Commit 5dd3fa5e authored by Praetorius, Simon's avatar Praetorius, Simon
Browse files

added toolchain intel/2018a easyconfigs

parent 92662f07
# EasyConfig file for bundled dune modules
name = 'dune'
version = '2.6.0'
easyblock = 'Bundle'
homepage = 'http://www.dune-project.org'
description = """DUNE, the Distributed and Unified Numerics Environment is a modular toolbox for solving partial differential equations (PDEs) with grid-based methods."""
toolchain = {'name': 'intel', 'version': '2018a'}
dependencies = [
('dune-common', version),
('dune-geometry', version),
('dune-localfunctions', version),
('dune-grid', version),
('dune-istl', version),
('dune-typetree', version),
('dune-uggrid', version),
# ('dune-functions', version),
('dune-alugrid', version),
('dune-multidomaingrid', version),
('dune-spgrid', '2.6.0rc1'),
('dune-fem', '2.6.0rc2'),
# ('dune-pdelab', '2.6.0-rc1'),
]
moduleclass = 'math'
name = 'SuperLU'
version = '5.2.1'
homepage = 'http://crd-legacy.lbl.gov/~xiaoye/SuperLU/'
description = """SuperLU is a general purpose library for the direct solution of large, sparse, nonsymmetric systems
of linear equations on high performance machines."""
toolchain = {'name': 'intel', 'version': '2018a'}
toolchainopts = {'opt': True, 'pic': True}
source_urls = ['http://crd-legacy.lbl.gov/~xiaoye/SuperLU/']
sources = ["superlu_%(version)s.tar.gz"]
checksums = ['28fb66d6107ee66248d5cf508c79de03d0621852a0ddeba7301801d3d859f463']
builddependencies = [
('CMake', '3.11.1')
]
easyblock = 'CMakeMake'
configopts = '-DCMAKE_BUILD_TYPE=Release'
sanity_check_paths = {
'files': [],
'dirs': ['include', ('lib', 'lib64')]
}
moduleclass = 'numlib'
diff --git a/dune/fem/common/forloop.hh b/dune/fem/common/forloop.hh
index a72baa3..efcad80 100644
--- a/dune/fem/common/forloop.hh
+++ b/dune/fem/common/forloop.hh
@@ -5,6 +5,7 @@
#include <dune/common/deprecated.hh>
#include <dune/common/hybridutilities.hh>
+#include <dune/common/std/apply.hh>
#include <dune/common/std/utility.hh>
namespace Dune
@@ -21,7 +22,12 @@ namespace Dune
static void apply(Args&&... args)
{
Dune::Hybrid::forEach(Std::make_index_sequence<last+1-first>{},
- [&](auto i){Operation<i+first>::apply(args...);});
+ [t = std::forward_as_tuple(std::forward<Args>(args)...)](auto i)
+ {
+ Std::apply([i](auto&&... a) {
+ Operation<i.value + first>::apply(std::forward<decltype(a)>(a)...);
+ }, t);
+ });
}
};
diff --git a/dune/fem/function/common/gridfunctionadapter.hh b/dune/fem/function/common/gridfunctionadapter.hh
index 168a8cb..5464a06 100644
--- a/dune/fem/function/common/gridfunctionadapter.hh
+++ b/dune/fem/function/common/gridfunctionadapter.hh
@@ -285,11 +285,25 @@ namespace Dune
}
//! evaluate function or jacobian of function for given quadrature
- template < class QuadratureType, class ... Vectors >
- void evaluateQuadrature( const QuadratureType& quadrature, Vectors& ... values ) const
+ template < class QuadratureType, class Vector0 >
+ void evaluateQuadrature( const QuadratureType& quadrature, Vector0& value0 ) const
{
- static_assert( sizeof...( Vectors ) > 0, "evaluateQuadrature needs to be called with at least one vector." );
- std::ignore = std::make_tuple( ( evaluateQuadratureImp( quadrature, values ), 1 ) ... );
+ evaluateQuadratureImp( quadrature, value0 );
+ }
+
+ template < class QuadratureType, class Vector0, class Vector1 >
+ void evaluateQuadrature( const QuadratureType& quadrature, Vector0& value0, Vector1& value1 ) const
+ {
+ evaluateQuadratureImp( quadrature, value0 );
+ evaluateQuadratureImp( quadrature, value1 );
+ }
+
+ template < class QuadratureType, class Vector0, class Vector1, class Vector2 >
+ void evaluateQuadrature( const QuadratureType& quadrature, Vector0& value0, Vector1& value1, Vector2& value2 ) const
+ {
+ evaluateQuadratureImp( quadrature, value0 );
+ evaluateQuadratureImp( quadrature, value1 );
+ evaluateQuadratureImp( quadrature, value2 );
}
int order () const { return order_; }
diff --git a/dune/fem/common/test/test-hybrid.cc b/dune/fem/common/test/test-hybrid.cc
index ce910c1..05ac7cb 100644
--- a/dune/fem/common/test/test-hybrid.cc
+++ b/dune/fem/common/test/test-hybrid.cc
@@ -39,8 +39,8 @@ int main ( int argc, char *argv[] )
typedef std::tuple< std::array< int, 3 >, std::array< int, 4 >, std::array< int, 5 > > Tuple2;
std::tuple< Tuple1, Tuple2 > tuple;
- using namespace Dune::Indices;
Dune::Hybrid::forEach( Range2(), [ &tuple ] ( auto i ) {
+ using namespace Dune::Indices;
std::get< i[ _1 ] >( std::get< i[ _0 ] >( tuple ) )[ i[ _2 ] ] = static_cast< int >( i );
} );
diff --git a/dune/functions/functionspacebases/boundarydofs.hh b/dune/functions/functionspacebases/boundarydofs.hh
index 4925d81..5bdc695 100644
--- a/dune/functions/functionspacebases/boundarydofs.hh
+++ b/dune/functions/functionspacebases/boundarydofs.hh
@@ -5,6 +5,7 @@
#include <utility>
+#include <dune/common/std/type_traits.hh>
#include <dune/functions/functionspacebases/subentitydofs.hh>
namespace Dune {
@@ -32,7 +33,9 @@ namespace Functions {
* \param f A callback that will be called with a local index, a bound local view, and an intersection of the visited boundary DOF
*/
template<class Basis, class F,
- decltype(std::declval<std::decay_t<F>>()(0, std::declval<typename Basis::LocalView>(),std::declval<typename Basis::GridView::Intersection>()), 0) = 0>
+ class LocalView = typename Basis::LocalView,
+ class Intersection = typename Basis::GridView::Intersection,
+ std::enable_if_t<Std::is_callable<F(std::size_t, LocalView, Intersection)>::value, int> = 0>
void forEachBoundaryDOF(const Basis& basis, F&& f)
{
auto localView = basis.localView();
@@ -69,7 +72,8 @@ void forEachBoundaryDOF(const Basis& basis, F&& f)
* \param f A callback that will be called with a local index and a bound local view of the visited boundary DOF
*/
template<class Basis, class F,
- decltype(std::declval<std::decay_t<F>>()(0, std::declval<typename Basis::LocalView>()),0) = 0>
+ class LocalView = typename Basis::LocalView,
+ std::enable_if_t<Std::is_callable<F(std::size_t, LocalView)>::value, int> = 0>
void forEachBoundaryDOF(const Basis& basis, F&& f)
{
auto localView = basis.localView();
@@ -105,7 +109,8 @@ void forEachBoundaryDOF(const Basis& basis, F&& f)
* \param f A callback that will be called with the global index of the visited boundary DOF
*/
template<class Basis, class F,
- decltype(std::declval<std::decay_t<F>>()(std::declval<typename Basis::LocalIndexSet::MultiIndex>()),0) = 0>
+ class MultiIndex = typename Basis::LocalIndexSet::MultiIndex,
+ std::enable_if_t<Std::is_callable<F(MultiIndex)>::value, int> = 0>
void forEachBoundaryDOF(const Basis& basis, F&& f)
{
auto localView = basis.localView();
diff --git a/dune/functions/functionspacebases/bsplinebasis.hh b/dune/functions/functionspacebases/bsplinebasis.hh
index 18fe841..4afba89 100644
--- a/dune/functions/functionspacebases/bsplinebasis.hh
+++ b/dune/functions/functionspacebases/bsplinebasis.hh
@@ -47,8 +47,8 @@ class BSplineLocalBasis
public:
//! \brief export type traits for function signature
- typedef LocalBasisTraits<D,dim,Dune::FieldVector<D,dim>,R,1,Dune::FieldVector<R,1>,
- Dune::FieldMatrix<R,1,dim>, 2> Traits;
+ typedef LocalBasisTraits<D,dim,FieldVector<D,dim>,R,1,FieldVector<R,1>,
+ FieldMatrix<R,1,dim>> Traits;
/** \brief Constructor with a given B-spline patch
*
@@ -90,7 +90,7 @@ public:
//! \brief Evaluate all shape functions and derivatives of any order
template<size_t k>
- inline void evaluate (const typename Dune::array<int,k>& directions,
+ inline void evaluate (const typename std::array<int,k>& directions,
const typename Traits::DomainType& in,
std::vector<typename Traits::RangeType>& out) const
{
@@ -641,7 +641,7 @@ public:
BSplineNodeFactory(const GridView& gridView,
const FieldVector<double,dim>& lowerLeft,
const FieldVector<double,dim>& upperRight,
- const array<unsigned int,dim>& elements,
+ const std::array<unsigned int,dim>& elements,
unsigned int order,
bool makeOpen = true)
: elements_(elements),
@@ -763,7 +763,7 @@ public:
const std::array<uint,dim>& currentKnotSpan) const
{
// Evaluate
- Dune::array<std::vector<R>, dim> oneDValues;
+ std::array<std::vector<R>, dim> oneDValues;
for (size_t i=0; i<dim; i++)
evaluateFunction(in[i], oneDValues[i], knotVectors_[i], order_[i], currentKnotSpan[i]);
@@ -810,12 +810,12 @@ public:
offset[i] = std::max((int)(currentKnotSpan[i] - order_[i]),0);
// Evaluate 1d function values (needed for the product rule)
- Dune::array<std::vector<R>, dim> oneDValues;
+ std::array<std::vector<R>, dim> oneDValues;
// Evaluate 1d function values of one order lower (needed for the derivative formula)
- Dune::array<std::vector<R>, dim> lowOrderOneDValues;
+ std::array<std::vector<R>, dim> lowOrderOneDValues;
- Dune::array<DynamicMatrix<R>, dim> values;
+ std::array<DynamicMatrix<R>, dim> values;
for (size_t i=0; i<dim; i++)
{
@@ -834,7 +834,7 @@ public:
// Evaluate 1d function derivatives
- Dune::array<std::vector<R>, dim> oneDDerivatives;
+ std::array<std::vector<R>, dim> oneDDerivatives;
for (size_t i=0; i<dim; i++)
{
oneDDerivatives[i].resize(limits[i]);
@@ -859,7 +859,7 @@ public:
// Working towards computing only the parts that we really need:
// Let's copy them out into a separate array
- Dune::array<std::vector<R>, dim> oneDValuesShort;
+ std::array<std::vector<R>, dim> oneDValuesShort;
for (int i=0; i<dim; i++)
{
@@ -1211,10 +1211,10 @@ public:
/** \brief Order of the B-spline for each space dimension */
- array<unsigned int, dim> order_;
+ std::array<unsigned int, dim> order_;
/** \brief The knot vectors, one for each space dimension */
- array<std::vector<double>, dim> knotVectors_;
+ std::array<std::vector<double>, dim> knotVectors_;
/** \brief Number of grid elements in the different coordinate directions */
std::array<uint,dim> elements_;
diff --git a/dune/functions/functionspacebases/compositebasis.hh b/dune/functions/functionspacebases/compositebasis.hh
index e821cc9..7b015c3 100644
--- a/dune/functions/functionspacebases/compositebasis.hh
+++ b/dune/functions/functionspacebases/compositebasis.hh
@@ -149,9 +149,8 @@ public:
//! Initialize the global indices
void initializeIndices()
{
- using namespace Dune::Hybrid;
- forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
- elementAt(subFactories_, i).initializeIndices();
+ Hybrid::forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
+ Hybrid::elementAt(subFactories_, i).initializeIndices();
});
}
@@ -164,9 +163,8 @@ public:
//! Update the stored grid view, to be called if the grid has changed
void update(const GridView& gv)
{
- using namespace Dune::Hybrid;
- forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
- elementAt(subFactories_, i).update(gv);
+ Hybrid::forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
+ Hybrid::elementAt(subFactories_, i).update(gv);
});
}
@@ -184,9 +182,8 @@ public:
Node<TP> node(const TP& tp) const
{
auto node = Node<TP>(tp);
- using namespace Dune::Hybrid;
- forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
- node.setChild( elementAt(subFactories_, i).node(TypeTree::push_back(tp, i)), i);
+ Hybrid::forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
+ node.setChild( Hybrid::elementAt(subFactories_, i).node(TypeTree::push_back(tp, i)), i);
});
return node;
}
@@ -260,10 +257,9 @@ private:
size_type size(const SizePrefix& prefix, BasisBuilder::FlatLexicographic) const
{
size_type r = 0;
- using namespace Dune::Hybrid;
if (prefix.size() == 0)
- forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
- r += elementAt(subFactories_, i).size();
+ Hybrid::forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
+ r += Hybrid::elementAt(subFactories_, i).size();
});
else {
size_type shiftedFirst = prefix[0];
@@ -279,9 +275,8 @@ public:
{
size_type r=0;
// Accumulate dimension() for all subfactories
- using namespace Dune::Hybrid;
- forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
- r += elementAt(subFactories_, i).dimension();
+ Hybrid::forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
+ r += Hybrid::elementAt(subFactories_, i).dimension();
});
return r;
}
@@ -291,9 +286,8 @@ public:
{
size_type r=0;
// Accumulate maxNodeSize() for all subfactories
- using namespace Dune::Hybrid;
- forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
- r += elementAt(subFactories_, i).maxNodeSize();
+ Hybrid::forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
+ r += Hybrid::elementAt(subFactories_, i).maxNodeSize();
});
return r;
}
@@ -348,18 +342,16 @@ public:
void bind(const Node& node)
{
node_ = &node;
- using namespace Dune::Hybrid;
- forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
- elementAt(subNodeIndexSetTuple_, i).bind(node.child(i));
+ Hybrid::forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
+ Hybrid::elementAt(subNodeIndexSetTuple_, i).bind(node.child(i));
});
}
void unbind()
{
node_ = nullptr;
- using namespace Dune::Hybrid;
- forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
- elementAt(subNodeIndexSetTuple_, i).unbind();
+ Hybrid::forEach(Dune::Std::make_index_sequence<children>(), [&](auto i) {
+ Hybrid::elementAt(subNodeIndexSetTuple_, i).unbind();
});
}
diff --git a/dune/functions/functionspacebases/defaultglobalbasis.hh b/dune/functions/functionspacebases/defaultglobalbasis.hh
index 1d697ac..f89de50 100644
--- a/dune/functions/functionspacebases/defaultglobalbasis.hh
+++ b/dune/functions/functionspacebases/defaultglobalbasis.hh
@@ -11,6 +11,7 @@
#include <dune/functions/functionspacebases/defaultlocalindexset.hh>
#include <dune/functions/functionspacebases/defaultlocalview.hh>
#include <dune/functions/functionspacebases/concepts.hh>
+#include <dune/functions/functionspacebases/flatmultiindex.hh>
@@ -167,17 +168,26 @@ namespace BasisBuilder {
template<class GridView, class FactoryTag>
auto makeBasis(const GridView& gridView, FactoryTag&& factoryTag)
- -> DefaultGlobalBasis<decltype(factoryTag.template build<typename Dune::ReservedVector<std::size_t, FactoryTag::requiredMultiIndexSize> >(gridView))>
{
- using MultiIndex = typename Dune::ReservedVector<std::size_t, FactoryTag::requiredMultiIndexSize>;
- return {factoryTag.template build<MultiIndex>(gridView)};
+ using RawFactoryTag = std::decay_t<FactoryTag>;
+ using MultiIndex = std::conditional_t<
+ (RawFactoryTag::requiredMultiIndexSize == 1),
+ FlatMultiIndex<std::size_t>,
+ ReservedVector<std::size_t, RawFactoryTag::requiredMultiIndexSize>>;
+
+ auto nf = factoryTag.template build<MultiIndex>(gridView);
+ using NF = std::decay_t<decltype(nf)>;
+
+ return DefaultGlobalBasis<NF>(std::move(nf));
}
template<class MultiIndex, class GridView, class FactoryTag>
auto makeBasis(const GridView& gridView, FactoryTag&& factoryTag)
- -> DefaultGlobalBasis<decltype(factoryTag.template build<MultiIndex>(gridView))>
{
- return {factoryTag.template build<MultiIndex>(gridView)};
+ auto nf = factoryTag.template build<MultiIndex>(gridView);
+ using NF = std::decay_t<decltype(nf)>;
+
+ return DefaultGlobalBasis<NF>(std::move(nf));
}
} // end namespace BasisBuilder
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 57be22e..72bf370 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,14 +1,14 @@
-add_executable("advection-reaction-dg" advection-reaction-dg.cc)
-target_link_dune_default_libraries("advection-reaction-dg")
-
-add_executable("interpolation" interpolation.cc)
-target_link_dune_default_libraries("interpolation")
-
-add_executable("poisson-pq2" poisson-pq2.cc)
-target_link_dune_default_libraries("poisson-pq2")
-
-add_executable("stokes-taylorhood" stokes-taylorhood.cc)
-target_link_dune_default_libraries("stokes-taylorhood")
-
-add_executable("poisson-mfem" poisson-mfem.cc)
-target_link_dune_default_libraries("poisson-mfem")
+# add_executable("advection-reaction-dg" advection-reaction-dg.cc)
+# target_link_dune_default_libraries("advection-reaction-dg")
+#
+# add_executable("interpolation" interpolation.cc)
+# target_link_dune_default_libraries("interpolation")
+#
+# add_executable("poisson-pq2" poisson-pq2.cc)
+# target_link_dune_default_libraries("poisson-pq2")
+#
+# add_executable("stokes-taylorhood" stokes-taylorhood.cc)
+# target_link_dune_default_libraries("stokes-taylorhood")
+#
+# add_executable("poisson-mfem" poisson-mfem.cc)
+# target_link_dune_default_libraries("poisson-mfem")
diff --git a/dune/functions/functionspacebases/flatmultiindex.hh b/dune/functions/functionspacebases/flatmultiindex.hh
index 20f597c..0617eb5 100644
--- a/dune/functions/functionspacebases/flatmultiindex.hh
+++ b/dune/functions/functionspacebases/flatmultiindex.hh
@@ -55,6 +55,7 @@ public:
return std::hash<size_type>()(arg);
}
+ static constexpr std::size_t max_size () { return 1; }
};
diff --git a/dune/functions/functionspacebases/test/gridviewfunctionspacebasistest.cc b/dune/functions/functionspacebases/test/gridviewfunctionspacebasistest.cc
index a16e61f..e8085d8 100644
--- a/dune/functions/functionspacebases/test/gridviewfunctionspacebasistest.cc
+++ b/dune/functions/functionspacebases/test/gridviewfunctionspacebasistest.cc
@@ -401,8 +401,8 @@ int main (int argc, char* argv[]) try
testOnStructuredGrid<2>();
testOnStructuredGrid<3>();
- testOnHybridGrid<2>();
- testOnHybridGrid<3>();
+ //testOnHybridGrid<2>();
+ //testOnHybridGrid<3>();
return 0;
diff --git a/dune/functions/common/indexaccess.hh b/dune/functions/common/indexaccess.hh
index b2a6698..c17b2bb 100644
--- a/dune/functions/common/indexaccess.hh
+++ b/dune/functions/common/indexaccess.hh
@@ -265,41 +265,73 @@ Result hybridMultiIndexAccess(C&& c, const MultiIndex& index)
namespace Imp {
-
+ // forward declaration
template<class C, class MultiIndex, class IsFinal>
- constexpr decltype(auto) resolveDynamicMultiIndex(C&& c, const MultiIndex& multiIndex, const IsFinal& isFinal)
+ constexpr decltype(auto) resolveDynamicMultiIndex(C&& c, const MultiIndex& multiIndex, const IsFinal& isFinal);
+
+ template <bool condition>
+ struct HasDynamicAccess
+ {
+ template <class C, class Index, class MultiIndex, class IsFinal>
+ decltype(auto) operator() (C&& c, const Index& i, const MultiIndex& tail, const IsFinal& isFinal) const
+ {
+ return Imp::resolveDynamicMultiIndex(c[i], tail, isFinal);
+ }
+ };
+
+ template <>
+ struct HasDynamicAccess<false>
{
- // If c is already considered final simply return it,
- // else resolve the next multiIndex entry.
- return Hybrid::ifElse(isFinal(c), [&](auto id) -> decltype(auto) {
+ template <class C, class Index, class MultiIndex, class IsFinal>
+ decltype(auto) operator() (C&& c, const Index& i, const MultiIndex& tail, const IsFinal& isFinal) const
+ {
+ auto indexRange = typename decltype(Dune::range(Hybrid::size(c)))::integer_sequence();
+ return Hybrid::switchCases(indexRange, i, [&](auto static_i) -> decltype(auto) {
+ // Do rescursion with static version of i
+ return Imp::resolveDynamicMultiIndex(c[static_i], tail, isFinal);
+ }, [&]() -> decltype(auto) {
+ // As fallback we use c[0] this is needed, because there must be one branch that matches.
+ return Imp::resolveDynamicMultiIndex(c[Dune::Indices::_0], tail, isFinal);
+ });
+ }
+ };
+
+ template <bool condition>
+ struct IfContainerIsFinal
+ {
+ template <class C, class MultiIndex, class IsFinal>
+ decltype(auto) operator() (C&& c, const MultiIndex& multiIndex, const IsFinal& /*isFinal*/) const
+ {
assert(multiIndex.size() == 0);
return std::forward<C>(c);
- }, [&](auto id) -> decltype(auto) {
+ }
+ };
+
+ template <>
+ struct IfContainerIsFinal<false>
+ {
+ template <class C, class MultiIndex, class IsFinal>
+ decltype(auto) operator() (C&& c, const MultiIndex& multiIndex, const IsFinal& isFinal) const
+ {
auto hasDynamicAccess = callableCheck([](auto&& cc) -> void_t<decltype(cc[0])> {});
// Split multiIndex into first entry and remaining ones.
auto i = multiIndex[0];
auto tail = multiIndex.pop();
- // Resolve first multiIndex entry by c[multiIndex[0]] and
- // continue resolving with the remaining remaining ones.
- // If c has a dynamic operator[] this is straight forward.
- // Else the dynamic multiIndex[0] has to be translated into
- // a static one using hybridIndexAccess.
- return Hybrid::ifElse(hasDynamicAccess(c), [&](auto id) -> decltype(auto) {
- return Imp::resolveDynamicMultiIndex(id(c)[i], tail, isFinal);
- }, [&](auto id) -> decltype(auto) {
- // auto indexRange = range(Hybrid::size(id(c)));
- auto indexRange = typename decltype(range(Hybrid::size(id(c))))::integer_sequence();
- return Hybrid::switchCases(indexRange, i, [&](auto static_i) -> decltype(auto){
- // Do rescursion with static version of i
- return Imp::resolveDynamicMultiIndex(id(c)[static_i], tail, isFinal);
- }, [&]() -> decltype(auto){
- // As fallback we use c[0] this is needed, because there must be one branch that matches.
- return Imp::resolveDynamicMultiIndex(id(c)[Dune::Indices::_0], tail, isFinal);
- });
- });
- });
+ const auto b = hasDynamicAccess(c);
+ return HasDynamicAccess<decltype(b)::value>{}(std::forward<C>(c),i,tail,isFinal);
+ }
+ };
+
+
+
+
+ template<class C, class MultiIndex, class IsFinal>
+ constexpr decltype(auto) resolveDynamicMultiIndex(C&& c, const MultiIndex& multiIndex, const IsFinal& isFinal)
+ {
+ const auto b = isFinal(c);
+ return IfContainerIsFinal<decltype(b)::value>{}(std::forward<C>(c), multiIndex, isFinal);
}
template<class C, class MultiIndex>
diff --git a/dune/functions/functionspacebases/nodes.hh b/dune/functions/functionspacebases/nodes.hh
index 565c183..335f5a0 100644
--- a/dune/functions/functionspacebases/nodes.hh
+++ b/dune/functions/functionspacebases/nodes.hh
@@ -11,7 +11,7 @@ namespace Dune {
namespace Functions {
- namespace {
+ namespace Impl {
template<typename size_type>
@@ -105,7 +105,7 @@ namespace Dune {
size_type treeIndex_;
};
- }
+ } // end namespace Impl
template<typename TP>
@@ -113,13 +113,13 @@ namespace Dune {
{
template<typename>
- friend struct ClearSizeVisitor;
+ friend struct Impl::ClearSizeVisitor;
template<typename,typename>
- friend struct BindVisitor;
+ friend struct Impl::BindVisitor;
template<typename>
- friend struct InitializeTreeVisitor;