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 {
 
        template<typename Ordering, typename GFS, typename GFSTP, typename OrderingTP>
        constexpr auto create_ordering_treepath_for_sub_gfs(
          const Ordering& ordering, const GFS& gfs, GFSTP gfs_tp, OrderingTP ordering_tp)
        {
          using namespace Dune::TypeTree;
 
          if constexpr (gfs_tp.size() == 0)
          {
            return ordering_tp;
          }
          else
          {
            // Get the ordering at the current subtree position.
            using SubOrdering = TypeTree::ChildForTreePath<Ordering,OrderingTP>;
 
            // 1. Only descend in the GFS tree if the current ordering child consumes a tree index entry.
            // 2. Insert either GFS child index or synthesized child index (always 0) in the ordering treepath.
            // 3. Keep (synthesized ordering node) or drop (ordering with associated GFS) first entry of GFS TreePath.
            if constexpr (SubOrdering::consume_tree_index)
            {
              // we now know that SubGFS = GFS;
              auto subordering_tp = push_back(OrderingTP(), front(GFSTP()));
              auto subgfs_tp = pop_front(GFSTP());
 
              // Recurse into child trees.
              return create_ordering_treepath_for_sub_gfs(
                ordering, gfs, subgfs_tp, subordering_tp);
            }
            else
            {
              // using SubGFS = typename GFS::template Child<TypeTree::front(GFSTP())>::type;
              auto subordering_tp = push_back(OrderingTP(), Indices::_0);
              auto subgfs_tp = gfs_tp;
 
              // Recurse into child trees.
              return create_ordering_treepath_for_sub_gfs(
                ordering, gfs.child(front(gfs_tp)), subgfs_tp, subordering_tp);
            }
          }
        }
 
        // ********************************************************************************
        // Helper TMPs
        // ********************************************************************************
 
 
        template<typename Ordering, typename GFS, typename GFSTP, typename OrderingTP = TypeTree::StaticTreePath<> >
        struct find_ordering_treepath_for_sub_gfs
        {
          using type = decltype(
            create_ordering_treepath_for_sub_gfs(
              std::declval<Ordering>(),
              std::declval<GFS>(),
              GFSTP(),
              OrderingTP())
            );
        };
 
      } // 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 SubSpacePath().size();
        }
 
        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, TreePath tree_path)
          : _ordering(gfs.orderingStorage(), create_ordering_treepath_for_sub_gfs(gfs.ordering(), gfs, tree_path, TypeTree::treePath()))
        {}
 
        DefaultSubSpaceFeatures(const GFS& gfs)
          : DefaultSubSpaceFeatures(gfs, TreePath())
        {}
 
      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, TreePath tree_path)
          : DefaultSubSpaceFeatures<GFS,TreePath,Tag>(gfs, tree_path)
        {}
 
      };
 
#else // DOXYGEN
 
      template<typename GFS, typename TreePath, typename Tag>
      class SubSpaceFeatureProvider
        : public DefaultSubSpaceFeatures<GFS,TreePath,Tag>
      {
 
      protected:
 
        SubSpaceFeatureProvider(const GFS& gfs, TreePath tree_path)
          : DefaultSubSpaceFeatures<GFS,TreePath,Tag>(gfs,tree_path)
        {}
 
      };
 
      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, TreePath tree_path)
          : DefaultSubSpaceFeatures<GFS,TreePath,LeafGridFunctionSpaceTag>(gfs, tree_path)
        {}
 
      };
 
#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, TreePath tree_path)
          : NodeT(TypeTree::childStorage(*gfs_storage,tree_path))
          , FeatureT(*gfs_storage, tree_path)
          , _base_gfs(gfs_storage)
        {
          this->inheritDataSetType(childGridFunctionSpace());
        }
 
        explicit GridFunctionSubSpace(std::shared_ptr<const GFS> gfs_storage)
          : GridFunctionSubSpace(gfs_storage, TreePath())
        {}
 
        // 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, TreePath tree_path)
          : NodeT(TypeTree::childStorage(gfs,tree_path))
          , FeatureT(gfs,tree_path)
          , _base_gfs(stackobject_to_shared_ptr(gfs))
        {
          this->inheritDataSetType(childGridFunctionSpace());
        }
 
        explicit GridFunctionSubSpace(const GFS& gfs)
          : GridFunctionSubSpace(gfs, TreePath())
        {}
 
 
        template<typename TP>
        explicit GridFunctionSubSpace(std::shared_ptr<const GridFunctionSubSpace<GFS,TP> > gfs_storage, TreePath tree_path, typename std::enable_if<!std::is_same<TP,TreePath>::value,void*>::type = nullptr)
          : NodeT(TypeTree::childStorage(gfs_storage->baseGridFunctionSpace(),tree_path))
          , FeatureT(gfs_storage->baseGridFunctionSpace(), tree_path)
          , _base_gfs(gfs_storage->baseGridFunctionSpaceStorage())
        {
          setDataSetType(childGridFunctionSpace().dataSetType());
        }
 
        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)
          : GridFunctionSubSpace(gfs_storage, TreePath())
        {}
 
 
        template<typename TP>
        explicit GridFunctionSubSpace(const GridFunctionSubSpace<GFS,TP>& gfs, TreePath tree_path, typename std::enable_if<!std::is_same<TP,TreePath>::value,void*>::type = nullptr)
          : NodeT(TypeTree::childStorage(gfs.baseGridFunctionSpace(),tree_path))
          , FeatureT(gfs.baseGridFunctionSpace(), tree_path)
          , _base_gfs(gfs.baseGridFunctionSpaceStorage())
        {
          this->inheritDataSetType(childGridFunctionSpace());
        }
 
        template<typename TP>
        explicit GridFunctionSubSpace(const GridFunctionSubSpace<GFS,TP>& gfs, typename std::enable_if<!std::is_same<TP,TreePath>::value,void*>::type = nullptr)
          : GridFunctionSubSpace(gfs, TreePath())
        {}
 
      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
                                 >
      {
        using SubSpaceTreePath = decltype(TypeTree::join(SubGFSTreePath(), TreePath()));
        typedef GridFunctionSubSpace<
          BaseGFS,SubSpaceTreePath> 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