subspace.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_PDELAB_GRIDFUNCTIONSPACE_SUBSPACE_HH
#define DUNE_PDELAB_GRIDFUNCTIONSPACE_SUBSPACE_HH
 
#include <dune/common/shared_ptr.hh>
#include <dune/pdelab/gridfunctionspace/gridfunctionspace.hh>
#include <dune/pdelab/gridfunctionspace/powergridfunctionspace.hh>
#include <dune/pdelab/gridfunctionspace/compositegridfunctionspace.hh>
#include <dune/pdelab/gridfunctionspace/subspacelocalfunctionspace.hh>
#include <dune/pdelab/ordering/subordering.hh>
 
namespace Dune {
  namespace PDELab {
 
    namespace gfs {
 
      // forward declaration for use in build_dof_index_type specialization and
      // in feature mixins.
      template<typename GFS, typename TreePath>
      class GridFunctionSubSpace;
 
    } // namespace gfs
 
#ifndef DOXYGEN
 
    // Specialization of DOFIndex type deduction TMP - the DOFIndex
    // of a subspace must be large enough to contain DOFIndex values
    // for the complete tree rooted in the base space.
    template<typename GFS, typename TP>
    struct build_dof_index_type<gfs::GridFunctionSubSpace<GFS,TP> >
    {
      typedef typename GFS::Ordering::Traits::DOFIndex type;
    };
 
#endif // DOXYGEN
 
 
 
    namespace gfs {
 
      namespace {
 
 
 
        // ********************************************************************************
        // Helper TMPs
        // ********************************************************************************
 
 
        template<typename Ordering, typename GFS, typename GFSTP, typename OrderingTP = TypeTree::StaticTreePath<> >
        struct find_ordering_treepath_for_sub_gfs
        {
 
          // Get the ordering at the current subtree position.
          using SubOrdering = TypeTree::ChildForTreePath<Ordering,OrderingTP>;
 
          // Only descend in the GFS tree if the current ordering child consumes a tree index entry.
          typedef typename std::conditional<
            SubOrdering::consume_tree_index,
            typename GFS::template Child<TypeTree::TreePathFront<GFSTP>::value>::type,
            GFS
            >::type SubGFS;
 
          // Insert either GFS child index or synthesized child index (always 0) in the ordering treepath.
          typedef typename TypeTree::TreePathPushBack<
            OrderingTP,
            (SubOrdering::consume_tree_index ? TypeTree::TreePathFront<GFSTP>::value : 0)
            >::type SubOrderingTP;
 
          // Keep (synthesized ordering node) or drop (ordering with associated GFS) first entry of GFS TreePath.
          typedef typename std::conditional<
            SubOrdering::consume_tree_index,
            typename TypeTree::TreePathPopFront<GFSTP>::type,
            GFSTP
            >::type SubGFSTP;
 
          // Recurse into child trees.
          typedef typename find_ordering_treepath_for_sub_gfs<
            Ordering,
            SubGFS,
            SubGFSTP,
            SubOrderingTP
            >::type type;
 
        };
 
        template<typename Ordering, typename GFS, typename OrderingTP>
        struct find_ordering_treepath_for_sub_gfs<Ordering,GFS,TypeTree::StaticTreePath<>,OrderingTP>
        {
 
          // We have found the correct ordering TreePath, so let's return it.
          typedef OrderingTP type;
 
        };
 
      } // anonymous namespace
 
 
 
 
      // *****************************************************************************************
      // Feature provider mixins
      // *****************************************************************************************
 
      template<typename GFS, typename TreePath, typename Tag>
      class DefaultSubSpaceFeatures
      {
 
        typedef GridFunctionSubSpace<GFS,TreePath> SubSpace;
 
        const SubSpace& subSpace() const
        {
          return static_cast<const SubSpace&>(*this);
        }
 
      public:
 
 
        typedef TreePath SubSpacePath;
 
        typedef GFS BaseGridFunctionSpace;
 
        using ChildGridFunctionSpace = TypeTree::ChildForTreePath<GFS,TreePath>;
 
        typedef typename ChildGridFunctionSpace::Traits Traits;
 
        typedef typename ChildGridFunctionSpace::OrderingTag OrderingTag;
 
 
        template<typename E>
        using Constraintscontainer = typename GFS::template ConstraintsContainer<E>;
 
        typedef SubOrdering<
          typename GFS::Ordering,
          typename find_ordering_treepath_for_sub_gfs<
            typename GFS::Ordering,
            GFS,
            TreePath
            >::type
          > Ordering;
 
        std::size_t subSpaceDepth() const
        {
          return TypeTree::TreePathSize<SubSpacePath>::value;
        }
 
        const Ordering& ordering() const
        {
          return _ordering;
        }
 
        const typename Traits::EntitySet& entitySet() const
        {
          return subSpace().childGridFunctionSpace().entitySet();
        }
 
        const typename Traits::GridViewType& gridView() const
        {
          return subSpace().childGridFunctionSpace().gridView();
        }
 
        typename Traits::SizeType globalSize() const
        {
          return _ordering.size();
        }
 
 
        typename Traits::SizeType size() const
        {
          return _ordering.size();
        }
 
        typename Traits::SizeType maxLocalSize() const
        {
          return _ordering.maxLocalSize();
        }
 
 
      protected:
 
        DefaultSubSpaceFeatures(const GFS& gfs)
          : _ordering(gfs.orderingStorage())
        {}
 
      private:
 
        Ordering _ordering;
 
      };
 
 
      template<typename GFS, typename TreePath, typename Tag>
      class LeafSubSpaceFeatures
      {
 
        typedef GridFunctionSubSpace<GFS,TreePath> SubSpace;
 
        const SubSpace& subSpace() const
        {
          return static_cast<const SubSpace&>(*this);
        }
 
      public:
 
        using ChildGridFunctionSpace = TypeTree::ChildForTreePath<GFS,TreePath>;
 
        typedef typename ChildGridFunctionSpace::Traits Traits;
 
 
        const typename Traits::FiniteElementMap& finiteElementMap() const
        {
          return subSpace().childGridFunctionSpace().finiteElementMap();
        }
 
        std::shared_ptr<const typename Traits::FiniteElementMap> finiteElementMapStorage () const
        {
          return subSpace().childGridFunctionSpace().finiteElementMapStorage();
        }
 
        const typename Traits::ConstraintsType& constraints() const
        {
          return subSpace().childGridFunctionSpace().constraints();
        }
 
        const std::string& name() const
        {
          return subSpace().childGridFunctionSpace().name();
        }
 
      };
 
 
#ifdef DOXYGEN
 
 
      template<typename GFS, typename TreePath, typename Tag>
      class SubSpaceFeatureProvider
        : public DefaultSubSpaceFeatures<GFS,TreePath,Tag>
        , public LeafSubSpaceFeatures<GFS,TreePath,Tag>
      {
 
      protected:
 
        SubSpaceFeatureProvider(const GFS& gfs)
          : DefaultSubSpaceFeatures<GFS,TreePath,Tag>(gfs)
        {}
 
      };
 
#else // DOXYGEN
 
      template<typename GFS, typename TreePath, typename Tag>
      class SubSpaceFeatureProvider
        : public DefaultSubSpaceFeatures<GFS,TreePath,Tag>
      {
 
      protected:
 
        SubSpaceFeatureProvider(const GFS& gfs)
          : DefaultSubSpaceFeatures<GFS,TreePath,Tag>(gfs)
        {}
 
      };
 
      template<typename GFS, typename TreePath>
      class SubSpaceFeatureProvider<GFS,TreePath,LeafGridFunctionSpaceTag>
        : public DefaultSubSpaceFeatures<GFS,TreePath,LeafGridFunctionSpaceTag>
        , public LeafSubSpaceFeatures<GFS,TreePath,LeafGridFunctionSpaceTag>
      {
 
      protected:
 
        SubSpaceFeatureProvider(const GFS& gfs)
          : DefaultSubSpaceFeatures<GFS,TreePath,LeafGridFunctionSpaceTag>(gfs)
        {}
 
      };
 
#endif // DOXYGEN
 
      template<class T, bool Enable = std::is_base_of<GridFunctionOutputParameters, T>::value>
      class GridFunctionSubSpaceOutputParameters
      {
      public:
        void inheritDataSetType(const T & t) {}
      };
 
#ifndef DOXYGEN
      template<class T>
      class GridFunctionSubSpaceOutputParameters<T,true> :
        public GridFunctionOutputParameters
      {
      public:
        void inheritDataSetType(const T & t)
        {
          setDataSetType(t.dataSetType());
        }
      };
#endif
 
      // ********************************************************************************
      // GridFunctionSubSpace implementation
      // ********************************************************************************
 
 
      template<typename GFS, typename TreePath>
      class GridFunctionSubSpace
        : public TypeTree::ProxyNode<const TypeTree::ChildForTreePath<GFS,TreePath>>
        , public SubSpaceFeatureProvider<GFS,TreePath,TypeTree::ImplementationTag<TypeTree::ChildForTreePath<GFS,TreePath>>>
        , public GridFunctionSubSpaceOutputParameters<TypeTree::ChildForTreePath<GFS,TreePath>>
      {
 
        using NodeT = TypeTree::ProxyNode<const TypeTree::ChildForTreePath<GFS,TreePath>>;
 
        using FeatureT = SubSpaceFeatureProvider<
          GFS,
          TreePath,
          TypeTree::ImplementationTag<TypeTree::ChildForTreePath<GFS,TreePath>>
          >;
 
      public:
 
        explicit GridFunctionSubSpace(std::shared_ptr<const GFS> gfs_storage)
          : NodeT(TypeTree::childStorage(*gfs_storage,TreePath()))
          , FeatureT(*gfs_storage)
          , _base_gfs(gfs_storage)
        {
          this->inheritDataSetType(childGridFunctionSpace());
        }
 
        // We can mask out the following constructors if we don't have template aliases,
        // as we perform the necessary reference <-> shared_ptr conversions in the derived
        // interface class.
 
        explicit GridFunctionSubSpace(const GFS& gfs)
          : NodeT(TypeTree::childStorage(gfs,TreePath()))
          , FeatureT(gfs)
          , _base_gfs(stackobject_to_shared_ptr(gfs))
        {
          this->inheritDataSetType(childGridFunctionSpace());
        }
 
 
        template<typename TP>
        explicit GridFunctionSubSpace(std::shared_ptr<const GridFunctionSubSpace<GFS,TP> > gfs_storage, typename std::enable_if<!std::is_same<TP,TreePath>::value,void*>::type = nullptr)
          : NodeT(TypeTree::childStorage(gfs_storage->baseGridFunctionSpace(),TreePath()))
          , FeatureT(gfs_storage->baseGridFunctionSpace())
          , _base_gfs(gfs_storage->baseGridFunctionSpaceStorage())
        {
          setDataSetType(childGridFunctionSpace().dataSetType());
        }
 
 
        template<typename TP>
        explicit GridFunctionSubSpace(const GridFunctionSubSpace<GFS,TP>& gfs, typename std::enable_if<!std::is_same<TP,TreePath>::value,void*>::type = nullptr)
          : NodeT(TypeTree::childStorage(gfs.baseGridFunctionSpace(),TreePath()))
          , FeatureT(gfs.baseGridFunctionSpace())
          , _base_gfs(gfs.baseGridFunctionSpaceStorage())
        {
          this->inheritDataSetType(childGridFunctionSpace());
        }
 
      public:
 
        typedef GFS BaseGridFunctionSpace;
 
        using ChildGridFunctionSpace = TypeTree::ChildForTreePath<GFS,TreePath>;
 
        typedef typename ChildGridFunctionSpace::Traits Traits;
 
        typedef GridFunctionSubSpaceTag<
          TypeTree::ImplementationTag<ChildGridFunctionSpace>
          > ImplementationTag;
 
        const BaseGridFunctionSpace& baseGridFunctionSpace() const
        {
          return *_base_gfs;
        }
 
        std::shared_ptr<const BaseGridFunctionSpace> baseGridFunctionSpaceStorage() const
        {
          return _base_gfs;
        }
 
 
        const ChildGridFunctionSpace& childGridFunctionSpace() const
        {
          return this->proxiedNode();
        }
 
 
        std::shared_ptr<const ChildGridFunctionSpace> childGridFunctionSpaceStorage() const
        {
          return this->proxiedNodeStorage();
        }
 
        std::string name() const
        {
          return childGridFunctionSpace().name();
        }
 
        void name(const std::string& name)
        {
          childGridFunctionSpace().name(name);
        }
 
      private:
 
        std::shared_ptr<const GFS> _base_gfs;
 
      };
 
#ifndef DOXYGEN
 
 
      template<typename GFS, typename TreePath>
      struct construct_sub_space
      {
        typedef GridFunctionSubSpace<
          GFS,
          TreePath
          > type;
      };
 
      template<typename BaseGFS, typename SubGFSTreePath, typename TreePath>
      struct construct_sub_space<Dune::PDELab::gfs::GridFunctionSubSpace<
                                   BaseGFS,
                                   SubGFSTreePath
                                   >,
                                 TreePath
                                 >
      {
        typedef GridFunctionSubSpace<
          BaseGFS,
          typename TypeTree::TreePathConcat<
            SubGFSTreePath,
            TreePath
            >::type
          > type;
      };
 
#endif // DOXYGEN
 
    } // namespace gfs
 
 
#if DOXYGEN
 
    template<typename GFS, typename TreePath>
    using GridFunctionSubSpace = gfs::GridFunctionSubSpace<GFS,TreePath>;
 
#else // DOXYGEN
 
    template<typename GFS, typename TreePath>
    using GridFunctionSubSpace = typename gfs::construct_sub_space<GFS,TreePath>::type;
 
#endif // DOXYGEN
 
 
  } // namespace PDELab
} // namespace Dune
 
#endif // DUNE_PDELAB_GRIDFUNCTIONSPACE_SUBSPACE_HH