miluphpc.h

Go to the documentation of this file.

 
#ifndef MILUPHPC_MILUPHPC_H
#define MILUPHPC_MILUPHPC_H
 
#include "particle_handler.h"
#include "subdomain_key_tree/tree_handler.h"
#include "subdomain_key_tree/subdomain_handler.h"
#include "device_rhs.cuh"
#include "cuda_utils/cuda_utilities.cuh"
#include "utils/logger.h"
#include "utils/timer.h"
#include "materials/material_handler.h"
#include "helper_handler.h"
#include "gravity/gravity.cuh"
#include "sph/sph.cuh"
#include "cuda_utils/cuda_runtime.h"
#include "utils/cxxopts.h"
#include "utils/h5profiler.h"
#include "sph/kernel.cuh"
#include "sph/kernel_handler.cuh"
#include "sph/density.cuh"
#include "sph/pressure.cuh"
#include "sph/internal_forces.cuh"
#include "sph/soundspeed.cuh"
#include "simulation_time_handler.h"
 
#include "processing/kernels.cuh"
 
#include <iostream>
#include <stdio.h>
#include <cuda.h>
#include <cuda_runtime.h>
#include <climits> // for ulong_max
#include <algorithm>
#include <cmath>
#include <utility>
#include <set>
#include <fstream>
#include <iomanip>
#include <random>
#include <fstream>
 
#include <boost/mpi/collectives/all_gatherv.hpp>
 
#include <highfive/H5File.hpp>
#include <highfive/H5DataSpace.hpp>
#include <highfive/H5DataSet.hpp>
 
class Miluphpc {
 
private:
 
    // @todo implement serial versions in order to reduce overhead due to parallelization
    //real serial_tree();
    //real serial_pseudoParticles();
    //real serial_gravity();
    //real serial_sph();
 
    real reset();
 
    real boundingBox();
 
    real parallel_tree();
 
    real parallel_pseudoParticles();
 
    real parallel_gravity();
 
    real parallel_sph();
 
    // @todo possible to combine sendPartclesEntry and sendParticles
    template <typename T>
    integer sendParticlesEntry(integer *sendLengths, integer *receiveLengths, T *entry, T *entryBuffer, T *copyBuffer);
    //void exchangeParticleEntry(integer *sendLengths, integer *receiveLengths, real *entry);
 
    template <typename T>
    integer sendParticles(T *sendBuffer, T *receiveBuffer, integer *sendLengths, integer *receiveLengths);
 
    template <typename U, typename T>
    real arrangeParticleEntries(U *sortArray, U *sortedArray, T *entry, T *temp);
 
    real assignParticles();
 
    real angularMomentum();
 
    real energy();
 
public:
 
    int subStep;
 
    real h_searchRadius;
 
    real totalEnergy;
 
    real totalAngularMomentum;
 
    real removeParticles();
 
    void fixedLoadBalancing();
 
    void dynamicLoadBalancing(int bins=5000);
 
    void updateRangeApproximately(int aimedParticlesPerProcess, int bins=5000);
 
    void updateRange(int aimedParticlesPerProcess);
 
    H5Profiler &profiler = H5Profiler::getInstance("log/performance.h5");
 
    Curve::Type curveType;
 
    SPH::KernelHandler kernelHandler;
    SimulationTimeHandler *simulationTimeHandler;
 
    integer numParticles;
    integer sumParticles;
    integer numParticlesLocal;
    integer numNodes;
 
    IntegratedParticleHandler *integratedParticles;
 
    integer *d_mutex;
    ParticleHandler *particleHandler;
    SubDomainKeyTreeHandler *subDomainKeyTreeHandler;
    TreeHandler *treeHandler;
    DomainListHandler *domainListHandler;
    DomainListHandler *lowestDomainListHandler;
    MaterialHandler *materialHandler;
 
    //HelperHandler *helperHandler;
    HelperHandler *buffer;
 
    // testing
    //integer *d_particles2SendIndices;
    //integer *d_pseudoParticles2SendIndices;
    //integer *d_pseudoParticles2SendLevels;
    //integer *d_pseudoParticles2ReceiveLevels;
    //integer *d_particles2SendCount;
    //integer *d_pseudoParticles2SendCount;
    //int *d_particles2removeBuffer;
    //int *d_particles2removeVal;
    //idInteger *d_idIntegerBuffer;
    //idInteger *d_idIntegerCopyBuffer;
    // end: testing
 
    SimulationParameters simulationParameters;
 
    Miluphpc(SimulationParameters simulationParameters);
 
    ~Miluphpc();
 
    void prepareSimulation();
 
    void numParticlesFromFile(const std::string& filename);
 
    void distributionFromFile(const std::string& filename);
 
    real tree();
 
    real pseudoParticles();
 
    real gravity();
 
    real sph();
 
    real rhs(int step, bool selfGravity=true, bool assignParticlesToProcess=true);
 
    virtual void integrate(int step = 0) = 0;
 
    void afterIntegrationStep();
 
    real particles2file(int step);
 
    real particles2file(const std::string& filename, int *particleIndices, int length);
 
    real configParameters2file(HighFive::File &h5file);
 
    void getMemoryInfo();
 
};
 
#endif //MILUPHPC_MILUPHPC_H