restrictedbasis.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:
 
// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef DUNE_FUNCTIONS_FUNCTIONSPACEBASES_RESTRICTEDBASIS_HH
#define DUNE_FUNCTIONS_FUNCTIONSPACEBASES_RESTRICTEDBASIS_HH
 
#include <cstddef>
#include <utility>
 
#include <dune/common/typetree/traversal.hh>
 
#include <dune/functions/functionspacebases/nodes.hh>
 
 
namespace Dune::Functions::Experimental {
 
 
 
template<class GV, class SDPB, class SD>
class RestrictedPreBasis
{
  using This = RestrictedPreBasis<GV, SDPB, SD>;
 
public:
 
  using SubDomain = SD;
  using SubDomainPreBasis = SDPB;
  using SubDomainGridView = typename SubDomainPreBasis::GridView;
 
  using GridView = GV;
 
  using size_type = std::size_t;
 
  class Node
    : public SubDomainPreBasis::Node
  {
    using Base = typename SubDomainPreBasis::Node;
  public:
 
    using Element = typename Base::Element;
 
    Node(Base&& base, const SubDomainGridView& subDomainGridView, const SubDomain& subDomain)
      : Base(base)
      , subDomainGridView_(subDomainGridView)
      , subDomain_(subDomain)
    {}
 
    void bind(const Element& element)
    {
      if (subDomainGridView_.contains(element))
        Base::bind(element);
      else
      {
        Dune::TypeTree::forEachNode(static_cast<Base&>(*this) , [&](auto& node, const auto& treePath) {
          Dune::Functions::Impl::BasisNodeSetupHelper::setOffset(node, this->offset());
          Dune::Functions::Impl::BasisNodeSetupHelper::setSize(node, 0);
        });
      }
    }
 
    const SubDomain& subDomain() const
    {
      return subDomain_;
    }
 
  private:
    const SubDomainGridView& subDomainGridView_;
    const SubDomain& subDomain_;
  };
 
  static constexpr size_type maxMultiIndexSize = SubDomainPreBasis::maxMultiIndexSize;
  static constexpr size_type minMultiIndexSize = SubDomainPreBasis::minMultiIndexSize;
  static constexpr size_type multiIndexBufferSize = SubDomainPreBasis::multiIndexBufferSize;
 
  RestrictedPreBasis(const GridView& gridView, SubDomainPreBasis&& subDomainPreBasis, const SubDomain& subDomain)
    : gridView_(gridView)
    , subDomainPreBasis_(std::move(subDomainPreBasis))
    , subDomainPtr_(&subDomain)
  {}
 
  void initializeIndices()
  {
    subDomainPreBasis_.initializeIndices();
  }
 
  const GridView& gridView() const
  {
    return gridView_;
  }
 
  void update(const GridView& gv)
  {
    gridView_ = gv;
    subDomainPreBasis_.update(subDomainPtr_->gridView());
  }
 
  Node makeNode() const
  {
    return Node(subDomainPreBasis_.makeNode(), subDomainPreBasis_.gridView(), *subDomainPtr_);
  }
 
  size_type size() const
  {
    return subDomainPreBasis_.size();
  }
 
  template<class SizePrefix>
  size_type size(const SizePrefix& prefix) const
  {
    return subDomainPreBasis_.size(prefix);
  }
 
  auto containerDescriptor() const
  {
    return subDomainPreBasis_.containerDescriptor();
  }
 
  size_type dimension() const
  {
    return subDomainPreBasis_.dimension();
  }
 
  size_type maxNodeSize() const
  {
    return subDomainPreBasis_.maxNodeSize();
  }
 
  const SubDomainPreBasis& subDomainPreBasis() const
  {
    return subDomainPreBasis_;
  }
 
  SubDomainPreBasis& subDomainPreBasis()
  {
    return subDomainPreBasis_;
  }
 
  template<typename It>
  It indices(const Node& node, It it) const
  {
    if (node.size() == 0)
      return it;
    else
      return subDomainPreBasis_.indices(node, it);
  }
 
protected:
  GridView gridView_;
  SubDomainPreBasis subDomainPreBasis_;
  const SubDomain* subDomainPtr_;
};
 
 
 
namespace BasisFactory {
 
template<class SubDomainBasisFactory, class SubDomain>
auto restrict(SubDomainBasisFactory&& subPreBasisFactory, const SubDomain& subDomain)
{
  return [
    subPreBasisFactory=std::forward<SubDomainBasisFactory>(subPreBasisFactory),
    &subDomain
  ](const auto& gridView) {
    return Dune::Functions::Experimental::RestrictedPreBasis(gridView, subPreBasisFactory(subDomain.gridView()), subDomain);
  };
}
 
 
} // end namespace BasisFactory
} // end namespace Dune::Functions::Experimental
 
 
#endif // DUNE_FUNCTIONS_FUNCTIONSPACEBASES_RESTRICTEDBASIS_HH