tags.hh

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
 
#ifndef DUNE_PDELAB_GRIDFUNCTIONSPACE_TAGS_HH
#define DUNE_PDELAB_GRIDFUNCTIONSPACE_TAGS_HH
 
#include <dune/grid/common/gridenums.hh>
#include <dune/typetree/utility.hh>
 
#include <dune/pdelab/common/dofindex.hh>
#include <dune/pdelab/common/simpledofindex.hh>
 
#include <numeric>
 
namespace Dune {
  namespace PDELab {
 
 
    struct FunctionSpaceTag {};
 
    struct GridFunctionSpaceTag : public FunctionSpaceTag {};
 
    struct PowerGridFunctionSpaceTag : public GridFunctionSpaceTag {};
 
    struct VectorGridFunctionSpaceTag : public PowerGridFunctionSpaceTag {};
 
    struct CompositeGridFunctionSpaceTag : public GridFunctionSpaceTag {};
 
    struct LeafGridFunctionSpaceTag : public GridFunctionSpaceTag {};
 
    template<typename ProxiedGFSTag>
    struct GridFunctionSubSpaceTag
      : public ProxiedGFSTag
    {};
 
    struct CompositeGridFunctionSpaceBaseTag {};
 
 
    struct EntityBlockedOrderingTag {};
 
 
    struct LexicographicOrderingTag { };
 
 
    struct InterleavedOrderingTag
    {
 
 
      InterleavedOrderingTag(std::initializer_list<std::size_t> sizes)
        : _offsets(sizes.size() + 1,0)
      {
        std::partial_sum(sizes.begin(),sizes.end(),_offsets.begin() + 1);
      }
 
      InterleavedOrderingTag(std::vector<std::size_t> sizes)
        : _offsets(sizes.size() + 1,0)
      {
        std::partial_sum(sizes.begin(),sizes.end(),_offsets.begin() + 1);
      }
 
      const std::vector<std::size_t>& offsets() const
      {
        return _offsets;
      }
 
    private:
 
      std::vector<std::size_t> _offsets;
    };
 
    template<bool v>
    struct NoConstOrderingSize
    {
      static const bool no_const_ordering_size = v;
    };
 
    namespace {
 
      // Use this compile-time bridge to shup up GCC warnings
 
      template<int i>
      struct shift_if_nonnegative
      {
        static const unsigned int value = 1 << i;
      };
 
      template<>
      struct shift_if_nonnegative<-1>
      {
        static const unsigned int value = 0;
      };
 
    }
 
 
    template<int p0 = -1, int p1 = -1, int p2 = -1, int p3 = -1, int p4 = -1>
    struct PartitionSelector
    {
 
      static const unsigned int partition_mask =
        shift_if_nonnegative<p0>::value |
        shift_if_nonnegative<p1>::value |
        shift_if_nonnegative<p2>::value |
        shift_if_nonnegative<p3>::value |
        shift_if_nonnegative<p4>::value;
 
    };
 
    struct EmptyParams
    {};
 
 
    template<typename Params>
    struct LeafOrderingTag
      : public Params
    {};
 
    using DefaultLeafOrderingTag = LeafOrderingTag<EmptyParams>;
 
    struct SingleCodimMapper {};
 
    struct PowerLocalFunctionSpaceTag {};
 
    struct CompositeLocalFunctionSpaceTag {};
 
    struct LeafLocalFunctionSpaceTag {};
 
    struct HierarchicContainerAllocationTag {};
 
    struct FlatContainerAllocationTag {};
 
    struct DefaultLFSCacheTag {};
 
    struct SimpleLFSCacheTag {};
 
    namespace Experimental {
 
      struct DuneFunctionsCacheTag {};
 
    }
 
    template<typename GFS, typename Tag>
    struct _build_dof_index_type
    {
      typedef Dune::PDELab::DOFIndex<std::size_t,TypeTree::TreeInfo<GFS>::depth,2> type;
    };
 
    template<typename GFS>
    struct _build_dof_index_type<GFS,SingleCodimMapper>
    {
      typedef SimpleDOFIndex<typename GFS::Traits::SizeType> type;
    };
 
 
    template<typename GFS>
    struct build_dof_index_type
    {
      typedef typename _build_dof_index_type<GFS,typename GFS::OrderingTag>::type type;
    };
 
 
#ifndef DOXYGEN
 
 
    template<typename GFS>
    struct gfs_to_lfs {
 
      //typedef Dune::PDELab::MultiIndex<std::size_t,TypeTree::TreeInfo<GFS>::depth> MultiIndex;
      typedef typename build_dof_index_type<GFS>::type DOFIndex;
 
    };
 
#endif // DOXYGEN
 
  } // namespace PDELab
} // namespace Dune
 
#endif // DUNE_PDELAB_GRIDFUNCTIONSPACE_TAGS_HH