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/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::TreePath<> >
        struct find_ordering_treepath_for_sub_gfs
        {

          // Get the ordering at the current subtree position.
          typedef typename TypeTree::extract_child_type<Ordering,OrderingTP>::type SubOrdering;

          // Only descend in the GFS tree if the current ordering child consumes a tree index entry.
          typedef typename 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 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::TreePath<>,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;

        typedef typename TypeTree::extract_child_type<GFS,TreePath>::type ChildGridFunctionSpace;

        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::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:

        typedef typename TypeTree::extract_child_type<GFS,TreePath>::type ChildGridFunctionSpace;

        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 typename TypeTree::extract_child_type<GFS,TreePath>::type>
        , public SubSpaceFeatureProvider<GFS,TreePath,typename TypeTree::extract_child_type<
                                                        GFS,
                                                        TreePath
                                                        >::type::ImplementationTag
                                         >
        , public GridFunctionSubSpaceOutputParameters<typename TypeTree::extract_child_type<GFS,TreePath>::type>
      {

        typedef TypeTree::ProxyNode<
          const typename TypeTree::extract_child_type<
            GFS,
            TreePath
            >::type
          > NodeT;

        typedef SubSpaceFeatureProvider<
          GFS,
          TreePath,
          typename TypeTree::extract_child_type<
            GFS,
            TreePath
            >::type::ImplementationTag
          > FeatureT;

      public:

        explicit GridFunctionSubSpace(std::shared_ptr<const GFS> gfs_storage)
          : NodeT(TypeTree::extract_child_storage(*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::extract_child_storage(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 enable_if<!is_same<TP,TreePath>::value,void*>::type = nullptr)
          : NodeT(TypeTree::extract_child_storage(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 enable_if<!is_same<TP,TreePath>::value,void*>::type = nullptr)
          : NodeT(TypeTree::extract_child_storage(gfs.baseGridFunctionSpace(),TreePath()))
          , FeatureT(gfs.baseGridFunctionSpace())
          , _base_gfs(gfs.baseGridFunctionSpaceStorage())
        {
          this->inheritDataSetType(childGridFunctionSpace());
        }

      public:

        typedef GFS BaseGridFunctionSpace;

        typedef typename TypeTree::extract_child_type<GFS,TreePath>::type ChildGridFunctionSpace;

        typedef typename ChildGridFunctionSpace::Traits Traits;

        typedef GridFunctionSubSpaceTag<
          typename ChildGridFunctionSpace::ImplementationTag
          > 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