Merge branch 'tuple' into 'master'

[API] Replace boost tuple and allow building Walberla without Boost

Closes #48

See merge request walberla/walberla!197

.gitlab-ci.yml

@@ -795,6 +795,22 @@ gcc_8_hybrid_dbg:
    tags:
       - docker
 
+gcc_8_hybrid_dbg_noboost:
+   <<: *build_definition
+   image: i10git.cs.fau.de:5005/walberla/buildenvs/gcc:8
+   before_script:
+      - rm -rf /opt/boost /usr/include/boost
+   variables:
+      <<: *build_hybrid_dbg_variables
+      WALBERLA_BUILD_WITH_CUDA: "OFF"
+      WALBERLA_ENABLE_GUI: 0
+      WALBERLA_BUILD_WITH_PYTHON: "OFF"
+   except:
+      variables:
+         - $DISABLE_PER_COMMIT_BUILDS
+   tags:
+      - docker
+
 gcc_8_hybrid_dbg_sp:
    <<: *build_definition
    image: i10git.cs.fau.de:5005/walberla/buildenvs/gcc:8

CMakeLists.txt

@@ -718,9 +718,18 @@ if ( Boost_FOUND )
       list( APPEND LINK_DIRS ${PYTHON_LIBRARY_DIR}/libs )
    endif()
 
+   set( WALBERLA_BUILD_WITH_BOOST TRUE CACHE INTERNAL "Build with Boost" )
 else( Boost_FOUND )
-   # Search again, this time with the REQUIRED option. This will give a CMAKE error and a detailed error message for the user
-   find_package ( Boost ${waLBerla_REQUIRED_MIN_BOOST_VERSION} REQUIRED ${waLBerla_REQUIRED_BOOST_COMPONENTS} OPTIONAL_COMPONENTS ${waLBerla_OPTIONAL_BOOST_COMPONENTS} )
+   if( (WALBERLA_USE_STD_EXPERIMENTAL_FILESYSTEM OR WALBERLA_USE_STD_FILESYSTEM) AND (WALBERLA_USE_STD_EXPERIMENTAL_ANY OR WALBERLA_USE_STD_ANY) AND (WALBERLA_USE_STD_EXPERIMENTAL_OPTIONAL OR WALBERLA_USE_STD_OPTIONAL) AND NOT WALBERLA_BUILD_WITH_PYTHON)
+      # we don't really need Boost
+      set( WALBERLA_BUILD_WITH_BOOST FALSE CACHE INTERNAL "Build with Boost" )
+   else()
+      # Search again, this time with the REQUIRED option. This will give a CMAKE error and a detailed error message for the user
+      find_package ( Boost ${waLBerla_REQUIRED_MIN_BOOST_VERSION} REQUIRED ${waLBerla_REQUIRED_BOOST_COMPONENTS} OPTIONAL_COMPONENTS ${waLBerla_OPTIONAL_BOOST_COMPONENTS} )
+      if( (WALBERLA_USE_STD_EXPERIMENTAL_FILESYSTEM OR WALBERLA_USE_STD_FILESYSTEM) AND (WALBERLA_USE_STD_EXPERIMENTAL_ANY OR WALBERLA_USE_STD_ANY) AND (WALBERLA_USE_STD_EXPERIMENTAL_OPTIONAL OR WALBERLA_USE_STD_OPTIONAL) )
+         message(WARNING "If you set WALBERLA_BUILD_WITH_PYTHON=OFF, you can build without the Boost library.")
+      endif()
+   endif()
 endif( Boost_FOUND )
 
 

apps/benchmarks/AdaptiveMeshRefinementFluidParticleCoupling/AMRSedimentSettling.cpp

@@ -106,8 +106,7 @@ typedef lbm::NoSlip< LatticeModel_T, flag_t > NoSlip_T;
 
 typedef pe_coupling::CurvedLinear< LatticeModel_T, FlagField_T > MO_T;
 
-typedef boost::tuples::tuple< NoSlip_T, MO_T > BoundaryConditions_T;
-typedef BoundaryHandling< FlagField_T, Stencil_T, BoundaryConditions_T > BoundaryHandling_T;
+typedef BoundaryHandling< FlagField_T, Stencil_T, NoSlip_T, MO_T > BoundaryHandling_T;
 
 typedef std::tuple<pe::Sphere, pe::Ellipsoid, pe::Plane> BodyTypeTuple;
 
@@ -590,8 +589,8 @@ BoundaryHandling_T * MyBoundaryHandling::initialize( IBlock * const block )
    WALBERLA_CHECK_NOT_NULLPTR( blocksPtr );
 
    BoundaryHandling_T * handling = new BoundaryHandling_T( "moving obstacle boundary handling", flagField, fluid,
-                                                           boost::tuples::make_tuple( NoSlip_T( "NoSlip", NoSlip_Flag, pdfField ),
-                                                                                      MO_T( "MO", MO_Flag, pdfField, flagField, bodyField, fluid, *blocksPtr, *block ) ),
+                                                           NoSlip_T( "NoSlip", NoSlip_Flag, pdfField ),
+                                                           MO_T( "MO", MO_Flag, pdfField, flagField, bodyField, fluid, *blocksPtr, *block ),
                                                            BoundaryHandling_T::Mode::ENTIRE_FIELD_TRAVERSAL);
 
    handling->fillWithDomain( FieldGhostLayers );

apps/benchmarks/AdaptiveMeshRefinementFluidParticleCoupling/WorkloadEvaluation.cpp

@@ -71,8 +71,6 @@
 #include "field/vtk/all.h"
 #include "lbm/vtk/all.h"
 
-#include <boost/tuple/tuple.hpp>
-
 #include <vector>
 #include <iomanip>
 #include <iostream>
@@ -102,8 +100,7 @@ const uint_t FieldGhostLayers = 1;
 // boundary handling
 typedef pe_coupling::CurvedLinear< LatticeModel_T, FlagField_T > MO_CLI_T;
 
-typedef boost::tuples::tuple<MO_CLI_T >               BoundaryConditions_T;
-typedef BoundaryHandling< FlagField_T, Stencil_T, BoundaryConditions_T > BoundaryHandling_T;
+typedef BoundaryHandling< FlagField_T, Stencil_T, MO_CLI_T > BoundaryHandling_T;
 
 typedef std::tuple<pe::Sphere, pe::Ellipsoid, pe::Plane> BodyTypeTuple;
 
@@ -152,7 +149,7 @@ BoundaryHandling_T * MyBoundaryHandling::operator()( IBlock * const block, const
    BoundaryHandling_T::Mode mode = (useEntireFieldTraversal_) ? BoundaryHandling_T::Mode::ENTIRE_FIELD_TRAVERSAL : BoundaryHandling_T::Mode::OPTIMIZED_SPARSE_TRAVERSAL ;
 
    BoundaryHandling_T * handling = new BoundaryHandling_T( "fixed obstacle boundary handling", flagField, fluid,
-                                                           boost::tuples::make_tuple( MO_CLI_T ( "MO_CLI", MO_CLI_Flag, pdfField, flagField, bodyField, fluid, *storage, *block ) ),
+                                                           MO_CLI_T ( "MO_CLI", MO_CLI_Flag, pdfField, flagField, bodyField, fluid, *storage, *block ),
                                                            mode);
 
    // boundaries are set by mapping the planes into the domain

apps/benchmarks/CouetteFlow/CouetteFlow.cpp

@@ -373,9 +373,7 @@ public:
    typedef lbm::NoSlip< LatticeModel_T, flag_t >    NoSlip_T;
    typedef lbm::SimpleUBB< LatticeModel_T, flag_t > UBB_T;
 
-   typedef boost::tuples::tuple< NoSlip_T, UBB_T > BoundaryConditions_T;
-
-   typedef BoundaryHandling< FlagField_T, typename Types<LatticeModel_T>::Stencil_T, BoundaryConditions_T > BoundaryHandling_T;
+   typedef BoundaryHandling< FlagField_T, typename Types<LatticeModel_T>::Stencil_T, NoSlip_T, UBB_T > BoundaryHandling_T;
 
 
 
@@ -405,8 +403,8 @@ MyBoundaryHandling<LatticeModel_T>::operator()( IBlock * const block ) const
    const flag_t fluid = flagField->registerFlag( Fluid_Flag );
 
    return new BoundaryHandling_T( "boundary handling", flagField, fluid,
-         boost::tuples::make_tuple( NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
-                                       UBB_T( "velocity bounce back", UBB_Flag, pdfField, topVelocity_, real_t(0), real_t(0) ) ) );
+                                  NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
+                                  UBB_T( "velocity bounce back", UBB_Flag, pdfField, topVelocity_, real_t(0), real_t(0) ) );
 }
 
 

apps/benchmarks/ForcesOnSphereNearPlaneInShearFlow/ForcesOnSphereNearPlaneInShearFlow.cpp

@@ -95,8 +95,7 @@ const uint_t FieldGhostLayers = 4;
 typedef pe_coupling::SimpleBB< LatticeModel_T, FlagField_T > MO_SBB_T;
 typedef pe_coupling::CurvedLinear< LatticeModel_T, FlagField_T > MO_CLI_T;
 
-typedef boost::tuples::tuple< MO_SBB_T, MO_CLI_T > BoundaryConditions_T;
-typedef BoundaryHandling< FlagField_T, Stencil_T, BoundaryConditions_T > BoundaryHandling_T;
+typedef BoundaryHandling< FlagField_T, Stencil_T, MO_SBB_T, MO_CLI_T > BoundaryHandling_T;
 
 typedef std::tuple< pe::Sphere, pe::Plane > BodyTypeTuple;
 
@@ -238,8 +237,8 @@ BoundaryHandling_T * MyBoundaryHandling::operator()( IBlock * const block, const
    const auto fluid = flagField->flagExists( Fluid_Flag ) ? flagField->getFlag( Fluid_Flag ) : flagField->registerFlag( Fluid_Flag );
 
    BoundaryHandling_T * handling = new BoundaryHandling_T( "moving obstacle boundary handling", flagField, fluid,
-         boost::tuples::make_tuple( MO_SBB_T( "MO_SBB", MO_SBB_Flag, pdfField, flagField, bodyField, fluid, *storage, *block ),
-                                    MO_CLI_T( "MO_CLI", MO_CLI_Flag, pdfField, flagField, bodyField, fluid, *storage, *block ) ) );
+                                                           MO_SBB_T( "MO_SBB", MO_SBB_Flag, pdfField, flagField, bodyField, fluid, *storage, *block ),
+                                                           MO_CLI_T( "MO_CLI", MO_CLI_Flag, pdfField, flagField, bodyField, fluid, *storage, *block ) );
 
    // boundary conditions are set by mapping the (moving) planes into the domain
 

apps/benchmarks/MotionSingleHeavySphere/MotionSingleHeavySphere.cpp

@@ -98,8 +98,7 @@ typedef pe_coupling::SimpleBB< LatticeModel_T, FlagField_T >        MEM_BB_T;
 typedef pe_coupling::CurvedLinear< LatticeModel_T, FlagField_T >    MEM_CLI_T;
 typedef pe_coupling::CurvedQuadratic< LatticeModel_T, FlagField_T > MEM_MR_T;
 
-typedef boost::tuples::tuple< UBB_T, Outlet_T, MEM_BB_T, MEM_CLI_T, MEM_MR_T > BoundaryConditions_T;
-typedef BoundaryHandling< FlagField_T, Stencil_T, BoundaryConditions_T > BoundaryHandling_T;
+typedef BoundaryHandling< FlagField_T, Stencil_T, UBB_T, Outlet_T, MEM_BB_T, MEM_CLI_T, MEM_MR_T > BoundaryHandling_T;
 
 using BodyTypeTuple = std::tuple<pe::Sphere>;
 
@@ -199,11 +198,11 @@ BoundaryHandling_T * MyBoundaryHandling::operator()( IBlock * const block, const
    const auto fluid = flagField->flagExists( Fluid_Flag ) ? flagField->getFlag( Fluid_Flag ) : flagField->registerFlag( Fluid_Flag );
 
    BoundaryHandling_T * handling = new BoundaryHandling_T( "moving obstacle boundary handling", flagField, fluid,
-         boost::tuples::make_tuple( UBB_T( "UBB", UBB_Flag, pdfField, velocity_),
+                                    UBB_T( "UBB", UBB_Flag, pdfField, velocity_),
                                     Outlet_T( "Outlet", Outlet_Flag, pdfField, real_t(1) ),
                                     MEM_BB_T (  "MEM_BB",  MEM_BB_Flag, pdfField, flagField, bodyField, fluid, *storage, *block ),
                                     MEM_CLI_T( "MEM_CLI", MEM_CLI_Flag, pdfField, flagField, bodyField, fluid, *storage, *block ),
-                                    MEM_MR_T (  "MEM_MR",  MEM_MR_Flag, pdfField, flagField, bodyField, fluid, *storage, *block, pdfFieldPreCol ) )  );
+                                    MEM_MR_T (  "MEM_MR",  MEM_MR_Flag, pdfField, flagField, bodyField, fluid, *storage, *block, pdfFieldPreCol ) );
 
    const auto ubb = flagField->getFlag( UBB_Flag );
    const auto outlet = flagField->getFlag( Outlet_Flag );

apps/benchmarks/NonUniformGrid/NonUniformGrid.cpp

@@ -434,9 +434,7 @@ struct MyBoundaryTypes
    typedef lbm::NoSlip< LatticeModel_T, flag_t >    NoSlip_T;
    typedef lbm::SimpleUBB< LatticeModel_T, flag_t > UBB_T;
 
-   typedef boost::tuples::tuple< NoSlip_T, UBB_T > BoundaryConditions_T;
-
-   typedef BoundaryHandling< FlagField_T, typename Types<LatticeModel_T>::Stencil_T, BoundaryConditions_T > BoundaryHandling_T;
+   typedef BoundaryHandling< FlagField_T, typename Types<LatticeModel_T>::Stencil_T, NoSlip_T, UBB_T > BoundaryHandling_T;
 };  
 
 template< typename LatticeModel_T >
@@ -447,8 +445,6 @@ public:
    using NoSlip_T = typename MyBoundaryTypes< LatticeModel_T >::NoSlip_T;
    using UBB_T = typename MyBoundaryTypes< LatticeModel_T >::UBB_T;
 
-   using BoundaryConditions_T = typename MyBoundaryTypes< LatticeModel_T >::BoundaryConditions_T;
-
    using BoundaryHandling_T = typename MyBoundaryTypes< LatticeModel_T >::BoundaryHandling_T;
 
 
@@ -484,8 +480,8 @@ MyBoundaryHandling<LatticeModel_T>::initialize( IBlock * const block )
    const auto fluid = flagField->flagExists( Fluid_Flag ) ? flagField->getFlag( Fluid_Flag ) : flagField->registerFlag( Fluid_Flag );
 
    BoundaryHandling_T * handling = new BoundaryHandling_T( "boundary handling", flagField, fluid,
-         boost::tuples::make_tuple( NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
-                                       UBB_T( "velocity bounce back", UBB_Flag, pdfField, velocity_, real_c(0), real_c(0) ) ) );
+                                                           NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
+                                                           UBB_T( "velocity bounce back", UBB_Flag, pdfField, velocity_, real_c(0), real_c(0) ) );
 
    auto forest = forest_.lock();
    WALBERLA_CHECK_NOT_NULLPTR( forest );

apps/benchmarks/PoiseuilleChannel/PoiseuilleChannel.cpp

@@ -458,9 +458,7 @@ public:
    typedef lbm::NoSlip< LatticeModel_T, flag_t >      NoSlip_T;
    typedef lbm::Curved< LatticeModel_T, FlagField_T > Curved_T;
 
-   typedef boost::tuples::tuple< NoSlip_T, Curved_T > BoundaryConditions_T;
-
-   typedef BoundaryHandling< FlagField_T, typename Types<LatticeModel_T>::Stencil_T, BoundaryConditions_T > BoundaryHandling_T;
+   typedef BoundaryHandling< FlagField_T, typename Types<LatticeModel_T>::Stencil_T, NoSlip_T, Curved_T > BoundaryHandling_T;
 
 
 
@@ -488,8 +486,8 @@ MyBoundaryHandling<LatticeModel_T>::operator()( IBlock * const block ) const
    const flag_t fluid = flagField->registerFlag( Fluid_Flag );
 
    return new BoundaryHandling_T( "boundary handling", flagField, fluid,
-         boost::tuples::make_tuple( NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
-                                    Curved_T( "curved", Curved_Flag, pdfField, flagField, fluid ) ) );
+                                   NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
+                                   Curved_T( "curved", Curved_Flag, pdfField, flagField, fluid ) );
 }
 
 

apps/benchmarks/SchaeferTurek/SchaeferTurek.cpp

@@ -784,11 +784,8 @@ struct MyBoundaryTypes
    typedef lbm::Outlet< LatticeModel_T, FlagField_T, 2, 1 >                       Outlet21_T;
    typedef lbm::Outlet< LatticeModel_T, FlagField_T, 4, 3 >                       Outlet43_T;
    typedef lbm::SimplePressure< LatticeModel_T, flag_t >                          PressureOutlet_T;
-   
-
-   typedef boost::tuples::tuple< NoSlip_T, Obstacle_T, Curved_T, DynamicUBB_T, Outlet21_T, Outlet43_T, PressureOutlet_T > BoundaryConditions_T;
 
-   typedef BoundaryHandling< FlagField_T, typename Types<LatticeModel_T>::Stencil_T, BoundaryConditions_T > BoundaryHandling_T;
+   typedef BoundaryHandling< FlagField_T, typename Types<LatticeModel_T>::Stencil_T, NoSlip_T, Obstacle_T, Curved_T, DynamicUBB_T, Outlet21_T, Outlet43_T, PressureOutlet_T > BoundaryHandling_T;
 };
 
 
@@ -805,8 +802,6 @@ public:
    using Outlet43_T = typename MyBoundaryTypes<LatticeModel_T>::Outlet43_T;
    using PressureOutlet_T = typename MyBoundaryTypes<LatticeModel_T>::PressureOutlet_T;
 
-   using BoundaryConditions_T = typename MyBoundaryTypes<LatticeModel_T>::BoundaryConditions_T;
-
    using BoundaryHandling_T = typename MyBoundaryTypes<LatticeModel_T>::BoundaryHandling_T;
 
 
@@ -848,13 +843,13 @@ MyBoundaryHandling<LatticeModel_T>::initialize( IBlock * const block )
    SinusInflowVelocity<Is2D< LatticeModel_T >::value> velocity( setup_.inflowVelocity_L, setup_.raisingTime_L, setup_.sinPeriod_L, setup_.H );
 
    return new BoundaryHandling_T( "boundary handling", flagField, fluid,
-         boost::tuples::make_tuple( NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
+                                    NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
                                   Obstacle_T( "obstacle (staircase)", Obstacle_Flag, pdfField ),
                                     Curved_T( "obstacle (curved)", Curved_Flag, pdfField, flagField, fluid ),
                                 DynamicUBB_T( "velocity bounce back", UBB_Flag, pdfField, timeTracker_, blocks->getLevel(*block), velocity, block->getAABB() ),
                                   Outlet21_T( "outlet (2/1)", Outlet21_Flag, pdfField, flagField, fluid ),
                                   Outlet43_T( "outlet (4/3)", Outlet43_Flag, pdfField, flagField, fluid ),
-                            PressureOutlet_T( "pressure outlet", PressureOutlet_Flag, pdfField, real_t(1) ) ) );
+                            PressureOutlet_T( "pressure outlet", PressureOutlet_Flag, pdfField, real_t(1) ) );
 }
 
 

apps/benchmarks/UniformGrid/UniformGrid.cpp

@@ -353,9 +353,7 @@ public:
    typedef lbm::NoSlip< LatticeModel_T, flag_t >    NoSlip_T;
    typedef lbm::SimpleUBB< LatticeModel_T, flag_t > UBB_T;
 
-   typedef boost::tuples::tuple< NoSlip_T, UBB_T > BoundaryConditions_T;
-
-   typedef BoundaryHandling< FlagField_T, typename Types<LatticeModel_T>::Stencil_T, BoundaryConditions_T > BoundaryHandling_T;
+   typedef BoundaryHandling< FlagField_T, typename Types<LatticeModel_T>::Stencil_T, NoSlip_T, UBB_T > BoundaryHandling_T;
 
 
 
@@ -388,8 +386,8 @@ MyBoundaryHandling<LatticeModel_T>::operator()( IBlock * const block, const Stru
    const auto fluid = flagField->flagExists( Fluid_Flag ) ? flagField->getFlag( Fluid_Flag ) : flagField->registerFlag( Fluid_Flag );
 
    BoundaryHandling_T * handling = new BoundaryHandling_T( "boundary handling", flagField, fluid,
-         boost::tuples::make_tuple( NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
-                                       UBB_T( "velocity bounce back", UBB_Flag, pdfField, velocity_, real_c(0), real_c(0) ) ) );
+                                                           NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
+                                                           UBB_T( "velocity bounce back", UBB_Flag, pdfField, velocity_, real_c(0), real_c(0) ) );
 
    CellInterval domainBB = storage->getDomainCellBB();
    storage->transformGlobalToBlockLocalCellInterval( domainBB, *block );

apps/showcases/BidisperseFluidizedBed/BidisperseFluidizedBedDPM.cpp

@@ -98,8 +98,7 @@ typedef lbm::Outlet< LatticeModel_T, FlagField_T >                     Outflow_T
 typedef lbm::SimplePressure< LatticeModel_T, flag_t >                  Outflow_T;
 #endif
 
-typedef boost::tuples::tuple< NoSlip_T, Inflow_T, Outflow_T >          BoundaryConditions_T;
-typedef BoundaryHandling<FlagField_T, Stencil_T, BoundaryConditions_T> BoundaryHandling_T;
+typedef BoundaryHandling<FlagField_T, Stencil_T, NoSlip_T, Inflow_T, Outflow_T> BoundaryHandling_T;
 
 typedef std::tuple<pe::Plane, pe::Sphere> BodyTypeTuple ;
 
@@ -165,14 +164,14 @@ BoundaryHandling_T * MyBoundaryHandling::operator()( IBlock * const block, const
 
 #ifdef OutletBC
    BoundaryHandling_T * handling = new BoundaryHandling_T( "Boundary handling", flagField, fluid,
-         boost::tuples::make_tuple( NoSlip_T( "NoSlip", NoSlip_Flag, pdfField ),
+                                    NoSlip_T( "NoSlip", NoSlip_Flag, pdfField ),
                                     Inflow_T( "Inflow", Inflow_Flag, pdfField, Vector3<real_t>(real_t(0),real_t(0),uInflow_) ),
-                                    Outflow_T( "Outflow", Outflow_Flag, pdfField, flagField, fluid ) ) );
+                                    Outflow_T( "Outflow", Outflow_Flag, pdfField, flagField, fluid ) );
 #else
    BoundaryHandling_T * handling = new BoundaryHandling_T( "Boundary handling", flagField, fluid,
-         boost::tuples::make_tuple( NoSlip_T( "NoSlip", NoSlip_Flag, pdfField ),
+                                    NoSlip_T( "NoSlip", NoSlip_Flag, pdfField ),
                                     Inflow_T( "Inflow", Inflow_Flag, pdfField, Vector3<real_t>(real_t(0),real_t(0),uInflow_) ),
-                                    Outflow_T( "Outflow", Outflow_Flag, pdfField, real_t(1) ) ) );
+                                    Outflow_T( "Outflow", Outflow_Flag, pdfField, real_t(1) ) );
 #endif
 
    const auto noslip  = flagField->getFlag( NoSlip_Flag );

apps/tutorials/lbm/03_LBLidDrivenCavity.cpp

@@ -79,10 +79,7 @@ typedef lbm::NoSlip< LatticeModel_T, flag_t >     NoSlip_T; // no slip boundary
 typedef lbm::SimpleUBB< LatticeModel_T, flag_t >  UBB_T;    // velocity bounce back boundary condition that internally works with one ...
                                                             // ... constant velocity that must be set during the setup phase
 
-typedef boost::tuples::tuple< NoSlip_T, UBB_T >  BoundaryConditions_T; // a collection of all boundary conditions - required for
-                                                                       // defining the type of the boundary handling (see below)
-
-typedef BoundaryHandling< FlagField_T, Stencil_T, BoundaryConditions_T > BoundaryHandling_T; // the boundary handling
+typedef BoundaryHandling< FlagField_T, Stencil_T, NoSlip_T, UBB_T > BoundaryHandling_T; // the boundary handling, includes a collection of all boundary conditions
 
 ///////////
 // FLAGS //
@@ -139,11 +136,11 @@ BoundaryHandling_T * MyBoundaryHandling::operator()( IBlock * const block ) cons
    // The fluid flag is used in order to decide whether a certain cell is part of the domain (and therefore has to be
    // treated by the boundary handling if it is located next to a boundary). Also, the no slip and velocity bounce back
    // boundary conditions are initialized (Please note that the order in which these boundary conditions are initialized
-   // must be identical to the order in 'BoundaryConditions_T'!).
+   // must be identical to the order of the template arguments of 'BoundaryHandling_T'!).
 
    return new BoundaryHandling_T( "boundary handling", flagField, fluid,
-         boost::tuples::make_tuple( NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
-                                       UBB_T( "velocity bounce back", UBB_Flag, pdfField, topVelocity_, real_c(0), real_c(0) ) ) );
+                                  NoSlip_T( "no slip", NoSlip_Flag, pdfField ),
+                                     UBB_T( "velocity bounce back", UBB_Flag, pdfField, topVelocity_, real_c(0), real_c(0) ) );
 }
 
 
@@ -420,4 +417,4 @@ int main( int argc, char ** argv )
 int main( int argc, char ** argv )
 {
    return walberla::main(argc, argv);
-}
\ No newline at end of file
+}

src/blockforest/BlockForest.h

@@ -854,7 +854,7 @@ template< typename T >
 inline BlockDataID BlockForest::addBlockData( const shared_ptr< T > & dataHandling, const std::string & identifier,
                                               const Set<SUID> & requiredSelectors, const Set<SUID> & incompatibleSelectors )
 {
-   //static_assert( boost::is_base_of< BlockDataHandling<typename T::value_type>, T >::value );
+   //static_assert( std::is_base_of< BlockDataHandling<typename T::value_type>, T >::value );
 
    auto downcast = dynamic_pointer_cast< blockforest::BlockDataHandling<typename T::value_type> >( dataHandling );
 

src/core/config/ConfigToBoostPropertyTree.cpp

@@ -19,6 +19,9 @@
 //
 //======================================================================================================================
 
+#include "waLBerlaDefinitions.h"
+#ifdef WALBERLA_BUILD_WITH_BOOST
+
 #include "ConfigToBoostPropertyTree.h"
 
 #include <boost/property_tree/ptree.hpp>
@@ -51,3 +54,5 @@ boost::property_tree::iptree configToBoostPropertyTree( const Config & config )
 
 } // namespace config
 } // namespace walberla
+
+#endif

src/core/config/all.h

@@ -23,5 +23,7 @@
 #pragma once
 
 #include "Config.h"
+#ifdef WALBERLA_BUILD_WITH_BOOST
 #include "ConfigToBoostPropertyTree.h"
+#endif
 #include "Create.h"

src/core/math/PhysicalCheck.cpp

@@ -19,6 +19,9 @@
 //
 //======================================================================================================================
 
+#include "waLBerlaDefinitions.h"
+#ifdef WALBERLA_BUILD_WITH_BOOST
+
 #include "PhysicalCheck.h"
 #include "core/Abort.h"
 #include "core/logging/Logging.h"
@@ -536,3 +539,5 @@ namespace math {
 
 } // namespace math
 } // namespace walberla
+
+#endif

src/core/math/all.h

@@ -36,7 +36,9 @@
 #include "Matrix3.h"
 #include "Parser.h"
 #include "ParserOMP.h"
+#ifdef WALBERLA_BUILD_WITH_BOOST
 #include "PhysicalCheck.h"
+#endif
 #include "Plane.h"
 #include "Primes.h"
 #include "Random.h"