powercompositegridfunctionspacebase.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_PDELAB_GRIDFUNCTIONSPACE_POWERCOMPOSITEGRIDFUNCTIONSPACEBASE_HH
#define DUNE_PDELAB_GRIDFUNCTIONSPACE_POWERCOMPOSITEGRIDFUNCTIONSPACEBASE_HH
 
#include <algorithm>
#include <cstddef>
#include <functional>
#include <vector>
 
#include <dune/typetree/fixedcapacitystack.hh>
#include <dune/typetree/traversal.hh>
#include <dune/typetree/traversalutilities.hh>
#include <dune/typetree/utility.hh>
#include <dune/typetree/transformation.hh>
#include <dune/typetree/visitor.hh>
 
#include <dune/pdelab/constraints/common/constraintstransformation.hh>
#include <dune/pdelab/constraints/noconstraints.hh>
#include <dune/pdelab/gridfunctionspace/tags.hh>
#include <dune/pdelab/gridfunctionspace/gridfunctionspacebase.hh>
#include <dune/pdelab/ordering/lexicographicordering.hh>
#include <dune/pdelab/ordering/entityblockedlocalordering.hh>
 
namespace Dune {
  namespace PDELab {
 
 
    template<typename G, typename B, typename O, std::size_t k>
    struct PowerCompositeGridFunctionSpaceTraits
    {
      enum{
        isComposite = 1,
        noChilds = k
      };
 
      const static std::size_t CHILDREN = k;
 
      using EntitySet = G;
 
      using GridView = typename EntitySet::GridView;
 
      using GridViewType = GridView;
 
      typedef B BackendType;
 
      typedef B Backend;
 
      typedef O MapperType;
 
      typedef O OrderingTag;
 
      typedef typename B::size_type SizeType;
    };
 
    template<typename GridFunctionSpace, typename GV, typename B, typename O, std::size_t k>
    class PowerCompositeGridFunctionSpaceBase
      : public GridFunctionSpaceBase<
                 GridFunctionSpace,
                 PowerCompositeGridFunctionSpaceTraits<GV,B,O,k>
                 >
    {
 
#ifndef DOXYGEN
 
      const GridFunctionSpace& gfs() const
      {
        return static_cast<const GridFunctionSpace&>(*this);
      }
 
      GridFunctionSpace& gfs()
      {
        return static_cast<GridFunctionSpace&>(*this);
      }
 
#endif // DOXYGEN
 
    public:
 
      typedef PowerCompositeGridFunctionSpaceTraits<GV,B,O,k> Traits;
 
    private:
 
      typedef GridFunctionSpaceBase<GridFunctionSpace,Traits> BaseT;
 
    public:
 
      typedef O OrderingTag;
 
      const typename Traits::EntitySet& entitySet () const
      {
        if (not this->_entity_set)
          return BaseT::_entity_set.emplace(gfs().template child<0>().entitySet());
        return BaseT::entitySet();
      }
 
      typename Traits::EntitySet& entitySet ()
      {
        if (not this->_entity_set)
          return BaseT::_entity_set.emplace(gfs().template child<0>().entitySet());
        return BaseT::entitySet();
      }
 
      PowerCompositeGridFunctionSpaceBase(const B& backend, const OrderingTag& ordering_tag)
        : BaseT(backend,ordering_tag)
      {}
 
    };
 
  }
 
}
#endif // DUNE_PDELAB_GRIDFUNCTIONSPACE_POWERCOMPOSITEGRIDFUNCTIONSPACEBASE_HH