milupHPC/particle__handler_8cpp_source.html

#include "../include/particle_handler.h"


ParticleHandler::ParticleHandler(integer numParticles, integer numNodes) : numParticles(numParticles),

                                                                            numNodes(numNodes) {


    Logger(INFO) << "numParticles: " << numParticles << "   numNodes: " << numNodes;


    h_mass = new real[numNodes];

    _h_x = new real[numNodes];

    h_x = _h_x;

    _h_vx = new real[numParticles]; // numNodes

    h_vx = _h_vx;

    _h_ax = new real[numParticles]; // numNodes

    h_ax = _h_ax;

    h_g_ax = new real[numParticles]; // numNodes

#if DIM > 1

    _h_y = new real[numNodes];

    h_y = _h_y;

    _h_vy = new real[numParticles]; // numNodes

    h_vy = _h_vy;

    _h_ay = new real[numParticles]; // numNodes

    h_ay = _h_ay;

    h_g_ay = new real[numParticles]; // numNodes

#if DIM == 3

    _h_z = new real[numNodes];

    h_z = _h_z;

    _h_vz = new real[numParticles]; // numNodes

    h_vz = _h_vz;

    _h_az = new real[numParticles]; // numNodes

    h_az = _h_az;

    h_g_az = new real[numParticles]; // numNodes

#endif

#endif


    h_nodeType = new integer[numNodes];

    h_level = new integer[numNodes];

    _h_uid = new idInteger[numParticles];

    h_uid = _h_uid;

    h_materialId = new integer[numParticles];


#if SPH_SIM


    _h_sml = new real[numParticles];

    h_sml = _h_sml;

    h_nnl = new integer[numParticles * MAX_NUM_INTERACTIONS];

    h_noi = new integer [numParticles];

    _h_e = new real[numParticles];

    h_e = _h_e;

    _h_dedt = new real[numParticles];

    h_dedt = _h_dedt;

    h_u = new real[numParticles];

    _h_cs = new real[numParticles];

    h_cs = _h_cs;

    _h_rho = new real[numParticles];

    h_rho = _h_rho;

    _h_p = new real[numParticles];

    h_p = _h_p;

    h_muijmax = new real[numParticles];


//#if INTEGRATE_DENSITY

    _h_drhodt = new real[numParticles];

    h_drhodt = _h_drhodt;

//#endif

#if VARIABLE_SML || INTEGRATE_SML

    _h_dsmldt = new real[numParticles];

    h_dsmldt = _h_dsmldt;

#endif

#if SML_CORRECTION

    h_sml_omega = new real[numParticles];

#endif

#if NAVIER_STOKES

    h_Tshear = new real[DIM * DIM * numParticles];

    h_eta = new real[DIM * DIM * numParticles];

#endif

#if SOLID

    h_S = new real[DIM * DIM * numParticles];

    h_dSdt = new real[DIM * DIM * numParticles];

    h_localStrain = new real[numParticles];

#endif

#if SOLID || NAVIER_STOKES

    h_sigma = new real[DIM * DIM * numParticles];

#endif

#if ARTIFICIAL_STRESS

    h_R = new real[DIM * DIM * numParticles];;

#endif

#if POROSITY

    h_pold = new real[numParticles];

    h_alpha_jutzi = new real[numParticles];

    h_alpha_jutzi_old = new real[numParticles];

    h_dalphadt = new real[numParticles];

    h_dalphadp = new real[numParticles];

    h_dp = new real[numParticles];

    h_dalphadrho = new real[numParticles];

    h_f = new real[numParticles];

    h_delpdelrho = new real[numParticles];

    h_delpdele = new real[numParticles];

    h_cs_old = new real[numParticles];

    h_alpha_epspor = new real[numParticles];

    h_dalpha_epspordt = new real[numParticles];

    h_epsilon_v = new real[numParticles];

    h_depsilon_vdt = new real[numParticles];

#endif

#if ZERO_CONSISTENCY

    h_shepardCorrection = new real[numParticles];

#endif

#if LINEAR_CONSISTENCY

    h_tensorialCorrectionMatrix = new real[DIM * DIM * numParticles];

#endif

#if FRAGMENTATION

    h_d = new real[numParticles];

    h_damage_total = new real[numParticles];

    h_dddt = new real[numParticles];

    h_numFlaws = new integer[numParticles];

    h_maxNumFlaws = new integer[numParticles];

    h_numActiveFlaws = new integer[numParticles];

    h_flaws = new real[numParticles];

#if PALPHA_POROSITY

    h_damage_porjutzi = new real[numParticles];

    h_ddamage_porjutzidt = new real[numParticles];

#endif

#endif


#endif // SPH_SIM


    h_particles = new Particles();


    cuda::malloc(d_numParticles, 1);

    cuda::malloc(d_numNodes, 1);


    //real *d_positions;

    //cuda::malloc(d_positions, DIM * numNodes);

    cuda::malloc(d_mass, numNodes);

    cuda::malloc(_d_x, numNodes);

    //_d_x = &d_positions[0];

    d_x = _d_x;

    cuda::malloc(_d_vx, numParticles); // numNodes

    d_vx = _d_vx;

    cuda::malloc(_d_ax, numParticles); // numNodes

    d_ax = _d_ax;

    cuda::malloc(d_g_ax, numParticles); // numNodes

#if DIM > 1

    cuda::malloc(_d_y, numNodes);

    //_d_y = &d_positions[numNodes];

    d_y = _d_y;

    cuda::malloc(_d_vy, numParticles); // numNodes

    d_vy = _d_vy;

    cuda::malloc(_d_ay, numParticles); // numNodes

    d_ay = _d_ay;

    cuda::malloc(d_g_ay, numParticles); // numNodes

#if DIM == 3

    cuda::malloc(_d_z, numNodes);

    //_d_z = &d_positions[2 * numNodes];

    d_z = _d_z;

    cuda::malloc(_d_vz, numParticles); // numNodes

    d_vz = _d_vz;

    cuda::malloc(_d_az, numParticles); // numNodes

    d_az = _d_az;

    cuda::malloc(d_g_az, numParticles); // numNodes

#endif

#endif

    cuda::malloc(d_nodeType, numNodes);

    cuda::malloc(d_level, numNodes);

    cuda::malloc(_d_uid, numParticles);

    d_uid = _d_uid;

    cuda::malloc(d_materialId, numParticles);


#if SPH_SIM


    cuda::malloc(_d_sml, numParticles);

    d_sml = _d_sml;

    cuda::malloc(d_nnl, numParticles * MAX_NUM_INTERACTIONS);

    cuda::malloc(d_noi, numParticles);

    cuda::malloc(_d_e, numParticles);

    d_e = _d_e;

    cuda::malloc(_d_dedt, numParticles);

    d_dedt = _d_dedt;

    cuda::malloc(d_u, numParticles);

    cuda::malloc(_d_cs, numParticles);

    d_cs = _d_cs;

    cuda::malloc(_d_rho, numParticles);

    d_rho = _d_rho;

    cuda::malloc(_d_p, numParticles);

    d_p = _d_p;

    cuda::malloc(d_muijmax, numParticles);


//#if INTEGRATE_DENSITY

    cuda::malloc(_d_drhodt, numParticles);

    d_drhodt =_d_drhodt;

//#endif

#if VARIABLE_SML || INTEGRATE_SML

    cuda::malloc(_d_dsmldt, numParticles);

    d_dsmldt = _d_dsmldt;

#endif

#if SML_CORRECTION

    cuda::malloc(d_sml_omega, numParticles);

#endif

#if NAVIER_STOKES

    cuda::malloc(d_Tshear, DIM * DIM * numParticles);

    cuda::malloc(d_eta, DIM * DIM * numParticles);

#endif

#if SOLID

    cuda::malloc(d_S, DIM * DIM *numParticles);

    cuda::malloc(d_dSdt, DIM * numParticles);

    cuda::malloc(d_localStrain, numParticles);

#endif

#if SOLID || NAVIER_STOKES

    cuda::malloc(d_sigma, DIM * DIM * numParticles);

#endif

#if ARTIFICIAL_STRESS

    cuda::malloc(d_R, DIM * DIM * numParticles);

#endif

#if POROSITY

    cuda::malloc(d_pold, numParticles);

    cuda::malloc(d_alpha_jutzi, numParticles);

    cuda::malloc(d_alpha_jutzi_old, numParticles);

    cuda::malloc(d_dalphadt, numParticles);

    cuda::malloc(d_dalphadp, numParticles);

    cuda::malloc(d_dp, numParticles);

    cuda::malloc(d_dalphadrho, numParticles);

    cuda::malloc(d_f, numParticles);

    cuda::malloc(d_delpdelrho, numParticles);

    cuda::malloc(d_delpdele, numParticles);

    cuda::malloc(d_cs_old, numParticles);

    cuda::malloc(d_alpha_epspor, numParticles);

    cuda::malloc(d_dalpha_epspordt, numParticles);

    cuda::malloc(d_epsilon_v, numParticles);

    cuda::malloc(d_depsilon_vdt, numParticles);

#endif

#if ZERO_CONSISTENCY

    cuda::malloc(d_shepardCorrection, numParticles);

#endif

#if LINEAR_CONSISTENCY

    cuda::malloc(d_tensorialCorrectionMatrix, DIM * DIM * numParticles);

#endif

#if FRAGMENTATION

    cuda::malloc(d_d, numParticles);

    cuda::malloc(d_damage_total, numParticles);

    cuda::malloc(d_dddt, numParticles);

    cuda::malloc(d_numFlaws, numParticles);

    cuda::malloc(d_maxNumFlaws, numParticles);

    cuda::malloc(d_numActiveFlaws, numParticles);

    cuda::malloc(d_flaws, numParticles);

#if PALPHA_POROSITY

    cuda::malloc(d_damage_porjutzi, numParticles);

    cuda::malloc(d_ddamage_porjutzidt, numParticles);

#endif

#endif


#endif // SPH_SIM


#if BALSARA_SWITCH

    h_divv = new real[numParticles];

    h_curlv = new real[numParticles * DIM];

    cuda::malloc(d_divv, numParticles);

    cuda::malloc(d_curlv, numParticles * DIM);

#endif


    cuda::malloc(d_particles, 1);


#if DIM == 1

    h_particles->set(&numParticles, &numNodes, h_mass, h_x, h_vx, h_ax, h_level, h_uid, h_materialId, h_sml, h_nnl,

                     h_noi, h_e, h_dedt, h_cs, h_rho, h_p);

    ParticlesNS::Kernel::Launch::set(d_particles, d_numParticles, d_numNodes, d_mass, d_x, d_vx, d_ax, d_level, d_uid,

                                     d_materialId, d_sml, d_nnl, d_noi, d_e, d_dedt, d_cs, d_rho, d_p);

#elif DIM == 2

    h_particles->set(&numParticles, &numNodes, h_mass, h_x, h_y, h_vx, h_vy, h_ax, h_ay, h_level, h_uid, h_materialId,

                     h_sml, h_nnl, h_noi, h_e, h_dedt, h_cs, h_rho, h_p);

    ParticlesNS::Kernel::Launch::set(d_particles, d_numParticles, d_numNodes, d_mass, d_x, d_y, d_vx, d_vy, d_ax, d_ay,

                                     d_level, d_uid, d_materialId, d_sml, d_nnl, d_noi, d_e, d_dedt, d_cs, d_rho, d_p);

#else

    h_particles->set(&numParticles, &numNodes, h_mass, h_x, h_y, h_z, h_vx, h_vy, h_vz, h_ax, h_ay, h_az,

                     h_level, h_uid, h_materialId, h_sml, h_nnl, h_noi, h_e, h_dedt, h_cs, h_rho, h_p);

    ParticlesNS::Kernel::Launch::set(d_particles, d_numParticles, d_numNodes, d_mass, d_x, d_y, d_z, d_vx, d_vy, d_vz,

                                     d_ax, d_ay, d_az, d_level, d_uid, d_materialId, d_sml,

                                     d_nnl, d_noi, d_e, d_dedt, d_cs, d_rho, d_p);

#endif


#if DIM == 1

    h_particles->setGravity(h_g_ax);

    ParticlesNS::Kernel::Launch::setGravity(d_particles, d_g_ax);

#elif DIM == 2

    h_particles->setGravity(h_g_ax, h_g_ay);

    ParticlesNS::Kernel::Launch::setGravity(d_particles, d_g_ax, d_g_ay);

#else

    h_particles->setGravity(h_g_ax, h_g_ay, h_g_az);

    ParticlesNS::Kernel::Launch::setGravity(d_particles, d_g_ax, d_g_ay, d_g_az);

#endif


    h_particles->setNodeType(h_nodeType);

    ParticlesNS::Kernel::Launch::setNodeType(d_particles, d_nodeType);

    h_particles->setU(h_u);

    ParticlesNS::Kernel::Launch::setU(d_particles, d_u);


#if SPH_SIM

    h_particles->setArtificialViscosity(h_muijmax);

    ParticlesNS::Kernel::Launch::setArtificialViscosity(d_particles, d_muijmax);


//#if INTEGRATE_DENSITY

    h_particles->setIntegrateDensity(h_drhodt);

    ParticlesNS::Kernel::Launch::setIntegrateDensity(d_particles, d_drhodt);

//#endif

#if VARIABLE_SML || INTEGRATE_SML

    h_particles->setVariableSML(h_dsmldt);

    ParticlesNS::Kernel::Launch::setVariableSML(d_particles, d_dsmldt);

#endif

#if SML_CORRECTION

    h_particles->setSMLCorrection(h_sml_omega);

    ParticlesNS::Kernel::Launch::setSMLCorrection(d_particles, d_sml_omega);

#endif

#if NAVIER_STOKES

    h_particles->setNavierStokes(h_Tshear, h_eta);

    ParticlesNS::Kernel::Launch::setNavierStokes(d_particles, d_Tshear, d_eta);

#endif

#if SOLID

    h_particles->setSolid(h_S, h_dSdt, h_localStrain);

    ParticlesNS::Kernel::Launch::setSolid(d_particles, d_S, d_dSdt, d_localStrain);

#endif

#if SOLID || NAVIER_STOKES

    h_particles->setSolidNavierStokes(h_sigma);

    ParticlesNS::Kernel::Launch::setSolidNavierStokes(d_particles, d_sigma);

#endif

#if ARTIFICIAL_STRESS

    h_particles->setArtificialStress(h_R);

    ParticlesNS::Kernel::Launch::setArtificialStress(d_particles, d_R);

#endif

#if POROSITY

    h_particles->setPorosity(h_pold, h_alpha_jutzi, h_alpha_jutzi_old, h_dalphadt, h_dalphadp, h_dp, h_dalphadrho, h_f,

                             h_delpdelrho, h_delpdele, h_cs_old, h_alpha_epspor, h_dalpha_epspordt, h_epsilon_v,

                             h_depsilon_vdt);

    ParticlesNS::Kernel::Launch::setPorosity(d_particles, d_pold, d_alpha_jutzi, d_alpha_jutzi_old, d_dalphadt,

                                             d_dalphadp, d_dp, d_dalphadrho, d_f, d_delpdelrho, d_delpdele, d_cs_old,

                                             d_alpha_epspor, d_dalpha_epspordt, d_epsilon_v, d_depsilon_vdt);

#endif

#if ZERO_CONSISTENCY

    h_particles->setZeroConsistency(h_shepardCorrection);

    ParticlesNS::Kernel::Launch::setZeroConsistency(d_particles, d_shepardCorrection);

#endif

#if LINEAR_CONSISTENCY

    h_particles->setLinearConsistency(h_tensorialCorrectionMatrix);

    ParticlesNS::Kernel::Launch::setLinearConsistency(d_particles, d_tensorialCorrectionMatrix);

#endif

#if FRAGMENTATION

    h_particles->setFragmentation(h_d, h_damage_total, h_dddt, h_numFlaws, h_maxNumFlaws,

                                  h_numActiveFlaws, h_flaws);

    ParticlesNS::Kernel::Launch::setFragmentation(d_particles, d_d, d_damage_total, d_dddt, d_numFlaws, d_maxNumFlaws,

                                                  d_numActiveFlaws, d_flaws);

#if PALPHA_POROSITY

    h_particles->setPalphaPorosity(h_damage_porjutzi, h_ddamage_porjutzidt);

    ParticlesNS::Kernel::Launch::setPalphaPorosity(d_particles, d_damage_porjutzi, d_ddamage_porjutzidt);

#endif

#endif

#endif // SPH_SIM


#if BALSARA_SWITCH

    h_particles->setDivCurl(h_divv, h_curlv);

    ParticlesNS::Kernel::Launch::setDivCurl(d_particles, d_divv, d_curlv);

#endif


    cuda::copy(&numParticles, d_numParticles, 1, To::device);

    cuda::copy(&numNodes, d_numNodes, 1, To::device);


}


ParticleHandler::~ParticleHandler() {


    delete [] h_mass;

    delete [] _h_x;

    delete [] _h_vx;

    delete [] _h_ax;

    delete [] h_g_ax;

#if DIM > 1

    delete [] _h_y;

    delete [] _h_vy;

    delete [] _h_ay;

    delete [] h_g_ay;

#if DIM == 3

    delete [] _h_z;

    delete [] _h_vz;

    delete [] _h_az;

    delete [] h_g_az;

#endif

#endif

    delete [] h_nodeType;

    delete [] h_uid;

    delete [] h_materialId;

#if SPH_SIM

    delete [] _h_sml;

    delete [] h_nnl;

    delete [] h_noi;

    delete [] _h_e;

    delete [] _h_dedt;

    delete [] _h_cs;

    delete [] _h_rho;

    delete [] _h_p;

    delete [] h_muijmax;

#endif // SPH_SIM


    // device particle entries

    cuda::free(d_numParticles);

    cuda::free(d_numNodes);


    cuda::free(d_mass);

    cuda::free(_d_x);

    cuda::free(_d_vx);

    cuda::free(_d_ax);

    cuda::free(d_g_ax);

#if DIM > 1

    cuda::free(_d_y);

    cuda::free(_d_vy);

    cuda::free(_d_ay);

    cuda::free(d_g_ay);

#if DIM == 3

    cuda::free(_d_z);

    cuda::free(_d_vz);

    cuda::free(_d_az);

    cuda::free(d_g_az);

#endif

#endif

    cuda::free(d_nodeType);

    cuda::free(d_uid);

    cuda::free(d_materialId);

#if SPH_SIM

    cuda::free(_d_sml);

    cuda::free(d_nnl);

    cuda::free(d_noi);

    cuda::free(_d_e);

    cuda::free(_d_dedt);

    cuda::free(_d_cs);

    cuda::free(_d_rho);

    cuda::free(_d_p);

    cuda::free(d_muijmax);

#endif // SPH_SIM


#if SPH_SIM

    delete [] h_muijmax;

    cuda::free(d_muijmax);


//#if INTEGRATE_DENSITY

    delete [] _h_drhodt;

    cuda::free(_d_drhodt);

//#endif

#if VARIABLE_SML || INTEGRATE_SML

    delete [] _h_dsmldt;

    cuda::free(_d_dsmldt);

#endif

#if SML_CORRECTION

    delete [] h_sml_omega;

    cuda::free(d_sml_omega);

#endif

#if NAVIER_STOKES

    delete [] h_Tshear;

    cuda::free(d_Tshear);

    delete [] h_eta;

    cuda::free(d_eta);

#endif

#if SOLID

    delete [] h_S;

    cuda::free(d_S);

    delete [] h_dSdt;

    cuda::free(d_dSdt);

    delete [] h_localStrain;

    cuda::free(d_localStrain);

#endif

#if SOLID || NAVIER_STOKES

    delete [] h_sigma;

    cuda::free(d_sigma);

#endif

#if ARTIFICIAL_STRESS

    delete [] h_R;

    cuda::free(d_R);

#endif

#if POROSITY

    delete [] h_pold;

    cuda::free(d_pold);

    delete [] h_alpha_jutzi;

    cuda::free(d_alpha_jutzi);

    delete [] h_alpha_jutzi_old;

    cuda::free(d_alpha_jutzi_old);

    delete [] h_dalphadt;

    cuda::free(d_dalphadt);

    delete [] h_dalphadp;

    cuda::free(d_dalphadp);

    delete [] h_dp;

    cuda::free(d_dp);

    delete [] h_dalphadrho;

    cuda::free(d_dalphadrho);

    delete [] h_f;

    cuda::free(d_f);

    delete [] h_delpdelrho;

    cuda::free(d_delpdelrho);

    delete [] h_delpdele;

    cuda::free(d_delpdele);

    delete [] h_cs_old;

    cuda::free(d_cs_old);

    delete [] h_alpha_epspor;

    cuda::free(d_alpha_epspor);

    delete [] h_dalpha_epspordt;

    cuda::free(d_dalpha_epspordt);

    delete [] h_epsilon_v;

    cuda::free(d_epsilon_v);

    delete [] h_depsilon_vdt;

    cuda::free(d_depsilon_vdt);

#endif

#if ZERO_CONSISTENCY

    delete [] h_shepardCorrection;

    cuda::free(d_shepardCorrection);

#endif

#if LINEAR_CONSISTENCY

    delete [] h_tensorialCorrectionMatrix;

    cuda::free(d_tensorialCorrectionMatrix);

#endif

#if FRAGMENTATION

    delete [] h_d;

    cuda::free(d_d);

    delete [] h_damage_total;

    cuda::free(d_damage_total);

    delete [] h_dddt;

    cuda::free(d_dddt);

    delete [] h_numFlaws;

    cuda::free(d_numFlaws);

    delete [] h_maxNumFlaws;

    cuda::free(d_maxNumFlaws);

    delete [] h_numActiveFlaws;

    cuda::free(d_numActiveFlaws);

    delete [] h_flaws;

    cuda::free(d_flaws);

#if PALPHA_POROSITY

    delete [] h_damage_porjutzi;

    cuda::free(d_damage_porjutzi);

    delete [] h_ddamage_porjutzidt;

    cuda::free(d_ddamage_porjutzidt);

#endif

#endif

#endif // SPH_SIM


#if BALSARA_SWITCH

    delete [] h_divv;

    delete [] h_curlv;

    cuda::free(d_divv);

    cuda::free(d_curlv);

#endif


    delete h_particles;

    cuda::free(d_particles);


}


void ParticleHandler::initLeapfrog() {


    leapfrog = true;


    // TODO: should be numParticles instead of numNodes

    h_ax_old = new real[numNodes];

    h_g_ax_old = new real[numNodes];

    cuda::malloc(d_ax_old, numNodes);

    cuda::set(d_ax_old, (real)0, numNodes);

    cuda::malloc(d_g_ax_old, numNodes);

    cuda::set(d_g_ax_old, (real)0, numNodes);

#if DIM > 1

    h_ay_old = new real[numNodes];

    h_g_ay_old = new real[numNodes];

    cuda::malloc(d_ay_old, numNodes);

    cuda::set(d_ay_old, (real)0, numNodes);

    cuda::malloc(d_g_ay_old, numNodes);

    cuda::set(d_g_ay_old, (real)0, numNodes);

#if DIM == 3

    h_az_old = new real[numNodes];

    h_g_az_old = new real[numNodes];

    cuda::malloc(d_az_old, numNodes);

    cuda::set(d_az_old, (real)0, numNodes);

    cuda::malloc(d_g_az_old, numNodes);

    cuda::set(d_g_az_old, (real)0, numNodes);

#endif

#endif


#if DIM == 1


#elif DIM == 2


#else

    h_particles->setLeapfrog(h_ax_old, h_ay_old, h_az_old, h_g_ax_old, h_g_ay_old, h_g_az_old);

    ParticlesNS::Kernel::Launch::setLeapfrog(d_particles, d_ax_old, d_ay_old, d_az_old, d_g_ax_old, d_g_ay_old, d_g_az_old);

#endif


}


void ParticleHandler::freeLeapfrog() {


    delete h_g_ax_old;

    cuda::free(d_g_ax_old);

#if DIM > 1

    delete h_g_ay_old;

    cuda::free(d_g_ay_old);

#if DIM == 3

    delete h_g_az_old;

    cuda::free(d_g_az_old);

#endif

#endif


}


template <typename T>

T*& ParticleHandler::getEntry(Entry::Name entry, Execution::Location location) {

    switch (location) {

        case Execution::device: {

            switch (entry) {

                case Entry::x: {

                    return d_x;

                }

#if DIM > 1

                case Entry::y: {

                    return d_y;

                }

#if DIM == 3

                case Entry::z: {

                    return d_z;

                }

#endif

#endif

                case Entry::mass: {

                    return d_mass;

                }

                default: {

                    printf("Entry is not available!\n");

                    return NULL;

                }

            }

        } break;

        case Execution::host: {

            switch (entry) {

                case Entry::x: {

                    return h_x;

                }

#if DIM > 1

                case Entry::y: {

                    return h_y;

                }

#if DIM == 3

                case Entry::z: {

                    return h_z;

                }

#endif

#endif

                case Entry::mass: {

                    return h_mass;

                } break;

                default: {

                    printf("Entry is not available!\n");

                    return NULL;

                }

            }

        } break;

        default: {

            printf("Location is not available!\n");

            return NULL;

        }

    }

}


void ParticleHandler::setPointer(IntegratedParticleHandler *integratedParticleHandler) {


    d_x = integratedParticleHandler->d_x;

    d_vx = integratedParticleHandler->d_vx;

    d_ax = integratedParticleHandler->d_ax;

#if DIM > 1

    d_y = integratedParticleHandler->d_y;

    d_vy = integratedParticleHandler->d_vy;

    d_ay = integratedParticleHandler->d_ay;

#if DIM == 3

    d_z = integratedParticleHandler->d_z;

    d_vz = integratedParticleHandler->d_vz;

    d_az = integratedParticleHandler->d_az;

#endif

#endif

    d_uid = integratedParticleHandler->d_uid;


#if SPH_SIM

    d_rho = integratedParticleHandler->d_rho;

    d_e = integratedParticleHandler->d_e;

    d_dedt = integratedParticleHandler->d_dedt;

    d_p = integratedParticleHandler->d_p;

    d_cs = integratedParticleHandler->d_cs;

    d_sml = integratedParticleHandler->d_sml;


//#if INTEGRATE_DENSITY

    d_drhodt = integratedParticleHandler->d_drhodt;

//#endif


#if VARIABLE_SML || INTEGRATE_SML

    d_dsmldt = integratedParticleHandler->d_dsmldt;

#endif

#endif // SPH_SIM


// Already redirected pointers, thus just call setter like in constructor

#if DIM == 1

    h_particles->set(&numParticles, &numNodes, h_mass, h_x, h_vx, h_ax, h_level, h_uid, h_materialId, h_sml, h_nnl,

                     h_noi, h_e, h_dedt, h_cs, h_rho, h_p);

    ParticlesNS::Kernel::Launch::set(d_particles, d_numParticles, d_numNodes, d_mass, d_x, d_vx, d_ax, d_level, d_uid,

                                     d_materialId, d_sml, d_nnl, d_noi, d_e, d_dedt, d_cs, d_rho, d_p);

#elif DIM == 2

    h_particles->set(&numParticles, &numNodes, h_mass, h_x, h_y, h_vx, h_vy, h_ax, h_ay, h_level, h_uid, h_materialId,

                     h_sml, h_nnl, h_noi, h_e, h_dedt, h_cs, h_rho, h_p);

    ParticlesNS::Kernel::Launch::set(d_particles, d_numParticles, d_numNodes, d_mass, d_x, d_y, d_vx, d_vy, d_ax, d_ay,

                                     d_level, d_uid, d_materialId, d_sml, d_nnl, d_noi, d_e, d_dedt, d_cs, d_rho, d_p);

#else

    h_particles->set(&numParticles, &numNodes, h_mass, h_x, h_y, h_z, h_vx, h_vy, h_vz, h_ax, h_ay, h_az,

                     h_level, h_uid, h_materialId, h_sml, h_nnl, h_noi, h_e, h_dedt, h_cs, h_rho, h_p);

    h_particles->setIntegrateDensity(h_drhodt);


#if SPH_SIM

#if VARIABLE_SML || INTEGRATE_SML

    h_particles->setVariableSML(h_dsmldt);

#endif


    ParticlesNS::Kernel::Launch::set(d_particles, d_numParticles, d_numNodes, d_mass, d_x, d_y, d_z, d_vx, d_vy, d_vz,

                                     d_ax, d_ay, d_az, d_level, d_uid, d_materialId, d_sml,

                                     d_nnl, d_noi, d_e, d_dedt, d_cs, d_rho, d_p);

    ParticlesNS::Kernel::Launch::setIntegrateDensity(d_particles, d_drhodt);

#if VARIABLE_SML || INTEGRATE_SML

    ParticlesNS::Kernel::Launch::setVariableSML(d_particles, d_dsmldt);

#endif

#endif

#endif // SPH_SIM


}


void ParticleHandler::resetPointer() {


    d_x = _d_x;

    d_vx = _d_vx;

    d_ax = _d_ax;

#if DIM > 1

    d_y = _d_y;

    d_vy = _d_vy;

    d_ay = _d_ay;

#if DIM == 3

    d_z = _d_z;

    d_vz = _d_vz;

    d_az = _d_az;

#endif

#endif


    d_uid = _d_uid;


#if SPH_SIM

    d_rho = _d_rho;

    d_e = _d_e;

    d_dedt = _d_dedt;

    d_p = _d_p;

    d_cs = _d_cs;

    d_sml = _d_sml;


//#if INTEGRATE_DENSITY

    d_drhodt = _d_drhodt;

//#endif


#if VARIABLE_SML || INTEGRATE_SML

    d_dsmldt = _d_dsmldt;

#endif

#endif // SPH_SIM


#if DIM == 1

    h_particles->set(&numParticles, &numNodes, h_mass, h_x, h_vx, h_ax, h_level, h_uid, h_materialId, h_sml, h_nnl,

                     h_noi, h_e, h_dedt, h_cs, h_rho, h_p);

    ParticlesNS::Kernel::Launch::set(d_particles, d_numParticles, d_numNodes, d_mass, d_x, d_vx, d_ax, d_level, d_uid,

                                     d_materialId, d_sml, d_nnl, d_noi, d_e, d_dedt, d_cs, d_rho, d_p);

#elif DIM == 2

    h_particles->set(&numParticles, &numNodes, h_mass, h_x, h_y, h_vx, h_vy, h_ax, h_ay, h_level, h_uid, h_materialId,

                     h_sml, h_nnl, h_noi, h_e, h_dedt, h_cs, h_rho, h_p);

    ParticlesNS::Kernel::Launch::set(d_particles, d_numParticles, d_numNodes, d_mass, d_x, d_y, d_vx, d_vy, d_ax, d_ay,

                                     d_level, d_uid, d_materialId, d_sml, d_nnl, d_noi, d_e, d_dedt, d_cs, d_rho, d_p);

#else

    h_particles->set(&numParticles, &numNodes, h_mass, h_x, h_y, h_z, h_vx, h_vy, h_vz, h_ax, h_ay, h_az,

                     h_level, h_uid, h_materialId, h_sml, h_nnl, h_noi, h_e, h_dedt, h_cs, h_rho, h_p);

    h_particles->setIntegrateDensity(h_drhodt);


#if SPH_SIM

#if VARIABLE_SML || INTEGRATE_SML

    h_particles->setVariableSML(h_dsmldt);

#endif


    ParticlesNS::Kernel::Launch::set(d_particles, d_numParticles, d_numNodes, d_mass, d_x, d_y, d_z, d_vx, d_vy, d_vz,

                                     d_ax, d_ay, d_az, d_level, d_uid, d_materialId, d_sml,

                                     d_nnl, d_noi, d_e, d_dedt, d_cs, d_rho, d_p);

    ParticlesNS::Kernel::Launch::setIntegrateDensity(d_particles, d_drhodt);

#if VARIABLE_SML || INTEGRATE_SML

    ParticlesNS::Kernel::Launch::setVariableSML(d_particles, d_dsmldt);

#endif

#endif

#endif // SPH_SIM


}


void ParticleHandler::copyMass(To::Target target, bool includePseudoParticles) {

    int length;

    if (includePseudoParticles) {

        length = numNodes;

    }

    else {

        length = numParticles;

    }

    cuda::copy(h_mass, d_mass, length, target);

}


void ParticleHandler::copyUid(To::Target target) {

    int length = numParticles;

    cuda::copy(h_uid, d_uid, length, target);

}


void ParticleHandler::copyMatId(To::Target target) {

    int length = numParticles;

    cuda::copy(h_materialId, d_materialId, length, target);

}


void ParticleHandler::copySML(To::Target target) {

    int length = numParticles;

    cuda::copy(h_sml, d_sml, length, target);

}


void ParticleHandler::copyPosition(To::Target target, bool includePseudoParticles) {

    int length;

    if (includePseudoParticles) {

        length = numNodes;

    }

    else {

        length = numParticles;

    }

    cuda::copy(h_x, d_x, length, target);

#if DIM > 1

    cuda::copy(h_y, d_y, length, target);

#if DIM == 3

    cuda::copy(h_z, d_z, length, target);

#endif

#endif

}


void ParticleHandler::copyVelocity(To::Target target, bool includePseudoParticles) {

    int length = numParticles;

    //if (includePseudoParticles) {

    //    length = numNodes;

    //}

    //else {

    //    length = numParticles;

    //}

    cuda::copy(h_vx, d_vx, length, target);

#if DIM > 1

    cuda::copy(h_vy, d_vy, length, target);

#if DIM == 3

    cuda::copy(h_vz, d_vz, length, target);

#endif

#endif

}


void ParticleHandler::copyAcceleration(To::Target target, bool includePseudoParticles) {

    int length = numParticles;

    //if (includePseudoParticles) {

    //    length = numNodes;

    //}

    //else {

    //    length = numParticles;

    //}

    cuda::copy(h_ax, d_ax, length, target);

#if DIM > 1

    cuda::copy(h_ay, d_ay, length, target);

#if DIM == 3

    cuda::copy(h_az, d_az, length, target);

#endif

#endif

}


void ParticleHandler::copyDistribution(To::Target target, bool velocity, bool acceleration, bool includePseudoParticles) {

    copyUid(target);

    copyMass(target, includePseudoParticles);

    copyPosition(target, includePseudoParticles);

    copyMatId(target);

#if SPH_SIM

    copySML(target);

#endif

    if (velocity) {

        copyVelocity(target, includePseudoParticles);

    }

    if (acceleration) {

        copyAcceleration(target, includePseudoParticles);

    }

}


void ParticleHandler::copySPH(To::Target target) {

    int length = numParticles;

    cuda::copy(h_rho, d_rho, length, target);

    cuda::copy(h_p, d_p, length, target);

    cuda::copy(h_e, d_e, length, target);

    cuda::copy(h_sml, d_sml, length, target);

    cuda::copy(h_noi, d_noi, length, target);

    cuda::copy(h_cs, d_cs, length, target);

}


IntegratedParticleHandler::IntegratedParticleHandler(integer numParticles, integer numNodes) :

                                                        numParticles(numParticles), numNodes(numNodes) {


    cuda::malloc(d_uid, numParticles);


    cuda::malloc(d_x, numNodes);

    cuda::malloc(d_vx, numParticles); // numNodes

    cuda::malloc(d_ax, numParticles); // numNodes

#if DIM > 1

    cuda::malloc(d_y, numNodes);

    cuda::malloc(d_vy, numParticles); // numNodes

    cuda::malloc(d_ay, numParticles); // numNodes

#if DIM == 3

    cuda::malloc(d_z, numNodes);

    cuda::malloc(d_vz, numParticles); // numNodes

    cuda::malloc(d_az, numParticles); // numNodes

#endif

#endif


    cuda::malloc(d_rho, numParticles);

    cuda::malloc(d_e, numParticles);

    cuda::malloc(d_dedt, numParticles);

    cuda::malloc(d_p, numParticles);

    cuda::malloc(d_cs, numParticles);


    cuda::malloc(d_sml, numParticles);


//#if INTEGRATE_DENSITY

    cuda::malloc(d_drhodt, numParticles);

//#endif


#if VARIABLE_SML || INTEGRATE_SML

    cuda::malloc(d_dsmldt, numParticles);

#endif


    cuda::malloc(d_integratedParticles, 1);


#if DIM == 1

    IntegratedParticlesNS::Kernel::Launch::set(d_integratedParticles, d_uid, d_rho, d_e, d_dedt, d_p, d_cs, d_x,

                                               d_vx, d_ax);

#elif DIM == 2

    IntegratedParticlesNS::Kernel::Launch::set(d_integratedParticles, d_uid, d_rho, d_e, d_dedt, d_p, d_cs, d_x,

                                               d_y, d_vx, d_vy, d_ax, d_ay);

#else

    IntegratedParticlesNS::Kernel::Launch::set(d_integratedParticles, d_uid, d_rho, d_e, d_dedt, d_p, d_cs, d_x,

                                               d_y, d_z, d_vx, d_vy, d_vz, d_ax, d_ay, d_az);

#endif


    IntegratedParticlesNS::Kernel::Launch::setSML(d_integratedParticles, d_sml);


//#if INTEGRATE_DENSITY

    IntegratedParticlesNS::Kernel::Launch::setIntegrateDensity(d_integratedParticles, d_drhodt);

//#endif


#if VARIABLE_SML || INTEGRATE_SML

    IntegratedParticlesNS::Kernel::Launch::setIntegrateSML(d_integratedParticles, d_dsmldt);

#endif


}


IntegratedParticleHandler::~IntegratedParticleHandler() {


    cuda::free(d_uid);


    cuda::free(d_x);

    cuda::free(d_vx);

    cuda::free(d_ax);

#if DIM > 1

    cuda::free(d_y);

    cuda::free(d_vy);

    cuda::free(d_ay);

#if DIM == 3

    cuda::free(d_z);

    cuda::free(d_vz);

    cuda::free(d_az);

#endif

#endif


    cuda::free(d_rho);

    cuda::free(d_e);

    cuda::free(d_dedt);

    cuda::free(d_p);

    cuda::free(d_cs);


    cuda::free(d_sml);


//#if INTEGRATE_DENSITY

    cuda::free(d_drhodt);

//#endif


#if VARIABLE_SML || INTEGRATE_SML

    cuda::free(d_dsmldt);

#endif


    cuda::free(d_integratedParticles);


}


IntegratedParticleHandler
Definition: particle_handler.h:425

IntegratedParticleHandler::~IntegratedParticleHandler
~IntegratedParticleHandler()
Definition: particle_handler.cpp:959

IntegratedParticleHandler::d_integratedParticles
IntegratedParticles * d_integratedParticles
device instance of IntegratedParticles class
Definition: particle_handler.h:474

IntegratedParticleHandler::d_e
real * d_e
Definition: particle_handler.h:458

IntegratedParticleHandler::d_dedt
real * d_dedt
Definition: particle_handler.h:459

IntegratedParticleHandler::d_vz
real * d_vz
device time derivative of particle's z position
Definition: particle_handler.h:451

IntegratedParticleHandler::d_rho
real * d_rho
Definition: particle_handler.h:457

IntegratedParticleHandler::d_sml
real * d_sml
Definition: particle_handler.h:463

IntegratedParticleHandler::d_vy
real * d_vy
device time derivative of particle's y position
Definition: particle_handler.h:445

IntegratedParticleHandler::d_uid
idInteger * d_uid
device unique identifier
Definition: particle_handler.h:435

IntegratedParticleHandler::d_vx
real * d_vx
device time derivative of particle's x position
Definition: particle_handler.h:439

IntegratedParticleHandler::d_az
real * d_az
device time derivative of particle's z velocity
Definition: particle_handler.h:453

IntegratedParticleHandler::d_cs
real * d_cs
Definition: particle_handler.h:461

IntegratedParticleHandler::d_y
real * d_y
Definition: particle_handler.h:443

IntegratedParticleHandler::d_ay
real * d_ay
device time derivative of particle's y velocity
Definition: particle_handler.h:447

IntegratedParticleHandler::numParticles
integer numParticles
(host) number of particles
Definition: particle_handler.h:430

IntegratedParticleHandler::d_drhodt
real * d_drhodt
Definition: particle_handler.h:466

IntegratedParticleHandler::d_p
real * d_p
Definition: particle_handler.h:460

IntegratedParticleHandler::d_ax
real * d_ax
device time derivative of particle's x velocity
Definition: particle_handler.h:441

IntegratedParticleHandler::IntegratedParticleHandler
IntegratedParticleHandler(integer numParticles, integer numNodes)
Definition: particle_handler.cpp:899

IntegratedParticleHandler::numNodes
integer numNodes
(host) number of nodes
Definition: particle_handler.h:432

IntegratedParticleHandler::d_z
real * d_z
Definition: particle_handler.h:449

IntegratedParticleHandler::d_x
real * d_x
Definition: particle_handler.h:437

Logger
Logger class.
Definition: logger.h:80

ParticleHandler::d_materialId
integer * d_materialId
device material identifier
Definition: particle_handler.h:227

ParticleHandler::_d_ax
real * _d_ax
Definition: particle_handler.h:197

ParticleHandler::d_muijmax
real * d_muijmax
device max(mu_ij)
Definition: particle_handler.h:247

ParticleHandler::h_rho
real * h_rho
host density
Definition: particle_handler.h:80

ParticleHandler::h_noi
integer * h_noi
host number of interactions
Definition: particle_handler.h:70

ParticleHandler::d_numNodes
integer * d_numNodes
device number of nodes
Definition: particle_handler.h:187

ParticleHandler::h_az
real * h_az
host z acceleration
Definition: particle_handler.h:52

ParticleHandler::h_ax
real * h_ax
host x acceleration
Definition: particle_handler.h:34

ParticleHandler::_h_rho
real * _h_rho
Definition: particle_handler.h:80

ParticleHandler::d_dedt
real * d_dedt
device time derivative of internal energy
Definition: particle_handler.h:237

ParticleHandler::h_e
real * h_e
host internal energy
Definition: particle_handler.h:72

ParticleHandler::leapfrog
bool leapfrog
Definition: particle_handler.h:20

ParticleHandler::d_z
real * d_z
device z position
Definition: particle_handler.h:211

ParticleHandler::d_nnl
integer * d_nnl
device near(est) neighbor list
Definition: particle_handler.h:231

ParticleHandler::h_level
integer * h_level
Definition: particle_handler.h:60

ParticleHandler::d_ay
real * d_ay
device y acceleration
Definition: particle_handler.h:206

ParticleHandler::h_az_old
real * h_az_old
Definition: particle_handler.h:54

ParticleHandler::_h_sml
real * _h_sml
Definition: particle_handler.h:66

ParticleHandler::d_u
real * d_u
energy
Definition: particle_handler.h:239

ParticleHandler::d_az_old
real * d_az_old
Definition: particle_handler.h:217

ParticleHandler::d_mass
real * d_mass
device mass array
Definition: particle_handler.h:191

ParticleHandler::resetPointer
void resetPointer()
Definition: particle_handler.cpp:728

ParticleHandler::_d_drhodt
real * _d_drhodt
Definition: particle_handler.h:251

ParticleHandler::h_drhodt
real * h_drhodt
host time derivative of density
Definition: particle_handler.h:88

ParticleHandler::_h_e
real * _h_e
Definition: particle_handler.h:72

ParticleHandler::copyMass
void copyMass(To::Target target=To::device, bool includePseudoParticles=false)
Definition: particle_handler.cpp:796

ParticleHandler::_d_uid
idInteger * _d_uid
Definition: particle_handler.h:225

ParticleHandler::d_g_az
real * d_g_az
Definition: particle_handler.h:216

ParticleHandler::_d_rho
real * _d_rho
Definition: particle_handler.h:243

ParticleHandler::h_p
real * h_p
host pressure
Definition: particle_handler.h:82

ParticleHandler::d_g_ax
real * d_g_ax
Definition: particle_handler.h:198

ParticleHandler::d_ax_old
real * d_ax_old
Definition: particle_handler.h:199

ParticleHandler::h_vx
real * h_vx
host x velocity
Definition: particle_handler.h:32

ParticleHandler::h_ay_old
real * h_ay_old
Definition: particle_handler.h:45

ParticleHandler::h_y
real * h_y
host y position
Definition: particle_handler.h:39

ParticleHandler::_h_x
real * _h_x
Definition: particle_handler.h:30

ParticleHandler::d_ay_old
real * d_ay_old
Definition: particle_handler.h:208

ParticleHandler::getEntry
T *& getEntry(Entry::Name entry, Execution::Location location=Execution::device)
Definition: particle_handler.cpp:604

ParticleHandler::d_numParticles
integer * d_numParticles
device number of particles
Definition: particle_handler.h:185

ParticleHandler::d_az
real * d_az
device z acceleration
Definition: particle_handler.h:215

ParticleHandler::h_g_ay
real * h_g_ay
Definition: particle_handler.h:44

ParticleHandler::_h_vx
real * _h_vx
Definition: particle_handler.h:32

ParticleHandler::copyDistribution
void copyDistribution(To::Target target=To::device, bool velocity=true, bool acceleration=true, bool includePseudoParticles=false)
Definition: particle_handler.cpp:873

ParticleHandler::_d_sml
real * _d_sml
Definition: particle_handler.h:229

ParticleHandler::_d_vz
real * _d_vz
Definition: particle_handler.h:213

ParticleHandler::_h_az
real * _h_az
Definition: particle_handler.h:52

ParticleHandler::_h_vz
real * _h_vz
Definition: particle_handler.h:50

ParticleHandler::h_dedt
real * h_dedt
host time derivative of internal energy
Definition: particle_handler.h:74

ParticleHandler::d_g_ax_old
real * d_g_ax_old
Definition: particle_handler.h:199

ParticleHandler::d_e
real * d_e
device internal energy
Definition: particle_handler.h:235

ParticleHandler::d_nodeType
integer * d_nodeType
Definition: particle_handler.h:221

ParticleHandler::_h_cs
real * _h_cs
Definition: particle_handler.h:78

ParticleHandler::numNodes
integer numNodes
(host) number of nodes
Definition: particle_handler.h:25

ParticleHandler::d_vx
real * d_vx
device x velocity
Definition: particle_handler.h:195

ParticleHandler::d_particles
Particles * d_particles
device instance of particles class
Definition: particle_handler.h:350

ParticleHandler::h_particles
Particles * h_particles
host instance of particles class
Definition: particle_handler.h:348

ParticleHandler::copyMatId
void copyMatId(To::Target target=To::device)
Definition: particle_handler.cpp:812

ParticleHandler::freeLeapfrog
void freeLeapfrog()
Definition: particle_handler.cpp:588

ParticleHandler::_d_p
real * _d_p
Definition: particle_handler.h:245

ParticleHandler::h_u
real * h_u
energy
Definition: particle_handler.h:76

ParticleHandler::h_vz
real * h_vz
host z velocity
Definition: particle_handler.h:50

ParticleHandler::_h_uid
idInteger * _h_uid
Definition: particle_handler.h:62

ParticleHandler::_h_z
real * _h_z
Definition: particle_handler.h:48

ParticleHandler::copySML
void copySML(To::Target target=To::device)
Definition: particle_handler.cpp:817

ParticleHandler::copyUid
void copyUid(To::Target target=To::device)
Definition: particle_handler.cpp:807

ParticleHandler::h_nnl
integer * h_nnl
host near(est) neighbor list
Definition: particle_handler.h:68

ParticleHandler::_h_dedt
real * _h_dedt
Definition: particle_handler.h:74

ParticleHandler::_d_y
real * _d_y
Definition: particle_handler.h:202

ParticleHandler::h_g_az_old
real * h_g_az_old
Definition: particle_handler.h:54

ParticleHandler::h_ax_old
real * h_ax_old
Definition: particle_handler.h:36

ParticleHandler::copyPosition
void copyPosition(To::Target target=To::device, bool includePseudoParticles=false)
Definition: particle_handler.cpp:822

ParticleHandler::h_g_az
real * h_g_az
Definition: particle_handler.h:53

ParticleHandler::_h_y
real * _h_y
Definition: particle_handler.h:39

ParticleHandler::d_uid
idInteger * d_uid
device unique identifier
Definition: particle_handler.h:225

ParticleHandler::h_materialId
integer * h_materialId
host material identifier
Definition: particle_handler.h:64

ParticleHandler::h_x
real * h_x
host x position
Definition: particle_handler.h:30

ParticleHandler::_d_ay
real * _d_ay
Definition: particle_handler.h:206

ParticleHandler::d_ax
real * d_ax
device x acceleration
Definition: particle_handler.h:197

ParticleHandler::_d_e
real * _d_e
Definition: particle_handler.h:235

ParticleHandler::h_mass
real * h_mass
host mass
Definition: particle_handler.h:28

ParticleHandler::numParticles
integer numParticles
(host) number of particles
Definition: particle_handler.h:23

ParticleHandler::d_y
real * d_y
device y position
Definition: particle_handler.h:202

ParticleHandler::d_sml
real * d_sml
device smoothing length
Definition: particle_handler.h:229

ParticleHandler::setPointer
void setPointer(IntegratedParticleHandler *integratedParticleHandler)
Definition: particle_handler.cpp:661

ParticleHandler::d_vy
real * d_vy
device y velocity
Definition: particle_handler.h:204

ParticleHandler::d_g_az_old
real * d_g_az_old
Definition: particle_handler.h:217

ParticleHandler::h_sml
real * h_sml
host smoothing length
Definition: particle_handler.h:66

ParticleHandler::_h_vy
real * _h_vy
Definition: particle_handler.h:41

ParticleHandler::_d_x
real * _d_x
Definition: particle_handler.h:193

ParticleHandler::_d_vy
real * _d_vy
Definition: particle_handler.h:204

ParticleHandler::h_cs
real * h_cs
host speed of sound
Definition: particle_handler.h:78

ParticleHandler::h_nodeType
integer * h_nodeType
Definition: particle_handler.h:58

ParticleHandler::h_z
real * h_z
host z position
Definition: particle_handler.h:48

ParticleHandler::d_cs
real * d_cs
device speed of sound
Definition: particle_handler.h:241

ParticleHandler::~ParticleHandler
~ParticleHandler()
Definition: particle_handler.cpp:365

ParticleHandler::_d_cs
real * _d_cs
Definition: particle_handler.h:241

ParticleHandler::h_g_ay_old
real * h_g_ay_old
Definition: particle_handler.h:45

ParticleHandler::d_level
integer * d_level
Definition: particle_handler.h:223

ParticleHandler::_d_az
real * _d_az
Definition: particle_handler.h:215

ParticleHandler::h_ay
real * h_ay
host y acceleration
Definition: particle_handler.h:43

ParticleHandler::d_x
real * d_x
device x position
Definition: particle_handler.h:193

ParticleHandler::h_g_ax
real * h_g_ax
Definition: particle_handler.h:35

ParticleHandler::copyVelocity
void copyVelocity(To::Target target=To::device, bool includePseudoParticles=false)
Definition: particle_handler.cpp:839

ParticleHandler::d_drhodt
real * d_drhodt
device time derivative of density
Definition: particle_handler.h:251

ParticleHandler::copyAcceleration
void copyAcceleration(To::Target target=To::device, bool includePseudoParticles=false)
Definition: particle_handler.cpp:856

ParticleHandler::_h_p
real * _h_p
Definition: particle_handler.h:82

ParticleHandler::copySPH
void copySPH(To::Target target)
Definition: particle_handler.cpp:889

ParticleHandler::_h_ay
real * _h_ay
Definition: particle_handler.h:43

ParticleHandler::ParticleHandler
ParticleHandler(integer numParticles, integer numNodes)
Definition: particle_handler.cpp:3

ParticleHandler::h_muijmax
real * h_muijmax
host max(mu_ij)
Definition: particle_handler.h:84

ParticleHandler::d_g_ay_old
real * d_g_ay_old
Definition: particle_handler.h:208

ParticleHandler::_h_ax
real * _h_ax
Definition: particle_handler.h:34

ParticleHandler::d_noi
integer * d_noi
device number of interaction
Definition: particle_handler.h:233

ParticleHandler::d_p
real * d_p
device pressure
Definition: particle_handler.h:245

ParticleHandler::_h_drhodt
real * _h_drhodt
Definition: particle_handler.h:88

ParticleHandler::h_vy
real * h_vy
host y velocity
Definition: particle_handler.h:41

ParticleHandler::_d_dedt
real * _d_dedt
Definition: particle_handler.h:237

ParticleHandler::h_uid
idInteger * h_uid
host unique identifier
Definition: particle_handler.h:62

ParticleHandler::d_g_ay
real * d_g_ay
Definition: particle_handler.h:207

ParticleHandler::_d_z
real * _d_z
Definition: particle_handler.h:211

ParticleHandler::h_g_ax_old
real * h_g_ax_old
Definition: particle_handler.h:36

ParticleHandler::_d_vx
real * _d_vx
Definition: particle_handler.h:195

ParticleHandler::initLeapfrog
void initLeapfrog()
Definition: particle_handler.cpp:549

ParticleHandler::d_vz
real * d_vz
device z velocity
Definition: particle_handler.h:213

ParticleHandler::d_rho
real * d_rho
device density
Definition: particle_handler.h:243

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

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::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::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::setNodeType
CUDA_CALLABLE_MEMBER void setNodeType(integer *nodeType)
Setter for node type.
Definition: particles.cu:175

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

INFO
@ INFO
debug log type
Definition: logger.h:48

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

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::setNodeType
void setNodeType(Particles *particles, integer *nodeType)
Definition: particles.cu:740

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

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

cuda::copy
void copy(T *h_var, T *d_var, std::size_t count=1, To::Target copyTo=To::device)
Copy between host and device and vice-versa.
Definition: cuda_runtime.h:30

cuda::set
void set(T *d_var, T val, std::size_t count=1)
Set device memory to a specific value.
Definition: cuda_runtime.h:56

cuda::free
void free(T *d_var)
Free device memory.
Definition: cuda_runtime.h:81

cuda::malloc
void malloc(T *&d_var, std::size_t count)
Allocate device memory.
Definition: cuda_runtime.h:70

real
double real
Definition: parameter.h:15

MAX_NUM_INTERACTIONS
#define MAX_NUM_INTERACTIONS
Definition: parameter.h:106

integer
int integer
Definition: parameter.h:17

DIM
#define DIM
Dimension of the problem.
Definition: parameter.h:38

idInteger
int idInteger
Definition: parameter.h:19

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

Entry::mass
@ mass
Definition: parameter.h:263

Entry::y
@ y
Definition: parameter.h:258

Entry::x
@ x
Definition: parameter.h:256

Entry::z
@ z
Definition: parameter.h:260

Execution::Location
Location
Definition: parameter.h:192

Execution::device
@ device
Definition: parameter.h:193

Execution::host
@ host
Definition: parameter.h:193

To::Target
Target
Definition: parameter.h:164

To::device
@ device
Definition: parameter.h:165