milupHPC/main_8cpp_source.html

#include "../include/miluphpc.h"

#include "../include/integrator/explicit_euler.h"

#include "../include/integrator/predictor_corrector_euler.h"

#include "../include/integrator/leapfrog.h"

#include "../include/utils/config_parser.h"

#include <boost/filesystem.hpp>


#include <fenv.h>

#include <iostream>

#include <fstream>

#include <stdlib.h>

#include <string.h>

#include <random>


#define ENV_LOCAL_RANK "OMPI_COMM_WORLD_LOCAL_RANK"


bool checkFile(const std::string file, bool terminate=false, const std::string message="");

bool checkFile(const std::string file, bool terminate, const std::string message) {

    std::ifstream fileStream(file.c_str());

    if (fileStream.good()) {

        return true;

    }

    else {

        if (terminate) {

            Logger(WARN) << message;

            Logger(ERROR) << "Provided file: " << file << " not available!";

            MPI_Finalize();

            exit(0);

        }

        return false;

    }

}


void SetDeviceBeforeInit()

{

    char * localRankStr = NULL;

    int rank = 0;

    int devCount = 2;


    if ((localRankStr = getenv(ENV_LOCAL_RANK)) != NULL)

    {

        rank = atoi(localRankStr);

    }


    gpuErrorcheck(cudaGetDeviceCount(&devCount));

    //gpuErrorcheck(cudaSetDevice(rank % devCount));

    gpuErrorcheck(cudaSetDevice(rank % devCount));

}


structLog LOGCFG = {};


int main(int argc, char** argv)

{


    // -----------------------------------------------------------------------------------------------------------------


    SetDeviceBeforeInit();


    boost::mpi::environment env(argc, argv);

    boost::mpi::communicator comm;


    int rank = comm.rank();

    int numProcesses = comm.size();


    //cudaSetDevice(rank);

    int device;

    cudaGetDevice(&device);

    int numDevices;

    cudaGetDeviceCount(&numDevices);

    cudaDeviceSynchronize();


    cudaDeviceProp deviceProp;

    cudaGetDeviceProperties(&deviceProp, device);

    int numberOfMultiprocessors = deviceProp.multiProcessorCount;

    printf("numberOfMultiprocessors: %i\n", numberOfMultiprocessors);


    // testing whether MPI works ...

    //int mpi_test = rank;

    //all_reduce(comm, boost::mpi::inplace_t<int*>(&mpi_test), 1, std::plus<int>());

    //Logger(INFO) << "mpi_test = " << mpi_test;


    cxxopts::Options options("HPC NBody", "Multi-GPU CUDA Barnes-Hut NBody/SPH code");


    bool loadBalancing = false;


    options.add_options()

            ("n,number-output-files", "number of output files", cxxopts::value<int>()->default_value("100"))

            ("t,max-time-step", "time step", cxxopts::value<real>()->default_value("-1."))

            ("l,load-balancing", "load balancing", cxxopts::value<bool>(loadBalancing))

            ("L,load-balancing-interval", "load balancing interval", cxxopts::value<int>()->default_value("-1"))

            ("C,config", "config file", cxxopts::value<std::string>()->default_value("config/config.info"))

            ("m,material-config", "material config file", cxxopts::value<std::string>()->default_value("config/material.cfg"))

            ("c,curve-type", "curve type (Lebesgue: 0/Hilbert: 1)", cxxopts::value<int>()->default_value("-1"))

            ("f,input-file", "File name", cxxopts::value<std::string>()->default_value("-"))

            ("v,verbosity", "Verbosity level", cxxopts::value<int>()->default_value("0"))

            ("h,help", "Show this help");


    cxxopts::ParseResult result;

    try {

        result = options.parse(argc, argv);

    }

    catch (cxxopts::OptionException &exception) {

        std::cerr << exception.what();

        MPI_Finalize();

        exit(0);

    }

    catch (...) {

        std::cerr << "Error parsing ...";

        MPI_Finalize();

        exit(0);

    }


    if (result.count("help")) {

        if (rank == 0) {

            std::cout << options.help() << std::endl;

        }

        MPI_Finalize();

        exit(0);

    }


    std::string configFile = result["config"].as<std::string>();

    checkFile(configFile, true, std::string{"Provided config file not available!"});


    SimulationParameters parameters;


    parameters.verbosity = result["verbosity"].as<int>();

    LOGCFG.headers = true;

    if (parameters.verbosity == 0) {

        LOGCFG.level = TRACE;

    }

    else if (parameters.verbosity == 1) {

        LOGCFG.level = INFO;

    }

    else if (parameters.verbosity >= 2) {

        LOGCFG.level = DEBUG;

    }

    else {

        LOGCFG.level = TRACE;

    }

    //LOGCFG.level = static_cast<typeLog>(1); //TRACE; //DEBUG;

    LOGCFG.rank = rank;

    //LOGCFG.outputRank = 0;

    //Logger(DEBUG) << "DEBUG output";

    //Logger(WARN) << "WARN output";

    //Logger(ERROR) << "ERROR output";

    //Logger(INFO) << "INFO output";

    //Logger(TRACE) << "TRACE output";

    //Logger(TIME) << "TIME output";


    Logger(DEBUG) << "rank: " << rank << " | number of processes: " << numProcesses;

    Logger(DEBUG) << "device: " << device << " | num devices: " << numDevices;


    Logger(INFO) << "sizeof(keyType) = " << (int)sizeof(keyType); // intmax_t, uintmax_t

    Logger(INFO) << "sizeof(intmax_t) = " << (int)sizeof(intmax_t);

    Logger(INFO) << "sizeof(uintmax_t) = " << (int)sizeof(uintmax_t); // __int128

    Logger(INFO) << "sizeof(__int128) = " << (int)sizeof(__int128);


    ConfigParser confP{ConfigParser(configFile.c_str())}; //"config/config.info"

    LOGCFG.write2LogFile = confP.getVal<bool>("log");

    LOGCFG.omitTime = confP.getVal<bool>("omitTime");


    parameters.directory = confP.getVal<std::string>("directory");

    if (boost::filesystem::create_directories(parameters.directory)) {

        Logger(DEBUG) << "Created directory: " << parameters.directory;

    }

    parameters.logDirectory = parameters.directory + std::string{"log/"};

    if (boost::filesystem::create_directories(parameters.logDirectory)) {

        Logger(DEBUG) << "Created directory: " << parameters.logDirectory;

    }


    std::stringstream logFileName;

    logFileName << parameters.logDirectory << "miluphpc.log";

    LOGCFG.logFileName = logFileName.str();

    Logger(TRACE) << "log file to: " << logFileName.str();

    //MPI_Finalize();

    //exit(0);


    parameters.timeStep = confP.getVal<real>("timeStep");

    parameters.maxTimeStep = result["max-time-step"].as<real>();

    if (parameters.maxTimeStep < 0.) {

        parameters.maxTimeStep = confP.getVal<real>("maxTimeStep");

    }

    parameters.timeEnd = confP.getVal<real>("timeEnd");

    parameters.outputRank = confP.getVal<int>("outputRank");

    if (parameters.outputRank < 0 || parameters.outputRank >= numProcesses) {

        parameters.outputRank = -1; // if selected output rank is not valid, log all processes

    }

    LOGCFG.outputRank = parameters.outputRank;

    parameters.performanceLog = confP.getVal<bool>("performanceLog");

    parameters.particlesSent2H5 = confP.getVal<bool>("particlesSent2H5");

    parameters.sfcSelection = confP.getVal<int>("sfc");

    if (result["curve-type"].as<int>() != -1) {

        parameters.sfcSelection = result["curve-type"].as<int>();

    }

    parameters.integratorSelection = confP.getVal<int>("integrator");

//#if GRAVITY_SIM

    parameters.theta = confP.getVal<real>("theta");

    parameters.smoothing = confP.getVal<real>("smoothing");

    parameters.gravityForceVersion = confP.getVal<int>("gravityForceVersion");

//#endif

//#if SPH_SIM

    parameters.smoothingKernelSelection = confP.getVal<int>("smoothingKernel");

    parameters.sphFixedRadiusNNVersion = confP.getVal<int>("sphFixedRadiusNNVersion");

//#endif

    parameters.removeParticles = confP.getVal<bool>("removeParticles");

    parameters.removeParticlesCriterion = confP.getVal<int>("removeParticlesCriterion");

    parameters.removeParticlesDimension = confP.getVal<real>("removeParticlesDimension");

    parameters.numOutputFiles = result["number-output-files"].as<int>();

    parameters.timeKernels = true;

    parameters.loadBalancing = confP.getVal<bool>("loadBalancing");

    if (parameters.loadBalancing || loadBalancing) {

        parameters.loadBalancing = true;

    }

    parameters.loadBalancingInterval = confP.getVal<int>("loadBalancingInterval");

    if (result["load-balancing-interval"].as<int>() > 0) {

        parameters.loadBalancingInterval = result["load-balancing-interval"].as<int>();

    }

    parameters.loadBalancingBins = confP.getVal<int>("loadBalancingBins");

    parameters.verbosity = result["verbosity"].as<int>();

    parameters.materialConfigFile = result["material-config"].as<std::string>();

    parameters.inputFile = result["input-file"].as<std::string>();

    parameters.particleMemoryContingent = confP.getVal<real>("particleMemoryContingent");

    if (parameters.particleMemoryContingent > 1.0 || parameters.particleMemoryContingent < 0.0) {

        parameters.particleMemoryContingent = 1.0;

        Logger(WARN) << "Setting particle memory contingent to: " << parameters.particleMemoryContingent;

    }

    parameters.calculateCenterOfMass = confP.getVal<bool>("calculateCenterOfMass");

    //TODO: apply those

    parameters.calculateAngularMomentum = confP.getVal<bool>("calculateAngularMomentum");

    parameters.calculateEnergy = confP.getVal<bool>("calculateEnergy");


    // + 1 should not be necessary, but need to investigate whether this is a problem for 1 GPU sims

    parameters.domainListSize = POW_DIM * MAX_LEVEL * (numProcesses - 1) + 1;

    Logger(DEBUG) << "domainListSize: " << parameters.domainListSize;


    if (!checkFile(parameters.materialConfigFile, false)) {

        parameters.materialConfigFile = std::string{"config/material.cfg"};

        checkFile(parameters.materialConfigFile, true,

                  std::string{"Provided material config file and default (config/material.cfg) not available!"});

    }

    checkFile(parameters.inputFile, true, std::string{"Provided input file not available!"});


    // profiling

    std::stringstream profilerFile;

    profilerFile << parameters.logDirectory << "performance.h5";

    H5Profiler &profiler = H5Profiler::getInstance(profilerFile.str());

    profiler.setRank(comm.rank());

    profiler.setNumProcs(comm.size());

    if (!parameters.performanceLog) {

        profiler.disableWrite();

    }

    // General

    profiler.createValueDataSet<int>(ProfilerIds::numParticles, 1);

    profiler.createValueDataSet<int>(ProfilerIds::numParticlesLocal, 1);

    profiler.createVectorDataSet<keyType>(ProfilerIds::ranges, 1, comm.size() + 1);

    // Timing

    profiler.createValueDataSet<real>(ProfilerIds::Time::rhs, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::rhsElapsed, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::loadBalancing, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::reset, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::removeParticles, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::boundingBox, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::assignParticles, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::tree, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::pseudoParticle, 1);

#if GRAVITY_SIM

    profiler.createValueDataSet<real>(ProfilerIds::Time::gravity, 1);

    profiler.createVectorDataSet<int>(ProfilerIds::SendLengths::gravityParticles, 1, numProcesses);

    profiler.createVectorDataSet<int>(ProfilerIds::SendLengths::gravityPseudoParticles, 1, numProcesses);

    profiler.createVectorDataSet<int>(ProfilerIds::ReceiveLengths::gravityParticles, 1, numProcesses);

    profiler.createVectorDataSet<int>(ProfilerIds::ReceiveLengths::gravityPseudoParticles, 1, numProcesses);

#endif

#if SPH_SIM

    profiler.createValueDataSet<real>(ProfilerIds::Time::sph, 1);

    profiler.createVectorDataSet<int>(ProfilerIds::SendLengths::sph, 1, numProcesses);

    profiler.createVectorDataSet<int>(ProfilerIds::ReceiveLengths::sph, 1, numProcesses);

#endif

    // Detailed timing

    profiler.createValueDataSet<real>(ProfilerIds::Time::Tree::createDomain, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::Tree::tree, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::Tree::buildDomain, 1);

#if GRAVITY_SIM

    profiler.createValueDataSet<real>(ProfilerIds::Time::Gravity::compTheta, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::Gravity::symbolicForce, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::Gravity::sending, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::Gravity::insertReceivedPseudoParticles, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::Gravity::insertReceivedParticles, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::Gravity::force, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::Gravity::repairTree, 1);

#endif

#if SPH_SIM

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::compTheta, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::determineSearchRadii, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::symbolicForce, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::sending, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::insertReceivedParticles, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::fixedRadiusNN, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::density, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::soundSpeed, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::pressure, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::resend, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::internalForces, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::SPH::repairTree, 1);

#endif

    profiler.createValueDataSet<real>(ProfilerIds::Time::integrate, 1);

    profiler.createValueDataSet<real>(ProfilerIds::Time::IO, 1);


#if !SPH_SIM

    // TODO: default integrator for gravity-only simulation

    if (parameters.integratorSelection == IntegratorSelection::predictor_corrector_euler) {

        Logger(INFO) << "Gravity is decoupled! Therefore switching to explicit Euler integrator!";

        parameters.integratorSelection = IntegratorSelection::explicit_euler;

    }

#endif


    // -----------------------------------------------------------------------------------------------------------------

    Miluphpc *miluphpc;

    // miluphpc = new Miluphpc(parameters, numParticles, numNodes); // not possible since abstract class

    switch (parameters.integratorSelection) {

        case IntegratorSelection::explicit_euler: {

            miluphpc = new ExplicitEuler(parameters);

        } break;

        case IntegratorSelection::predictor_corrector_euler: {

            miluphpc = new PredictorCorrectorEuler(parameters);

        } break;

        case IntegratorSelection::leapfrog: {

            miluphpc = new Leapfrog(parameters);

        } break;

        default: {

            Logger(ERROR) << "Integrator not available!";

            MPI_Finalize();

            exit(1);

        }

    }


    if (rank == 0) {

        Logger(TRACE) << "---------------STARTING---------------";

    }


    Timer timer;

    real timeElapsed;

    // -----------------------------------------------------------------------------------------------------------------

    real t = 0;

    for (int i_step=0; i_step<parameters.numOutputFiles; i_step++) {


        //profiler.setStep(i_step);


        Logger(TRACE) << "-----------------------------------------------------------------";

        Logger(TRACE, true) << "STEP: " << i_step;

        Logger(TRACE) << "-----------------------------------------------------------------";


        *miluphpc->simulationTimeHandler->h_subEndTime += (parameters.timeEnd/(real)parameters.numOutputFiles);

        Logger(DEBUG) << "subEndTime += " << (parameters.timeEnd/(real)parameters.numOutputFiles);


        miluphpc->simulationTimeHandler->copy(To::device);


        miluphpc->integrate(i_step);

        miluphpc->afterIntegrationStep();


        timer.reset();

        auto time = miluphpc->particles2file(i_step);

        timeElapsed = timer.elapsed();

        Logger(TIME) << "particles2file: " << timeElapsed << " ms";

        profiler.value2file(ProfilerIds::Time::IO, timeElapsed);


        t += parameters.timeStep;


    }


    // -----------------------------------------------------------------------------------------------------------------

    comm.barrier();

    LOGCFG.outputRank = -1;

    if (rank == 0) {

        Logger(TRACE) << "\n\n";

        Logger(TRACE) << "---------------FINISHED---------------";

        Logger(TRACE) << "Input file: " << parameters.inputFile;

        Logger(TRACE) << "Config file: " << parameters.materialConfigFile;

        Logger(TRACE) << "Material config: " << parameters.materialConfigFile;

        if (LOGCFG.write2LogFile) {

            Logger(TRACE) << "Log file saved to: " << LOGCFG.logFileName;

        }

        if (parameters.performanceLog) {

            Logger(TRACE) << "Performance log saved to " << profilerFile.str();

        }

        if (parameters.particlesSent2H5) {

            Logger(TRACE) << "(Most recent) particles sent saved to: " << parameters.logDirectory;

        }

        Logger(TRACE) << "Generated " << parameters.numOutputFiles << " files!";

        Logger(TRACE) << "Data saved to " << parameters.directory;

        Logger(TRACE) << "---------------FINISHED---------------";

    }


    return 0;

}

ConfigParser
Config parser class for reading input parameter/settings.
Definition: config_parser.h:43

ExplicitEuler
Definition: explicit_euler.h:16

H5Profiler
Singleton class for HDF5 profiler.
Definition: h5profiler.h:118

H5Profiler::getInstance
static H5Profiler & getInstance(const std::string &outfile="")
Constructor/Instance getter for HDF5 profiler.
Definition: h5profiler.h:130

H5Profiler::setNumProcs
void const setNumProcs(const int &_numProcs)
Set number of MPI processes.
Definition: h5profiler.h:156

H5Profiler::createVectorDataSet
void createVectorDataSet(const std::string &path, int steps, std::size_t size, std::size_t maxSteps=HighFive::DataSpace::UNLIMITED)
Track vector values (per MPI rank).
Definition: h5profiler.h:226

H5Profiler::createValueDataSet
void createValueDataSet(const std::string &path, int steps, std::size_t maxSteps=HighFive::DataSpace::UNLIMITED)
Track single value (per MPI rank).
Definition: h5profiler.h:185

H5Profiler::setRank
void const setRank(const int &_myRank)
Set MPI rank.
Definition: h5profiler.h:150

H5Profiler::disableWrite
void const disableWrite()
Disable write to output file.
Definition: h5profiler.h:160

H5Profiler::value2file
void value2file(const std::string &path, T value)
Write value to single value data set.
Definition: h5profiler.h:202

Leapfrog
Definition: leapfrog.h:16

Logger
Logger class.
Definition: logger.h:80

Miluphpc
MilupHPC class.
Definition: miluphpc.h:74

Miluphpc::afterIntegrationStep
void afterIntegrationStep()
Definition: miluphpc.cpp:471

Miluphpc::integrate
virtual void integrate(int step=0)=0

Miluphpc::simulationTimeHandler
SimulationTimeHandler * simulationTimeHandler
Instance to handle the SimulationTime instances on device and host.
Definition: miluphpc.h:282

Miluphpc::particles2file
real particles2file(int step)
Definition: miluphpc.cpp:3409

PredictorCorrectorEuler
Definition: predictor_corrector_euler.h:42

SimulationTimeHandler::copy
void copy(To::Target target)
Definition: simulation_time_handler.cpp:56

SimulationTimeHandler::h_subEndTime
real * h_subEndTime
Definition: simulation_time_handler.h:21

Timer
Definition: timer.h:15

Timer::elapsed
double elapsed() const
Get elapsed time since instantiation/latest reset.
Definition: timer.cpp:22

Timer::reset
void reset()
Reset timer instance.
Definition: timer.cpp:11

gpuErrorcheck
#define gpuErrorcheck(ans)
check CUDA call
Definition: cuda_utilities.cuh:41

DEBUG
@ DEBUG
Definition: logger.h:47

ERROR
@ ERROR
warning log type
Definition: logger.h:51

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

WARN
@ WARN
trace log type
Definition: logger.h:50

TRACE
@ TRACE
info log type
Definition: logger.h:49

TIME
@ TIME
error log type
Definition: logger.h:52

ENV_LOCAL_RANK
#define ENV_LOCAL_RANK
Definition: main.cpp:15

main
int main(int argc, char **argv)
Definition: main.cpp:52

SetDeviceBeforeInit
void SetDeviceBeforeInit()
Definition: main.cpp:34

checkFile
bool checkFile(const std::string file, bool terminate=false, const std::string message="")
Definition: main.cpp:18

LOGCFG
structLog LOGCFG
Definition: main.cpp:50

ProfilerIds::ReceiveLengths::gravityParticles
const char *const gravityParticles
Definition: h5profiler.h:42

ProfilerIds::ReceiveLengths::gravityPseudoParticles
const char *const gravityPseudoParticles
Definition: h5profiler.h:43

ProfilerIds::ReceiveLengths::sph
const char *const sph
Definition: h5profiler.h:44

ProfilerIds::SendLengths::gravityPseudoParticles
const char *const gravityPseudoParticles
Definition: h5profiler.h:36

ProfilerIds::SendLengths::gravityParticles
const char *const gravityParticles
Definition: h5profiler.h:35

ProfilerIds::SendLengths::sph
const char *const sph
Definition: h5profiler.h:37

ProfilerIds::Time::Gravity::compTheta
const char *const compTheta
Definition: h5profiler.h:87

ProfilerIds::Time::Gravity::force
const char *const force
Definition: h5profiler.h:92

ProfilerIds::Time::Gravity::repairTree
const char *const repairTree
Definition: h5profiler.h:93

ProfilerIds::Time::Gravity::symbolicForce
const char *const symbolicForce
Definition: h5profiler.h:88

ProfilerIds::Time::Gravity::insertReceivedParticles
const char *const insertReceivedParticles
Definition: h5profiler.h:91

ProfilerIds::Time::Gravity::insertReceivedPseudoParticles
const char *const insertReceivedPseudoParticles
Definition: h5profiler.h:90

ProfilerIds::Time::Gravity::sending
const char *const sending
Definition: h5profiler.h:89

ProfilerIds::Time::SPH::insertReceivedParticles
const char *const insertReceivedParticles
Definition: h5profiler.h:101

ProfilerIds::Time::SPH::internalForces
const char *const internalForces
Definition: h5profiler.h:107

ProfilerIds::Time::SPH::soundSpeed
const char *const soundSpeed
Definition: h5profiler.h:104

ProfilerIds::Time::SPH::symbolicForce
const char *const symbolicForce
Definition: h5profiler.h:99

ProfilerIds::Time::SPH::pressure
const char *const pressure
Definition: h5profiler.h:105

ProfilerIds::Time::SPH::sending
const char *const sending
Definition: h5profiler.h:100

ProfilerIds::Time::SPH::fixedRadiusNN
const char *const fixedRadiusNN
Definition: h5profiler.h:102

ProfilerIds::Time::SPH::determineSearchRadii
const char *const determineSearchRadii
Definition: h5profiler.h:98

ProfilerIds::Time::SPH::repairTree
const char *const repairTree
Definition: h5profiler.h:108

ProfilerIds::Time::SPH::density
const char *const density
Definition: h5profiler.h:103

ProfilerIds::Time::SPH::compTheta
const char *const compTheta
Definition: h5profiler.h:97

ProfilerIds::Time::SPH::resend
const char *const resend
Definition: h5profiler.h:106

ProfilerIds::Time::Tree::tree
const char *const tree
Definition: h5profiler.h:78

ProfilerIds::Time::Tree::buildDomain
const char *const buildDomain
Definition: h5profiler.h:79

ProfilerIds::Time::Tree::createDomain
const char *const createDomain
Definition: h5profiler.h:77

ProfilerIds::Time::pseudoParticle
const char *const pseudoParticle
Definition: h5profiler.h:58

ProfilerIds::Time::gravity
const char *const gravity
Definition: h5profiler.h:59

ProfilerIds::Time::IO
const char *const IO
Definition: h5profiler.h:62

ProfilerIds::Time::removeParticles
const char *const removeParticles
Definition: h5profiler.h:54

ProfilerIds::Time::rhs
const char *const rhs
Definition: h5profiler.h:50

ProfilerIds::Time::reset
const char *const reset
Definition: h5profiler.h:53

ProfilerIds::Time::tree
const char *const tree
Definition: h5profiler.h:57

ProfilerIds::Time::loadBalancing
const char *const loadBalancing
Definition: h5profiler.h:52

ProfilerIds::Time::assignParticles
const char *const assignParticles
Definition: h5profiler.h:56

ProfilerIds::Time::boundingBox
const char *const boundingBox
Definition: h5profiler.h:55

ProfilerIds::Time::integrate
const char *const integrate
Definition: h5profiler.h:61

ProfilerIds::Time::sph
const char *const sph
Definition: h5profiler.h:60

ProfilerIds::Time::rhsElapsed
const char *const rhsElapsed
Definition: h5profiler.h:51

ProfilerIds::numParticlesLocal
const char *const numParticlesLocal
Definition: h5profiler.h:30

ProfilerIds::ranges
const char *const ranges
Definition: h5profiler.h:31

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

real
double real
Definition: parameter.h:15

keyType
unsigned long keyType
Definition: parameter.h:18

MAX_LEVEL
#define MAX_LEVEL
Definition: parameter.h:25

POW_DIM
#define POW_DIM
Definition: parameter.h:40

IntegratorSelection::predictor_corrector_euler
@ predictor_corrector_euler
Definition: parameter.h:222

IntegratorSelection::leapfrog
@ leapfrog
Definition: parameter.h:222

IntegratorSelection::explicit_euler
@ explicit_euler
Definition: parameter.h:222

SimulationParameters
Definition: parameter.h:122

SimulationParameters::verbosity
int verbosity
verbosity level
Definition: parameter.h:125

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

structLog
Logger settings.
Definition: logger.h:58

structLog::level
typeLog level
Minimum logging level to be shown.
Definition: logger.h:62

structLog::omitTime
bool omitTime
omit time output/logging
Definition: logger.h:72

structLog::headers
bool headers
show headers
Definition: logger.h:60

structLog::logFileName
std::string logFileName
log file to be written
Definition: logger.h:70

structLog::write2LogFile
bool write2LogFile
write additionally to log file
Definition: logger.h:68

structLog::outputRank
int outputRank
MPI rank to be displayed (default: -1 -> display all)
Definition: logger.h:66

structLog::rank
int rank
whether to use MPI
Definition: logger.h:64