apps/benchmarks/GranularGas/Parameters.cpp

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file Parameters.cpp
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+//======================================================================================================================
+//
+//  THIS FILE IS GENERATED - PLEASE CHANGE THE TEMPLATE !!!
+//
+//======================================================================================================================
+
+#include "Parameters.h"
+
+#include <core/logging/Logging.h>
+
+namespace walberla {
+namespace mesa_pd {
+
+void loadFromConfig(Parameters& params, const Config::BlockHandle& cfg)
+{
+   params.sorting = cfg.getParameter<std::string>("sorting", "none" );
+   WALBERLA_LOG_INFO_ON_ROOT("sorting: " << params.sorting);
+   
+   params.normal = cfg.getParameter<Vec3>("normal", Vec3(real_t(1.0), real_t(1.0), real_t(1.0)) );
+   WALBERLA_LOG_INFO_ON_ROOT("normal: " << params.normal);
+   
+   params.spacing = cfg.getParameter<real_t>("spacing", real_t(1.0) );
+   WALBERLA_LOG_INFO_ON_ROOT("spacing: " << params.spacing);
+   
+   params.shift = cfg.getParameter<Vec3>("shift", Vec3(real_t(0.1), real_t(0.1), real_t(0.1)) );
+   WALBERLA_LOG_INFO_ON_ROOT("shift: " << params.shift);
+   
+   params.radius = cfg.getParameter<real_t>("radius", real_t(0.5) );
+   WALBERLA_LOG_INFO_ON_ROOT("radius: " << params.radius);
+   
+   params.bBarrier = cfg.getParameter<bool>("bBarrier", false );
+   WALBERLA_LOG_INFO_ON_ROOT("bBarrier: " << params.bBarrier);
+   
+   params.storeNodeTimings = cfg.getParameter<bool>("storeNodeTimings", false );
+   WALBERLA_LOG_INFO_ON_ROOT("storeNodeTimings: " << params.storeNodeTimings);
+   
+   params.checkSimulation = cfg.getParameter<bool>("checkSimulation", false );
+   WALBERLA_LOG_INFO_ON_ROOT("checkSimulation: " << params.checkSimulation);
+   
+   params.numOuterIterations = cfg.getParameter<int64_t>("numOuterIterations", 10 );
+   WALBERLA_LOG_INFO_ON_ROOT("numOuterIterations: " << params.numOuterIterations);
+   
+   params.initialRefinementLevel = cfg.getParameter<int64_t>("initialRefinementLevel", 0 );
+   WALBERLA_LOG_INFO_ON_ROOT("initialRefinementLevel: " << params.initialRefinementLevel);
+   
+   params.simulationSteps = cfg.getParameter<int64_t>("simulationSteps", 10 );
+   WALBERLA_LOG_INFO_ON_ROOT("simulationSteps: " << params.simulationSteps);
+   
+   params.dt = cfg.getParameter<real_t>("dt", real_t(0.01) );
+   WALBERLA_LOG_INFO_ON_ROOT("dt: " << params.dt);
+   
+   params.visSpacing = cfg.getParameter<int64_t>("visSpacing", 1000 );
+   WALBERLA_LOG_INFO_ON_ROOT("visSpacing: " << params.visSpacing);
+   
+   params.vtk_out = cfg.getParameter<std::string>("vtk_out", "vtk_out" );
+   WALBERLA_LOG_INFO_ON_ROOT("vtk_out: " << params.vtk_out);
+   
+   params.sqlFile = cfg.getParameter<std::string>("sqlFile", "benchmark.sqlite" );
+   WALBERLA_LOG_INFO_ON_ROOT("sqlFile: " << params.sqlFile);
+   
+   params.recalculateBlockLevelsInRefresh = cfg.getParameter<bool>("recalculateBlockLevelsInRefresh", false );
+   WALBERLA_LOG_INFO_ON_ROOT("recalculateBlockLevelsInRefresh: " << params.recalculateBlockLevelsInRefresh);
+   
+   params.alwaysRebalanceInRefresh = cfg.getParameter<bool>("alwaysRebalanceInRefresh", true );
+   WALBERLA_LOG_INFO_ON_ROOT("alwaysRebalanceInRefresh: " << params.alwaysRebalanceInRefresh);
+   
+   params.reevaluateMinTargetLevelsAfterForcedRefinement = cfg.getParameter<bool>("reevaluateMinTargetLevelsAfterForcedRefinement", false );
+   WALBERLA_LOG_INFO_ON_ROOT("reevaluateMinTargetLevelsAfterForcedRefinement: " << params.reevaluateMinTargetLevelsAfterForcedRefinement);
+   
+   params.allowRefreshChangingDepth = cfg.getParameter<bool>("allowRefreshChangingDepth", false );
+   WALBERLA_LOG_INFO_ON_ROOT("allowRefreshChangingDepth: " << params.allowRefreshChangingDepth);
+   
+   params.allowMultipleRefreshCycles = cfg.getParameter<bool>("allowMultipleRefreshCycles", false );
+   WALBERLA_LOG_INFO_ON_ROOT("allowMultipleRefreshCycles: " << params.allowMultipleRefreshCycles);
+   
+   params.checkForEarlyOutInRefresh = cfg.getParameter<bool>("checkForEarlyOutInRefresh", true );
+   WALBERLA_LOG_INFO_ON_ROOT("checkForEarlyOutInRefresh: " << params.checkForEarlyOutInRefresh);
+   
+   params.checkForLateOutInRefresh = cfg.getParameter<bool>("checkForLateOutInRefresh", true );
+   WALBERLA_LOG_INFO_ON_ROOT("checkForLateOutInRefresh: " << params.checkForLateOutInRefresh);
+   
+   params.regridMin = cfg.getParameter<uint_t>("regridMin", uint_c(100) );
+   WALBERLA_LOG_INFO_ON_ROOT("regridMin: " << params.regridMin);
+   
+   params.regridMax = cfg.getParameter<uint_t>("regridMax", uint_c(1000) );
+   WALBERLA_LOG_INFO_ON_ROOT("regridMax: " << params.regridMax);
+   
+   params.maxBlocksPerProcess = cfg.getParameter<int>("maxBlocksPerProcess", int_c(1000) );
+   WALBERLA_LOG_INFO_ON_ROOT("maxBlocksPerProcess: " << params.maxBlocksPerProcess);
+   
+   params.baseWeight = cfg.getParameter<real_t>("baseWeight", real_t(10.0) );
+   WALBERLA_LOG_INFO_ON_ROOT("baseWeight: " << params.baseWeight);
+   
+   params.metisipc2redist = cfg.getParameter<real_t>("metisipc2redist", real_t(1000.0) );
+   WALBERLA_LOG_INFO_ON_ROOT("metisipc2redist: " << params.metisipc2redist);
+   
+   params.LBAlgorithm = cfg.getParameter<std::string>("LBAlgorithm", "Hilbert" );
+   WALBERLA_LOG_INFO_ON_ROOT("LBAlgorithm: " << params.LBAlgorithm);
+   
+   params.metisAlgorithm = cfg.getParameter<std::string>("metisAlgorithm", "PART_GEOM_KWAY" );
+   WALBERLA_LOG_INFO_ON_ROOT("metisAlgorithm: " << params.metisAlgorithm);
+   
+   params.metisWeightsToUse = cfg.getParameter<std::string>("metisWeightsToUse", "BOTH_WEIGHTS" );
+   WALBERLA_LOG_INFO_ON_ROOT("metisWeightsToUse: " << params.metisWeightsToUse);
+   
+   params.metisEdgeSource = cfg.getParameter<std::string>("metisEdgeSource", "EDGES_FROM_EDGE_WEIGHTS" );
+   WALBERLA_LOG_INFO_ON_ROOT("metisEdgeSource: " << params.metisEdgeSource);
+   
+}
+
+void saveToSQL(const Parameters& params,
+               std::map< std::string, walberla::int64_t >& integerProperties,
+               std::map< std::string, double >&            realProperties,
+               std::map< std::string, std::string >&       stringProperties )
+{
+   stringProperties["sorting"] = params.sorting;
+   
+   
+   realProperties["spacing"] = double_c(params.spacing);
+   
+   
+   realProperties["radius"] = double_c(params.radius);
+   
+   
+   
+   
+   integerProperties["numOuterIterations"] = params.numOuterIterations;
+   
+   integerProperties["initialRefinementLevel"] = params.initialRefinementLevel;
+   
+   integerProperties["simulationSteps"] = params.simulationSteps;
+   
+   realProperties["dt"] = double_c(params.dt);
+   
+   integerProperties["visSpacing"] = params.visSpacing;
+   
+   stringProperties["vtk_out"] = params.vtk_out;
+   
+   stringProperties["sqlFile"] = params.sqlFile;
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   realProperties["baseWeight"] = double_c(params.baseWeight);
+   
+   realProperties["metisipc2redist"] = double_c(params.metisipc2redist);
+   
+   stringProperties["LBAlgorithm"] = params.LBAlgorithm;
+   
+   stringProperties["metisAlgorithm"] = params.metisAlgorithm;
+   
+   stringProperties["metisWeightsToUse"] = params.metisWeightsToUse;
+   
+   stringProperties["metisEdgeSource"] = params.metisEdgeSource;
+   
+}
+
+} //namespace mesa_pd
+} //namespace walberla
\ No newline at end of file

apps/benchmarks/GranularGas/Parameters.h

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file Parameters.h
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+//======================================================================================================================
+//
+//  THIS FILE IS GENERATED - PLEASE CHANGE THE TEMPLATE !!!
+//
+//======================================================================================================================
+
+#pragma once
+
+#include <core/config/Config.h>
+#include <mesa_pd/data/DataTypes.h>
+
+#include <string>
+
+namespace walberla {
+namespace mesa_pd {
+
+struct Parameters
+{
+   std::string sorting = "none";
+   Vec3 normal = Vec3(real_t(1.0), real_t(1.0), real_t(1.0));
+   real_t spacing = real_t(1.0);
+   Vec3 shift = Vec3(real_t(0.1), real_t(0.1), real_t(0.1));
+   real_t radius = real_t(0.5);
+   bool bBarrier = false;
+   bool storeNodeTimings = false;
+   bool checkSimulation = false;
+   int64_t numOuterIterations = 10;
+   int64_t initialRefinementLevel = 0;
+   int64_t simulationSteps = 10;
+   real_t dt = real_t(0.01);
+   int64_t visSpacing = 1000;
+   std::string vtk_out = "vtk_out";
+   std::string sqlFile = "benchmark.sqlite";
+   bool recalculateBlockLevelsInRefresh = false;
+   bool alwaysRebalanceInRefresh = true;
+   bool reevaluateMinTargetLevelsAfterForcedRefinement = false;
+   bool allowRefreshChangingDepth = false;
+   bool allowMultipleRefreshCycles = false;
+   bool checkForEarlyOutInRefresh = true;
+   bool checkForLateOutInRefresh = true;
+   uint_t regridMin = uint_c(100);
+   uint_t regridMax = uint_c(1000);
+   int maxBlocksPerProcess = int_c(1000);
+   real_t baseWeight = real_t(10.0);
+   real_t metisipc2redist = real_t(1000.0);
+   std::string LBAlgorithm = "Hilbert";
+   std::string metisAlgorithm = "PART_GEOM_KWAY";
+   std::string metisWeightsToUse = "BOTH_WEIGHTS";
+   std::string metisEdgeSource = "EDGES_FROM_EDGE_WEIGHTS";
+};
+
+void loadFromConfig(Parameters& params,
+                    const Config::BlockHandle& cfg);
+
+void saveToSQL(const Parameters& params,
+               std::map< std::string, walberla::int64_t >& integerProperties,
+               std::map< std::string, double >&            realProperties,
+               std::map< std::string, std::string >&       stringProperties );
+
+} //namespace mesa_pd
+} //namespace walberla
\ No newline at end of file

apps/benchmarks/GranularGas/Parameters.templ.cpp

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file Parameters.cpp
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+//======================================================================================================================
+//
+//  THIS FILE IS GENERATED - PLEASE CHANGE THE TEMPLATE !!!
+//
+//======================================================================================================================
+
+#include "Parameters.h"
+
+#include <core/logging/Logging.h>
+
+namespace walberla {
+namespace mesa_pd {
+
+void loadFromConfig(Parameters& params, const Config::BlockHandle& cfg)
+{
+   {%- for param in parameters %}
+   params.{{param.name}} = cfg.getParameter<{{param.type}}>("{{param.name}}", {{param.defValue}} );
+   WALBERLA_LOG_INFO_ON_ROOT("{{param.name}}: " << params.{{param.name}});
+   {% endfor %}
+}
+
+void saveToSQL(const Parameters& params,
+               std::map< std::string, walberla::int64_t >& integerProperties,
+               std::map< std::string, double >&            realProperties,
+               std::map< std::string, std::string >&       stringProperties )
+{
+   {%- for param in parameters %}
+   {%- if param.type=="int64_t" %}
+   integerProperties["{{param.name}}"] = params.{{param.name}};
+   {%- endif %}
+   {%- if param.type=="real_t" %}
+   realProperties["{{param.name}}"] = double_c(params.{{param.name}});
+   {%- endif %}
+   {%- if param.type=="std::string" %}
+   stringProperties["{{param.name}}"] = params.{{param.name}};
+   {%- endif %}
+   {% endfor %}
+}
+
+} //namespace mesa_pd
+} //namespace walberla

apps/benchmarks/GranularGas/Parameters.templ.h

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file Parameters.h
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+//======================================================================================================================
+//
+//  THIS FILE IS GENERATED - PLEASE CHANGE THE TEMPLATE !!!
+//
+//======================================================================================================================
+
+#pragma once
+
+#include <core/config/Config.h>
+#include <mesa_pd/data/DataTypes.h>
+
+#include <string>
+
+namespace walberla {
+namespace mesa_pd {
+
+struct Parameters
+{
+   {%- for param in parameters %}
+   {{param.type}} {{param.name}} = {{param.defValue}};
+   {%- endfor %}
+};
+
+void loadFromConfig(Parameters& params,
+                    const Config::BlockHandle& cfg);
+
+void saveToSQL(const Parameters& params,
+               std::map< std::string, walberla::int64_t >& integerProperties,
+               std::map< std::string, double >&            realProperties,
+               std::map< std::string, std::string >&       stringProperties );
+
+} //namespace mesa_pd
+} //namespace walberla

apps/benchmarks/GranularGas/SQLProperties.cpp

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file SQLProperties.cpp
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+#include "SQLProperties.h"
+
+#include <blockforest/BlockForest.h>
+#include <blockforest/loadbalancing/DynamicDiffusive.h>
+#include <blockforest/loadbalancing/DynamicParMetis.h>
+#include <core/DataTypes.h>
+#include <core/waLBerlaBuildInfo.h>
+
+namespace walberla {
+namespace mesa_pd {
+
+void addBuildInfoToSQL( std::map< std::string, int64_t > &       /*integerProperties*/,
+                        std::map< std::string, double > &        /*realProperties*/,
+                        std::map< std::string, std::string > & stringProperties )
+{
+   stringProperties["walberla_sha"]    = walberla::core::buildinfo::gitSHA1();
+   stringProperties["build_type"]      = walberla::core::buildinfo::buildType();
+   stringProperties["compiler_flags"]  = walberla::core::buildinfo::compilerFlags();
+   stringProperties["build_machine"]   = walberla::core::buildinfo::buildMachine();
+}
+
+void addDomainPropertiesToSQL( const ::walberla::blockforest::BlockForest& forest,
+                               std::map< std::string, int64_t > &          integerProperties,
+                               std::map< std::string, double > &           realProperties,
+                               std::map< std::string, std::string > &    /*stringProperties*/ )
+{
+   integerProperties["numMPIProcesses"]  = ::walberla::mpi::MPIManager::instance()->numProcesses();
+
+   realProperties[ "domainXMin" ] = forest.getDomain().xMin();
+   realProperties[ "domainXMax" ] = forest.getDomain().xMax();
+   realProperties[ "domainYMin" ] = forest.getDomain().yMin();
+   realProperties[ "domainYMax" ] = forest.getDomain().yMax();
+   realProperties[ "domainZMin" ] = forest.getDomain().zMin();
+   realProperties[ "domainZMax" ] = forest.getDomain().zMax();
+
+   integerProperties[ "xBlocks" ] = ::walberla::int_c( forest.getXSize() );
+   integerProperties[ "yBlocks" ] = ::walberla::int_c( forest.getYSize() );
+   integerProperties[ "zBlocks" ] = ::walberla::int_c( forest.getZSize() );
+
+   integerProperties[ "xPeriodic" ] = ( forest.isXPeriodic() ? 1 : 0 );
+   integerProperties[ "yPeriodic" ] = ( forest.isYPeriodic() ? 1 : 0 );
+   integerProperties[ "zPeriodic" ] = ( forest.isZPeriodic() ? 1 : 0 );
+}
+
+void addLoadBalancingPropertiesToSQL( const ::walberla::blockforest::BlockForest& forest,
+                                      std::map< std::string, int64_t > &          integerProperties,
+                                      std::map< std::string, double > &         /*realProperties*/,
+                                      std::map< std::string, std::string > &    /*stringProperties*/ )
+{
+   integerProperties[ "recalculateBlockLevelsInRefresh" ]                = ( forest.recalculateBlockLevelsInRefresh() ? 1 : 0 );
+   integerProperties[ "alwaysRebalanceInRefresh" ]                       = ( forest.alwaysRebalanceInRefresh() ? 1 : 0 );
+   integerProperties[ "reevaluateMinTargetLevelsAfterForcedRefinement" ] = ( forest.reevaluateMinTargetLevelsAfterForcedRefinement() ? 1 : 0 );
+   integerProperties[ "allowRefreshChangingDepth" ]                      = ( forest.allowRefreshChangingDepth() ? 1 : 0 );
+   integerProperties[ "allowMultipleRefreshCycles" ]                     = ( forest.allowMultipleRefreshCycles() ? 1 : 0 );
+   integerProperties[ "checkForEarlyOutInRefresh" ]                      = ( forest.checkForEarlyOutInRefresh() ? 1 : 0 );
+   integerProperties[ "checkForLateOutInRefresh" ]                       = ( forest.checkForLateOutInRefresh() ? 1 : 0 );
+}
+
+void addParMetisPropertiesToSQL( const ::walberla::blockforest::DynamicParMetis&         dpm,
+                                 std::map< std::string, int64_t > &        /*integerProperties*/,
+                                 std::map< std::string, double > &         realProperties,
+                                 std::map< std::string, std::string > &    stringProperties )
+{
+   stringProperties["metisAlgorithm"]    = dpm.algorithmToString();
+   stringProperties["metisEdgeSource"]   = dpm.edgeSourceToString();
+   stringProperties["metisWeightsToUse"] = dpm.weightsToUseToString();
+   realProperties["metisipc2redist"]     = dpm.getipc2redist();
+}
+
+std::string envToString(const char* env)
+{
+   return env != nullptr ? std::string(env) : "";
+}
+
+void addSlurmPropertiesToSQL( std::map< std::string, int64_t > &        /*integerProperties*/,
+                              std::map< std::string, double > &         /*realProperties*/,
+                              std::map< std::string, std::string > &    stringProperties )
+{
+   stringProperties["SLURM_CLUSTER_NAME"]       = envToString(std::getenv( "SLURM_CLUSTER_NAME" ));
+   stringProperties["SLURM_CPUS_ON_NODE"]       = envToString(std::getenv( "SLURM_CPUS_ON_NODE" ));
+   stringProperties["SLURM_CPUS_PER_TASK"]      = envToString(std::getenv( "SLURM_CPUS_PER_TASK" ));
+   stringProperties["SLURM_JOB_ACCOUNT"]        = envToString(std::getenv( "SLURM_JOB_ACCOUNT" ));
+   stringProperties["SLURM_JOB_ID"]             = envToString(std::getenv( "SLURM_JOB_ID" ));
+   stringProperties["SLURM_JOB_CPUS_PER_NODE"]  = envToString(std::getenv( "SLURM_JOB_CPUS_PER_NODE" ));
+   stringProperties["SLURM_JOB_NAME"]           = envToString(std::getenv( "SLURM_JOB_NAME" ));
+   stringProperties["SLURM_JOB_NUM_NODES"]      = envToString(std::getenv( "SLURM_JOB_NUM_NODES" ));
+   stringProperties["SLURM_NTASKS"]             = envToString(std::getenv( "SLURM_NTASKS" ));
+   stringProperties["SLURM_NTASKS_PER_CORE"]    = envToString(std::getenv( "SLURM_NTASKS_PER_CORE" ));
+   stringProperties["SLURM_NTASKS_PER_NODE"]    = envToString(std::getenv( "SLURM_NTASKS_PER_NODE" ));
+   stringProperties["SLURM_NTASKS_PER_SOCKET"]  = envToString(std::getenv( "SLURM_NTASKS_PER_SOCKET" ));
+   stringProperties["SLURM_CPU_BIND_TYPE"]      = envToString(std::getenv( "SLURM_CPU_BIND_TYPE" ));
+}
+
+} //namespace mesa_pd
+} //namespace walberla

apps/benchmarks/GranularGas/SQLProperties.h

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file SQLProperties.h
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+#pragma once
+
+#include <blockforest/loadbalancing/DynamicDiffusive.h>
+#include <core/DataTypes.h>
+
+#include <map>
+#include <string>
+
+namespace walberla { namespace blockforest{
+class DynamicParMetis;
+} }
+
+namespace walberla {
+namespace mesa_pd {
+
+void addBuildInfoToSQL( std::map< std::string, int64_t > &       integerProperties,
+                        std::map< std::string, double > &        realProperties,
+                        std::map< std::string, std::string > & stringProperties );
+
+void addDomainPropertiesToSQL( const walberla::blockforest::BlockForest& forest,
+                               std::map< std::string, int64_t > &       integerProperties,
+                               std::map< std::string, double > &        realProperties,
+                               std::map< std::string, std::string > & /*stringProperties*/ );
+
+void addLoadBalancingPropertiesToSQL( const walberla::blockforest::BlockForest& forest,
+                                      std::map< std::string, int64_t > &       integerProperties,
+                                      std::map< std::string, double > &        /*realProperties*/,
+                                      std::map< std::string, std::string > & /*stringProperties*/ );
+
+template <typename PhantomBlockWeight_T>
+void addDynamicDiffusivePropertiesToSQL( const walberla::blockforest::DynamicDiffusionBalance<PhantomBlockWeight_T>& ddb,
+                                         std::map< std::string, int64_t > &       integerProperties,
+                                         std::map< std::string, double > &        /*realProperties*/,
+                                         std::map< std::string, std::string > &   stringProperties )
+{
+   integerProperties[ "diffMaxIterations" ]                = walberla::int64_c(ddb.getMaxIterations());
+   integerProperties[ "diffFlowIterations" ]               = walberla::int64_c(ddb.getFlowIterations());
+   integerProperties[ "bDiffAbortEarly" ]                  = ( ddb.checkForEarlyAbort() ? 1 : 0 );
+   integerProperties[ "bDiffAdaptInflow" ]                 = ( ddb.adaptInflowWithGlobalInformation() ? 1 : 0 );
+   integerProperties[ "bDiffAdaptOutflow" ]                = ( ddb.adaptOutflowWithGlobalInformation() ? 1 : 0 );
+   std::string diffModeStr = "unknown";
+   if (ddb.getMode() == walberla::blockforest::DynamicDiffusionBalance<PhantomBlockWeight_T>::DIFFUSION_PUSH) diffModeStr = "push";
+   if (ddb.getMode() == walberla::blockforest::DynamicDiffusionBalance<PhantomBlockWeight_T>::DIFFUSION_PULL) diffModeStr = "pull";
+   if (ddb.getMode() == walberla::blockforest::DynamicDiffusionBalance<PhantomBlockWeight_T>::DIFFUSION_PUSHPULL) diffModeStr = "pushpull";
+   stringProperties[ "diffMode" ]                          = diffModeStr;
+}
+
+void addParMetisPropertiesToSQL( const ::walberla::blockforest::DynamicParMetis&         dpm,
+                                 std::map< std::string, int64_t > &        integerProperties,
+                                 std::map< std::string, double > &         realProperties,
+                                 std::map< std::string, std::string > &    stringProperties );
+
+void addSlurmPropertiesToSQL( std::map< std::string, int64_t > &        integerProperties,
+                              std::map< std::string, double > &         realProperties,
+                              std::map< std::string, std::string > &    stringProperties );
+
+} //namespace mesa_pd
+} //namespace walberla

apps/benchmarks/GranularGas/SelectProperty.h

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file   SelectProperty.h
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+#include <mesa_pd/data/ParticleStorage.h>
+
+#include <core/mpi/MPIManager.h>
+
+namespace walberla {
+namespace mesa_pd {
+
+class SelectRank
+{
+public:
+   using return_type = int;
+   int operator()(const data::Particle& /*p*/) const { return rank_; }
+   int operator()(const data::Particle&& /*p*/) const { return rank_; }
+private:
+   int rank_ = walberla::mpi::MPIManager::instance()->rank();
+};
+
+class SelectIdx
+{
+public:
+   using return_type = int;
+   auto operator()(const data::Particle& p) const { return p.getIdx(); }
+   auto operator()(const data::Particle&& p) const { return p.getIdx(); }
+private:
+};
+
+} // namespace mesa_pd
+} // namespace walberla

apps/benchmarks/GranularGas/check.h

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file   check.h
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+#include <mesa_pd/data/ParticleStorage.h>
+
+#include <blockforest/BlockForest.h>
+#include <core/grid_generator/SCIterator.h>
+#include <core/logging/Logging.h>
+
+namespace walberla {
+namespace mesa_pd {
+
+inline void check( data::ParticleStorage& ps, blockforest::BlockForest& forest, real_t spacing, const Vec3& shift )
+{
+   WALBERLA_LOG_INFO_ON_ROOT("*** CHECKING RESULT - START ***");
+   auto pIt = ps.begin();
+   for (auto& iBlk : forest)
+   {
+      for (auto it = grid_generator::SCIterator(iBlk.getAABB(), Vector3<real_t>(spacing, spacing, spacing) * real_c(0.5) + shift, spacing);
+           it != grid_generator::SCIterator();
+           ++it, ++pIt)
+      {
+         WALBERLA_CHECK_UNEQUAL(pIt, ps.end());
+         WALBERLA_CHECK_FLOAT_EQUAL(pIt->getPositionRef(), *it);
+      }
+   }
+   WALBERLA_LOG_INFO_ON_ROOT("*** CHECKING RESULT - END ***");
+}
+
+} //namespace mesa_pd
+} //namespace walberla

apps/benchmarks/GranularGas/generateConfig.py

+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from ConfigGenerator import Config
+
+cfg = Config()
+cfg.addParameter("sorting",                "std::string", '"none"')
+cfg.addParameter("normal",                 "Vec3",        "Vec3(real_t(1.0), real_t(1.0), real_t(1.0))")
+cfg.addParameter("spacing",                "real_t",      "real_t(1.0)")
+cfg.addParameter("shift",                  "Vec3",        "Vec3(real_t(0.1), real_t(0.1), real_t(0.1))")
+cfg.addParameter("radius",                 "real_t",      "real_t(0.5)")
+cfg.addParameter("bBarrier",               "bool",        "false")
+cfg.addParameter("storeNodeTimings",       "bool",        "false")
+cfg.addParameter("checkSimulation",        "bool",        "false")
+cfg.addParameter("numOuterIterations",     "int64_t",     "10")
+cfg.addParameter("initialRefinementLevel", "int64_t",     "0")
+cfg.addParameter("simulationSteps",        "int64_t",     "10")
+cfg.addParameter("dt",                     "real_t",      "real_t(0.01)")
+cfg.addParameter("visSpacing",             "int64_t",     "1000")
+cfg.addParameter("vtk_out",                "std::string", '"vtk_out"')
+cfg.addParameter("sqlFile",                "std::string", '"benchmark.sqlite"')
+
+cfg.addParameter("recalculateBlockLevelsInRefresh",                "bool", "false")
+cfg.addParameter("alwaysRebalanceInRefresh",                       "bool", "true")
+cfg.addParameter("reevaluateMinTargetLevelsAfterForcedRefinement", "bool", "false")
+cfg.addParameter("allowRefreshChangingDepth",                      "bool", "false")
+
+cfg.addParameter("allowMultipleRefreshCycles",                     "bool", "false")
+cfg.addParameter("checkForEarlyOutInRefresh",                      "bool", "true")
+cfg.addParameter("checkForLateOutInRefresh",                       "bool", "true")
+
+cfg.addParameter("regridMin",              "uint_t",      'uint_c(100)')
+cfg.addParameter("regridMax",              "uint_t",      'uint_c(1000)')
+cfg.addParameter("maxBlocksPerProcess",    "int",         'int_c(1000)')
+cfg.addParameter("baseWeight",             "real_t",      'real_t(10.0)')
+cfg.addParameter("metisipc2redist",        "real_t",      'real_t(1000.0)')
+cfg.addParameter("LBAlgorithm",            "std::string", '"Hilbert"')
+cfg.addParameter("metisAlgorithm",         "std::string", '"PART_GEOM_KWAY"')
+cfg.addParameter("metisWeightsToUse",      "std::string", '"BOTH_WEIGHTS"')
+cfg.addParameter("metisEdgeSource",        "std::string", '"EDGES_FROM_EDGE_WEIGHTS"')
+
+cfg.generate()

apps/benchmarks/GranularGas/mesa_pd_upload.py

+#! /usr/bin/env python3
+
+import os
+import time
+import re
+from influxdb import InfluxDBClient
+
+
+class Upload:
+    def __init__(self):
+        try:
+            self.write_user_pw = os.environ["INFLUXDB_MESAPD_PW"]
+        except KeyError:
+            import sys
+            print('Password for the InfluxDB write_user was not set.\n',
+                  'See https://docs.gitlab.com/ee/ci/variables/#secret-variables', file=sys.stderr)
+            exc_info = sys.exc_info()
+            raise exc_info[0].with_traceback(exc_info[1], exc_info[2])
+
+        self.client = InfluxDBClient('i10grafana.informatik.uni-erlangen.de', 8086,
+                                     'mesa_pd', self.write_user_pw, 'mesa_pd')
+
+    def process(self, filename):
+        tts = dict()
+
+        with open(filename) as f:
+            for s in f.readlines():
+                m = re.search(r'\[0\]\s*(\w*)\s*\|[\s\d\.\%]*\|\s*([\d\.]*)', s)
+
+                if m is not None:
+                    tts[m.group(1)] = float(m.group(2))
+
+        json_body = [
+            {
+                'measurement': 'mesa_pd_benchmark',
+                'tags': {
+                    'host': os.uname()[1],
+                    'image': os.environ["DOCKER_IMAGE_NAME"],
+                },
+                'time': int(time.time()),
+                'fields': tts
+            }
+        ]
+        print(tts)
+        self.client.write_points(json_body, time_precision='s')
+
+
+if __name__ == "__main__":
+    up = Upload()
+    up.process("mesa_pd.txt")

apps/benchmarks/GranularGas/pe_upload.py

+# -*- coding: utf-8 -*-
+
+import os
+import time
+import re
+from influxdb import InfluxDBClient
+
+
+class Upload:
+    def __init__(self):
+        try:
+            self.write_user_pw = os.environ["INFLUXDB_WRITE_USER"]
+        except KeyError:
+            import sys
+            print('Password for the InfluxDB write_user was not set.\n',
+                  'See https://docs.gitlab.com/ee/ci/variables/#secret-variables', file=sys.stderr)
+            exc_info = sys.exc_info()
+            raise exc_info[0].with_traceback(exc_info[1], exc_info[2])
+
+        self.client = InfluxDBClient('i10grafana.informatik.uni-erlangen.de', 8086,
+                                     'pe', self.write_user_pw, 'pe')
+
+    def process(self, filename, model, friction, sync, parallelization):
+        with open(filename) as f:
+            s = f.read()
+        m = re.search(r'PUpS: (\S*)', s)
+
+        json_body = [
+            {
+                'measurement': 'pe_benchmark',
+                'tags': {
+                    'host': os.uname()[1],
+                    'image': os.environ["DOCKER_IMAGE_NAME"],
+                    'model': model,
+                    'friction': friction,
+                    'sync': sync,
+                    'parallelization': parallelization
+                },
+                'time': int(time.time()),
+                'fields': {'PUpS': float(m.group(1))}
+            }
+        ]
+        print(float(m.group(1)))
+        self.client.write_points(json_body, time_precision='s')
+
+
+if __name__ == "__main__":
+    up = Upload()
+    up.process("GranularGas_DEM_NN.txt", "DEM", "Coulomb", "next neighbors", "8P1T")
+    up.process("GranularGas_DEM_SO.txt", "DEM", "Coulomb", "shadow owners", "8P1T")
+    up.process("GranularGas_HCSITS_NN_IFC.txt", "HCSITS", "InelasticFrictionlessContact", "next neighbors", "8P1T")
+    up.process("GranularGas_HCSITS_NN_AICCBD.txt", "HCSITS", "ApproximateInelasticCoulombContactByDecoupling",
+               "next neighbors", "8P1T")
+    up.process("GranularGas_HCSITS_NN_ICCBD.txt", "HCSITS", "InelasticCoulombContactByDecoupling", "next neighbors",
+               "8P1T")
+    up.process("GranularGas_HCSITS_NN_IGMDC.txt", "HCSITS", "InelasticGeneralizedMaximumDissipationContact",
+               "next neighbors", "8P1T")
+    up.process("GranularGas_HCSITS_SO_IFC.txt", "HCSITS", "InelasticFrictionlessContact", "shadow owners", "8P1T")

apps/benchmarks/GranularGas/sortParticleStorage.cpp

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file   sortParticleStorage.cpp
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+#include "sortParticleStorage.h"
+
+namespace walberla {
+namespace mesa_pd {
+
+class RandomCompareFunctor
+{
+public:
+   double getWeight(const data::Particle p1) const
+   {
+      math::seedRandomGenerator(static_cast<std::mt19937::result_type>(p1.getUid()));
+      return math::realRandom<double>();
+   }
+};
+
+
+void sortParticleStorage( data::ParticleStorage& ps,
+                          const std::string& algorithm,
+                          const math::AABB& domain,
+                          const uint64_t cells )
+{
+   if( algorithm == "none" ) return;
+   if( algorithm == "random" )
+   {
+      RandomCompareFunctor rand;
+      ps.sort(rand);
+      return;
+   }
+   if( algorithm == "linear" )
+   {
+      sorting::LinearizedCompareFunctor linear(domain, Vector3<uint_t>(cells));
+      ps.sort(linear);
+      return;
+   }
+   if( algorithm == "hilbert" )
+   {
+      auto tmp = uint_t(1) << math::uintMSBPosition(cells);
+      if (tmp!=cells)
+      {
+         tmp <<= 1;
+      }
+      sorting::HilbertCompareFunctor hilbert(domain, tmp);
+      ps.sort(hilbert);
+      return;
+   }
+   WALBERLA_ABORT("unknown sorting algorithm: " << algorithm);
+}
+
+} // namespace mesa_pd
+} // namespace walberla

apps/benchmarks/GranularGas/sortParticleStorage.h

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file   sortParticleStorage.h
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+#include <mesa_pd/data/ParticleStorage.h>
+#include <mesa_pd/sorting/HilbertCompareFunctor.h>
+#include <mesa_pd/sorting/LinearizedCompareFunctor.h>
+
+#include <core/Abort.h>
+#include <core/math/Random.h>
+#include <core/logging/Logging.h>
+
+#include <memory>
+#include <string>
+
+namespace walberla {
+namespace mesa_pd {
+
+void sortParticleStorage( data::ParticleStorage& ps,
+                          const std::string& algorithm,
+                          const math::AABB& domain,
+                          const uint64_t cells );
+
+} // namespace mesa_pd
+} // namespace walberla

apps/benchmarks/IntegratorAccuracy/CMakeLists.txt

+waLBerla_link_files_to_builddir( "*.ipynb" )
+
+waLBerla_add_executable ( NAME IntegratorAccuracy
+      DEPENDS walberla::core walberla::mesa_pd )

apps/benchmarks/IntegratorAccuracy/IntegratorAccuracy.cpp

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file   IntegratorAccuracy.cpp
+//! \author Christoph Rettinger <christoph.rettinger@fau.de>
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+#include "mesa_pd/data/ParticleAccessor.h"
+
+#include "mesa_pd/kernel/ExplicitEuler.h"
+#include "mesa_pd/kernel/SemiImplicitEuler.h"
+#include "mesa_pd/kernel/VelocityVerlet.h"
+
+#include "core/Environment.h"
+#include "core/math/all.h"
+
+#include <iostream>
+
+namespace walberla {
+
+using namespace walberla::mesa_pd;
+
+class SingleParticleAccessorWithShape : public data::SingleParticleAccessor
+{
+public:
+   void setInvMass(const size_t /*p_idx*/, const real_t &val)
+   { invMass_ = val; }
+
+   const auto &getInvMass(const size_t /*p_idx*/) const
+   { return invMass_; }
+
+   const auto &getInvInertiaBF(const size_t /*p_idx*/) const // dummy
+   { return dummyI_; }
+
+   const auto &getInertiaBF(const size_t /*p_idx*/) const // dummy
+   { return dummyI_; }
+
+private:
+   real_t invMass_;
+   Mat3 dummyI_{0_r};
+};
+
+struct Oscillator
+{
+   real_t amplitude = 1.5_r;
+   real_t k = 0.1_r;
+   real_t damping = 0_r;
+   real_t mass = 0.9_r;
+   real_t dt = 0.2_r;
+   real_t phaseFraction = 0_r;
+   real_t periods = 10_r;
+   real_t phase = phaseFraction * math::pi;
+   real_t dampingRatio = damping / (2_r * std::sqrt(mass * k));
+   real_t omega = std::sqrt(k / mass) * std::sqrt(1_r - dampingRatio * dampingRatio);
+   real_t decay = std::sqrt(k / mass) * dampingRatio;
+   real_t durationOnePeriod = 2_r * math::pi / omega;
+   uint_t timeSteps = uint_c(periods * durationOnePeriod / dt);
+
+   Oscillator(int argc, char **argv)
+   {
+      for (int i = 1; i < argc; ++i)
+      {
+         if (std::strcmp(argv[i], "--dt") == 0)
+         {
+            dt = real_c(std::atof(argv[++i]));
+            continue;
+         }
+         if (std::strcmp(argv[i], "--amplitude") == 0)
+         {
+            amplitude = real_c(std::atof(argv[++i]));
+            continue;
+         }
+         if (std::strcmp(argv[i], "--k") == 0)
+         {
+            k = real_c(std::atof(argv[++i]));
+            continue;
+         }
+         if (std::strcmp(argv[i], "--damping") == 0)
+         {
+            damping = real_c(std::atof(argv[++i]));
+            continue;
+         }
+         if (std::strcmp(argv[i], "--mass") == 0)
+         {
+            mass = real_c(std::atof(argv[++i]));
+            continue;
+         }
+         if (std::strcmp(argv[i], "--phaseFraction") == 0)
+         {
+            phaseFraction = real_c(std::atof(argv[++i]));
+            continue;
+         }
+         if (std::strcmp(argv[i], "--periods") == 0)
+         {
+            periods = real_c(std::atof(argv[++i]));
+            continue;
+         }
+         WALBERLA_ABORT("Unrecognized command line argument found: " << argv[i]);
+      }
+
+      update();
+   }
+
+   void update()
+   {
+      phase = phaseFraction * math::pi;
+      dampingRatio = damping / (2_r * std::sqrt(mass * k));
+      omega = std::sqrt(k / mass) * std::sqrt(1_r - dampingRatio * dampingRatio);
+      decay = std::sqrt(k / mass) * dampingRatio;
+      durationOnePeriod = 2_r * math::pi / omega;
+      timeSteps = uint_c(periods * durationOnePeriod / dt);
+   }
+
+   Vec3 getForce(const Vec3 &pos, const Vec3 &vel) const
+   {
+      return -k * pos - damping * vel;
+   }
+
+   real_t getEnergy(const real_t &pos, const real_t &vel) const
+   {
+      return 0.5_r * mass * vel * vel + 0.5_r * k * pos * pos;
+   }
+
+   real_t analyticalPos(real_t t) const
+   {
+      return amplitude * std::exp(-decay * t) * std::cos(omega * t + phase);
+   }
+
+   real_t analyticalVel(real_t t) const
+   {
+      return -decay * amplitude * std::exp(-decay * t) * std::cos(omega * t + phase)
+             -amplitude * std::exp(-decay * t) * omega * std::sin(omega * t + phase);
+   }
+};
+
+struct ExplicitEuler
+{
+   ExplicitEuler(real_t dt) : integrator(dt) {}
+   void operator()(SingleParticleAccessorWithShape& particle,
+                   const Oscillator& osc)
+   {
+      particle.setForce(0, osc.getForce(particle.getPosition(0),
+                                           particle.getLinearVelocity(0)));
+      integrator(0, particle);
+   }
+   kernel::ExplicitEuler integrator;
+};
+
+struct SemiImplicitEuler
+{
+   SemiImplicitEuler(real_t dt) : integrator(dt) {}
+   void operator()(SingleParticleAccessorWithShape& particle,
+                   const Oscillator& osc)
+   {
+      particle.setForce(0, osc.getForce(particle.getPosition(0),
+                                           particle.getLinearVelocity(0)));
+      integrator(0, particle);
+   }
+   kernel::SemiImplicitEuler integrator;
+};
+
+struct VelocityVerlet
+{
+   VelocityVerlet(real_t dt) : preVV(dt), postVV(dt) {}
+   void operator()(SingleParticleAccessorWithShape& particle,
+                   const Oscillator& osc)
+   {
+      preVV(0, particle);
+      particle.setForce(0, osc.getForce(particle.getPosition(0),
+                                           particle.getLinearVelocity(0)));
+      postVV(0, particle);
+   }
+   kernel::VelocityVerletPreForceUpdate preVV;
+   kernel::VelocityVerletPostForceUpdate postVV;
+};
+
+struct AccuracyResult
+{
+   real_t maxPosDeviation;
+   real_t maxVelDeviation;
+   real_t maxEneDeviation;
+};
+
+template <typename Integrator>
+AccuracyResult checkIntegrator(const Oscillator& osc)
+{
+   //init data structures
+   SingleParticleAccessorWithShape particle;
+
+   //first dummy argument is needed to fulfill accessor interface
+   particle.setPosition(0, Vec3(0, 0, osc.analyticalPos(0_r)));
+   particle.setLinearVelocity(0, Vec3(0, 0, osc.analyticalVel(0_r)));
+   particle.setInvMass(0, 1_r / osc.mass);
+   particle.setForce(0, osc.getForce(Vec3(0, 0, osc.analyticalPos(real_t(0))),
+                                        Vec3(0, 0, osc.analyticalVel(real_t(0)))));
+   particle.setOldForce(0, osc.getForce(Vec3(0, 0, osc.analyticalPos(-osc.dt)),
+                                           Vec3(0, 0, osc.analyticalVel(-osc.dt))));
+
+   // explicit euler
+   Integrator integrator(osc.dt);
+
+   real_t maxPosDeviation = 0_r;
+   real_t maxVelDeviation = 0_r;
+   real_t maxEneDeviation = 0_r;
+
+   for (auto i = uint_t(0); i <= osc.timeSteps; ++i)
+   {
+      real_t refPos = osc.analyticalPos(real_c(i) * osc.dt);
+      real_t refVel = osc.analyticalVel(real_c(i) * osc.dt);
+      real_t refEne = osc.getEnergy(refPos, refVel);
+
+      maxPosDeviation = std::max(maxPosDeviation, std::abs(particle.getPosition(0)[2] - refPos));
+      maxVelDeviation = std::max(maxVelDeviation, std::abs(particle.getLinearVelocity(0)[2] - refVel));
+      maxEneDeviation = std::max(maxEneDeviation, std::abs(osc.getEnergy(particle.getPosition(0)[2], particle.getLinearVelocity(0)[2]) - refEne));
+
+      std::cout << real_t(i) * osc.dt << " "
+                << refPos << " "
+                << refVel << " "
+                << refEne << " "
+                << particle.getPosition(0)[2] << " "
+                << particle.getLinearVelocity(0)[2] << " "
+                << osc.getEnergy(particle.getPosition(0)[2], particle.getLinearVelocity(0)[2]) << " "
+                << maxPosDeviation << " "
+                << maxVelDeviation << std::endl;
+
+      integrator(particle, osc);
+   }
+
+   return {maxPosDeviation, maxVelDeviation, maxEneDeviation};
+}
+
+int main(int argc, char **argv)
+{
+   mpi::Environment env(argc, argv);
+   WALBERLA_UNUSED(env);
+   mpi::MPIManager::instance()->useWorldComm();
+
+   Oscillator osc(argc, argv);
+
+   AccuracyResult res;
+//   res = walberla::checkIntegrator<walberla::ExplicitEuler>(osc);
+//   res = walberla::checkIntegrator<walberla::SemiImplicitEuler>(osc);
+   res = walberla::checkIntegrator<walberla::VelocityVerlet>(osc);
+
+   return EXIT_SUCCESS;
+}
+
+} //namespace walberla
+
+
+/*
+ * Simulates a harmonic oscillator to test the accuracy of the integrators.
+ * Playground for integrator analysis. The corresponding unit test is located at
+ * tests/mesa_pd/kernel/IntegratorAccuracy.cpp
+ */
+int main(int argc, char **argv)
+{
+   return walberla::main(argc, argv);
+}
+

apps/benchmarks/IntegratorAccuracy/IntegratorAccuracy.ipynb

+%% Cell type:markdown id: tags:
+
+# error analysis of integration kernels
+
+%% Cell type:code id: tags:
+
+``` python
+import matplotlib.pyplot as plt
+import numpy as np
+```
+
+%% Cell type:code id: tags:
+
+``` python
+integrator = 'euler'
+data01 = np.loadtxt(f'{integrator}01.txt').transpose()
+data02 = np.loadtxt(f'{integrator}02.txt').transpose()
+data04 = np.loadtxt(f'{integrator}04.txt').transpose()
+```
+
+%% Cell type:code id: tags:
+
+``` python
+plt.plot(data01[0], data01[7], label='dt = 0.1')
+plt.plot(data02[0], data02[7], label='dt = 0.2')
+plt.plot(data04[0], data04[7], label='dt = 0.4')
+plt.xlabel('time')
+plt.ylabel('max pos error')
+plt.legend()
+plt.show()
+```
+
+%% Cell type:code id: tags:
+
+``` python
+plt.plot(data01[0], data01[8], label='dt = 0.1')
+plt.plot(data02[0], data02[8], label='dt = 0.2')
+plt.plot(data04[0], data04[8], label='dt = 0.4')
+plt.xlabel('time')
+plt.ylabel('max vel error')
+plt.legend()
+plt.show()
+```
+
+%% Cell type:code id: tags:
+
+``` python
+final_errors = np.ones(3)
+final_errors[0] = np.abs(data01[7][-1])
+final_errors[1] = np.abs(data02[7][-1])
+final_errors[2] = np.abs(data04[7][-1])
+
+plt.bar(np.arange(3), final_errors)
+plt.show()
+
+print(final_errors[2] / final_errors[1])
+print(final_errors[1] / final_errors[0])
+```
+
+%% Cell type:code id: tags:
+
+``` python
+plt.plot(data01[0], data01[1], label='analytic')
+plt.plot(data01[0], data01[4], label='dt = 0.1')
+plt.plot(data02[0], data02[4], label='dt = 0.2')
+plt.plot(data04[0], data04[4], label='dt = 0.4')
+plt.xlabel('time')
+plt.ylabel('pos')
+plt.legend()
+plt.show()
+```
+
+%% Cell type:code id: tags:
+
+``` python
+plt.plot(data01[0], data01[2], label='analytic')
+plt.plot(data01[0], data01[5], label='dt = 0.1')
+plt.plot(data02[0], data02[5], label='dt = 0.2')
+plt.plot(data04[0], data04[5], label='dt = 0.4')
+plt.xlabel('time')
+plt.ylabel('vel')
+plt.legend()
+plt.show()
+```
+
+%% Cell type:code id: tags:
+
+``` python
+plt.plot(data01[0], data01[6] / data01[3][0], label='dt = 0.1')
+plt.plot(data02[0], data02[6] / data01[3][0], label='dt = 0.2')
+plt.plot(data04[0], data04[6] / data01[3][0], label='dt = 0.4')
+plt.xlabel('time')
+plt.ylabel('relative energy')
+plt.legend()
+plt.show()
+```
+
+%% Cell type:code id: tags:
+
+``` python
+```

apps/benchmarks/PeriodicGranularGas/CMakeLists.txt → apps/benchmarks/LennardJones/CMakeLists.txt

 waLBerla_link_files_to_builddir( *.cfg )
 waLBerla_link_files_to_builddir( *.py )
 
-waLBerla_add_executable ( NAME PeriodicGranularGas
-                          FILES PeriodicGranularGas.cpp
-                          DEPENDS blockforest core pe )
+waLBerla_add_executable ( NAME LennardJones
+                          FILES LennardJones.cpp
+      DEPENDS walberla::blockforest walberla::core walberla::pe )

apps/benchmarks/LennardJones/LennardJones.cpp

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file   LennardJones.cpp
+//! \author Sebastian Eibl <sebastian.eibl@fau.de>
+//
+//======================================================================================================================
+
+#include <pe/basic.h>
+#include <pe/vtk/SphereVtkOutput.h>
+
+#include <blockforest/Initialization.h>
+#include <core/Abort.h>
+#include <core/Environment.h>
+#include <core/grid_generator/SCIterator.h>
+#include <core/logging/Logging.h>
+#include <core/math/Random.h>
+#include <core/waLBerlaBuildInfo.h>
+#include <vtk/VTKOutput.h>
+
+#include <functional>
+#include <memory>
+#include <tuple>
+
+namespace walberla {
+using namespace walberla::pe;
+using namespace walberla::timing;
+
+using BodyTuple = std::tuple<Sphere> ;
+
+inline
+void LJ(RigidBody& bd1, RigidBody& bd2)
+{
+   if (bd1.getSystemID() != bd2.getSystemID())
+   {
+      Vec3 dir = bd1.getPosition() - bd2.getPosition();
+      const real_t inv_d = real_t(1) / length(dir);
+      dir *= inv_d;
+      WALBERLA_ASSERT_FLOAT_EQUAL(length(dir),
+                                  real_t(1),
+                                  "direction not normalized: " << dir);
+      const real_t sr = real_t(1.21) * inv_d;
+      const real_t sr6 = (sr*sr*sr)*(sr*sr*sr);
+      const real_t force = real_t(4) * real_t(2.12) * sr6 * ( sr6 - 1 );
+      bd1.addForce(force * dir);
+   }
+}
+
+inline
+void integrate(RigidBody& bd)
+{
+      bd.setLinearVel( bd.getForce() * real_t(0.01) + bd.getLinearVel() );
+      bd.setPosition( bd.getLinearVel() * real_t(0.01) + bd.getPosition() );
+      bd.setForce( Vec3( real_t(0) ) );
+}
+
+int main( int argc, char ** argv )
+{
+   Environment env(argc, argv);
+
+   logging::Logging::instance()->setStreamLogLevel(logging::Logging::INFO);
+   logging::Logging::instance()->setFileLogLevel(logging::Logging::INFO);
+
+   WALBERLA_LOG_INFO_ON_ROOT( "config file: " << argv[1] )
+         WALBERLA_LOG_INFO_ON_ROOT( "waLBerla Revision: " << WALBERLA_GIT_SHA1 );
+
+   math::seedRandomGenerator( static_cast<unsigned int>(1337 * mpi::MPIManager::instance()->worldRank()) );
+
+   WALBERLA_LOG_INFO_ON_ROOT("*** GLOBALBODYSTORAGE ***");
+   shared_ptr<BodyStorage> globalBodyStorage = make_shared<BodyStorage>();
+
+   WALBERLA_LOG_INFO_ON_ROOT("*** BLOCKFOREST ***");
+   //domain setup
+   const real_t spacing = real_t(1.0);
+   math::AABB domain( Vec3(real_t(-0.5), real_t(-0.5), real_t(-0.5)),
+                      Vec3(real_t(+0.5), real_t(+0.5), real_t(+0.5)));
+   domain.scale(real_t(20));
+
+   // create forest
+   auto forest = blockforest::createBlockForest(domain,
+                                                Vector3<uint_t>(1,1,1),
+                                                Vector3<bool>(false, false, false));
+   if (!forest)
+   {
+      WALBERLA_LOG_INFO_ON_ROOT( "No BlockForest created ... exiting!");
+      return EXIT_SUCCESS;
+   }
+
+   WALBERLA_LOG_INFO_ON_ROOT("simulationDomain: " << forest->getDomain());
+
+   WALBERLA_LOG_INFO_ON_ROOT("blocks: " << Vector3<uint_t>(forest->getXSize(), forest->getYSize(), forest->getZSize()) );
+
+   WALBERLA_LOG_INFO_ON_ROOT("*** BODYTUPLE ***");
+   // initialize body type ids
+   SetBodyTypeIDs<BodyTuple>::execute();
+
+   WALBERLA_LOG_INFO_ON_ROOT("*** STORAGEDATAHANDLING ***");
+   // add block data
+   auto storageID           = forest->addBlockData(createStorageDataHandling<BodyTuple>(), "Storage");
+   auto ccdID               = forest->addBlockData(ccd::createHashGridsDataHandling( globalBodyStorage, storageID ), "CCD");
+   auto fcdID               = forest->addBlockData(fcd::createGenericFCDDataHandling<BodyTuple, fcd::AnalyticCollideFunctor>(), "FCD");
+   WALBERLA_UNUSED(ccdID);
+   WALBERLA_UNUSED(fcdID);
+
+   WALBERLA_LOG_INFO_ON_ROOT("*** SYNCCALL ***");
+   std::function<void(void)> syncCallWithoutTT;
+   syncCallWithoutTT = std::bind( pe::syncNextNeighbors<BodyTuple>, std::ref(*forest), storageID, static_cast<WcTimingTree*>(nullptr), real_c(0.1), false );
+   WALBERLA_LOG_INFO_ON_ROOT("Using NextNeighbor sync!");
+
+   WALBERLA_LOG_INFO_ON_ROOT("*** VTK ***");
+   auto vtkDomainOutput = vtk::createVTKOutput_DomainDecomposition( forest, "domain_decomposition", 1, "vtk_out", "simulation_step" );
+   auto vtkSphereHelper = make_shared<SphereVtkOutput>(storageID, *forest) ;
+   auto vtkSphereOutput = vtk::createVTKOutput_PointData(vtkSphereHelper, "Bodies", 1, "vtk_out", "simulation_step", false, false);
+
+   WALBERLA_LOG_INFO_ON_ROOT("*** SETUP - START ***");
+   auto simulationDomain = forest->getDomain();
+   const auto& generationDomain = simulationDomain; // simulationDomain.getExtended(-real_c(0.5) * spacing);
+
+   //initialize particles
+   uint_t numParticles(0);
+   for (auto it = grid_generator::SCIterator(generationDomain, Vec3(spacing, spacing, spacing) * real_c(0.5), spacing);
+        it != grid_generator::SCIterator();
+        ++it)
+   {
+      SphereID sp = createSphere(*globalBodyStorage, *forest, storageID, 0, *it, real_t(1));
+
+      if (sp!=nullptr)
+      {
+         sp->setLinearVel( math::realRandom(real_t(-1), real_t(+1)),
+                           math::realRandom(real_t(-1), real_t(+1)),
+                           math::realRandom(real_t(-1), real_t(+1)));
+         ++numParticles;
+      }
+   }
+   mpi::reduceInplace(numParticles, mpi::SUM);
+   WALBERLA_LOG_INFO_ON_ROOT("#particles created: " << numParticles);
+
+   WALBERLA_LOG_INFO_ON_ROOT("*** SETUP - END ***");
+
+   // synchronize particles
+   //syncCallWithoutTT();
+   //syncCallWithoutTT();
+
+   WALBERLA_LOG_INFO_ON_ROOT("*** SIMULATION - START ***");
+   WALBERLA_MPI_BARRIER();
+   WcTimer timer;
+   for (int i=0; i < 1000; ++i)
+   {
+      WALBERLA_LOG_DEVEL(i);
+
+      for (auto& blk : *forest)
+      {
+         Storage* storage = blk.getData< Storage >( storageID );
+         BodyStorage& localStorage = (*storage)[0];
+
+         for (auto& bd1 : localStorage)
+         {
+            for (auto& bd2 : localStorage)
+            {
+               LJ(bd1, bd2);
+            }
+         }
+         const real_t coeff = real_t(0.2);
+         for (auto& bd : localStorage)
+         {
+            bd.addForce( -coeff*bd.getPosition() );
+         }
+      }
+
+      for (auto& blk : *forest)
+      {
+         Storage* storage = blk.getData< Storage >( storageID );
+         BodyStorage& localStorage = (*storage)[0];
+
+         for (auto& bd : localStorage)
+         {
+            integrate(bd);
+         }
+      }
+
+      vtkSphereOutput->write( );
+      //syncCallWithoutTT();
+   }
+   WALBERLA_MPI_BARRIER();
+   timer.end();
+   WALBERLA_LOG_INFO_ON_ROOT("runtime: " << timer.average());
+   WALBERLA_LOG_INFO_ON_ROOT("*** SIMULATION - END ***");
+   return EXIT_SUCCESS;
+}
+} // namespace walberla
+
+int main( int argc, char* argv[] )
+{
+   return walberla::main( argc, argv );
+}

apps/benchmarks/MeshDistance/CMakeLists.txt

 if ( WALBERLA_BUILD_WITH_OPENMESH )
-
-	waLBerla_link_files_to_builddir( "*.obj" )                 
-                                  
-	waLBerla_add_executable( NAME MeshDistanceBenchmark DEPENDS core mesh )
+        
+    waLBerla_link_geometry_to_builddir( "bunny.obj" )                                
+    waLBerla_add_executable( NAME MeshDistanceBenchmark DEPENDS walberla::core walberla::mesh )
 
 	##############
 	# Some tests #

apps/benchmarks/MeshDistance/MeshDistanceBenchmark.cpp

@@ -22,17 +22,18 @@
 #include "core/debug/TestSubsystem.h"
 #include "core/logging/Logging.h"
 #include "core/mpi/Environment.h"
+#include "core/stringToNum.h"
 #include "core/timing/Timer.h"
 
 #include "geometry/containment_octree/ContainmentOctree.h"
 #include "geometry/mesh/TriangleMesh.h"
 #include "geometry/mesh/TriangleMeshIO.h"
 
-#include "mesh/TriangleMeshes.h"
-#include "mesh/MeshOperations.h"
-#include "mesh/DistanceComputations.h"
-#include "mesh/distance_octree/DistanceOctree.h"
-#include "mesh/MeshIO.h"
+#include "mesh_common/TriangleMeshes.h"
+#include "mesh_common/MeshOperations.h"
+#include "mesh_common/DistanceComputations.h"
+#include "mesh_common/distance_octree/DistanceOctree.h"
+#include "mesh_common/MeshIO.h"
 
 #include <random>
 
@@ -164,8 +165,8 @@ int main( int argc, char * argv[] )
       WALBERLA_ABORT_NO_DEBUG_INFO( "USAGE: " << args[0] << " [--no-brute-force] [--force-float] MESH_FILE NUM_POINTS NUM_REPETITIONS" );
 
    const std::string & meshFile = args[1];
-   const uint_t numPoints       = boost::lexical_cast<uint_t>( args[2] );
-   const uint_t numRepetitions  = boost::lexical_cast<uint_t>( args[3] );
+   const uint_t numPoints       = stringToNum<uint_t>( args[2] );
+   const uint_t numRepetitions  = stringToNum<uint_t>( args[3] );
 
    if(forceFloat)
    {