subordering.hh

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
 
#ifndef DUNE_PDELAB_ORDERING_SUBORDERING_HH
#define DUNE_PDELAB_ORDERING_SUBORDERING_HH
 
#include <algorithm>
#include <array>
#include <iterator>
#include <memory>
 
#include <dune/typetree/treepath.hh>
#include <dune/typetree/proxynode.hh>
#include <dune/typetree/childextraction.hh>
 
#include <dune/pdelab/ordering/utility.hh>
 
namespace Dune {
  namespace PDELab {
 
 
 
    template<typename BaseOrdering_, typename TreePath>
    class SubOrdering
      : public TypeTree::ProxyNode<const TypeTree::ChildForTreePath<BaseOrdering_,TreePath>>
    {
 
      using NodeT = TypeTree::ProxyNode<const TypeTree::ChildForTreePath<BaseOrdering_,TreePath>>;
 
    public:
 
      typedef BaseOrdering_ BaseOrdering;
 
      using TargetOrdering = TypeTree::ChildForTreePath<BaseOrdering,TreePath>;
 
      typedef typename BaseOrdering::Traits Traits;
 
      typedef typename BaseOrdering::ContainerAllocationTag ContainerAllocationTag;
 
      typedef typename BaseOrdering::CacheTag CacheTag;
 
      static const bool has_dynamic_ordering_children = TargetOrdering::has_dynamic_ordering_children;
 
      static const bool consume_tree_index = TargetOrdering::consume_tree_index;
 
 
 
      explicit SubOrdering(std::shared_ptr<const BaseOrdering> base_ordering, TreePath tree_path)
        : NodeT(base_ordering->child(tree_path))
        , _base_ordering(base_ordering)
      {
        update();
      }
 
      explicit SubOrdering(std::shared_ptr<const BaseOrdering> base_ordering)
        : SubOrdering(base_ordering, TreePath())
      {}
 
      void update()
      {}
 
 
      template<typename ItIn, typename ItOut>
      void map_lfs_indices(ItIn begin, const ItIn end, ItOut out) const
      {
        // Do the mapping up to the root ordering.
        // Avoid spelling out the type of ItIn here (it has to be a DOFIndexViewIterator),
        // so we don't need to include lfsindexcache.hh.
        map_lfs_indices_to_root_space(TreePath(),
                                      begin,
                                      end,
                                      out);
      }
 
 
    private:
 
 
      template<typename TP, typename ItIn, typename ItOut>
      void map_lfs_indices_in_ancestor(TP tp, ItIn& begin, ItIn& end, ItOut out) const
      {
        using Ordering = TypeTree::ChildForTreePath<BaseOrdering,TP>;
 
        // This logic needs to be replicated from the IndexCache visitor, as we bypass
        // the tree-visiting algorithm and work our way up the tree all by ourselves.
        // Don't consume the first entry in the tree path to the parent before it has
        // been used!
        if (!std::is_same<TreePath,TP>::value && Ordering::consume_tree_index)
          {
            begin.restore_back();
            end.restore_back();
          }
 
        // Call the single-level mapping step of our ancestor ordering.
        TypeTree::child(baseOrdering(),tp).map_lfs_indices(begin,end,out);
      }
 
      // Template recursion for walking up the TreePath to the BaseOrdering
      template<typename TP, typename ItIn, typename ItOut>
      void map_lfs_indices_to_root_space(TP tp, ItIn begin, ItIn end, ItOut out) const
      {
        if constexpr (tp.size() == 0)
        {
          // End of template recursion for walking up the TreePath to the BaseOrdering
          map_lfs_indices_in_ancestor(tp,begin,end,out);
        }
        else
        {
          map_lfs_indices_in_ancestor(tp,begin,end,out);
          // recurse further up to the tree
          map_lfs_indices_to_root_space(pop_back(tp),begin,end,out);
        }
      }
 
    public:
 
      typename Traits::ContainerIndex mapIndex(const typename Traits::DOFIndex& di) const
      {
        typename Traits::ContainerIndex ci;
        mapIndex(di,ci);
        return ci;
      }
 
      void mapIndex(typename Traits::DOFIndexView di, typename Traits::ContainerIndex& ci) const
      {
        baseOrdering().mapIndex(di,ci);
      }
 
      typename Traits::SizeType size() const
      {
        return baseOrdering().size();
      }
 
      typename Traits::SizeType size(const typename Traits::ContainerIndex& suffix) const
      {
        return baseOrdering().size(suffix);
      }
 
      typename Traits::SizeType blockCount() const
      {
        return baseOrdering().blockCount();
      }
 
      typename Traits::SizeType maxLocalSize() const
      {
        return targetOrdering().maxLocalSize();
      }
 
      bool contains(typename Traits::SizeType codim) const
      {
        return targetOrdering().contains(codim);
      }
 
      bool fixedSize(typename Traits::SizeType codim) const
      {
        return targetOrdering().fixedSize(codim);
      }
 
      const BaseOrdering& baseOrdering() const
      {
        return *_base_ordering;
      }
 
      const TargetOrdering& targetOrdering() const
      {
        return this->proxiedNode();
      }
 
    private:
 
      std::shared_ptr<const BaseOrdering> _base_ordering;
 
    };
 
 
  } // namespace PDELab
} // namespace Dune
 
#endif // DUNE_PDELAB_ORDERING_SUBORDERING_HH