domainfilter.hh

#ifndef DUNE_FEM_DOMAINFILTER_HH
#define DUNE_FEM_DOMAINFILTER_HH
 
#include <dune/fem/gridpart/filter/filter.hh>
#include <dune/fem/storage/dynamicarray.hh>
 
#include <dune/fem/misc/boundaryidprovider.hh>
 
namespace Dune
{
  namespace Fem
  {
 
    // forward declarations
    // --------------------
 
    template< class > class FilterDefaultImplementation;
    template< class , class > class DomainFilter;
 
 
    // DomainFilterTraits
    // ------------------------
 
    template< class GridPartImp, class DomainArrayImp >
    struct DomainFilterTraits
    {
      typedef GridPartImp GridPartType;
 
      typedef DomainArrayImp DomainArrayType;
 
      typedef DomainFilter< GridPartType, DomainArrayType > FilterType;
 
      template < int cd >
      struct Codim
      {
        typedef typename GridPartType::template Codim< cd >::EntityType EntityType;
      };
 
      typedef typename Codim< 0 >::EntityType EntityType;
    };
 
 
    // DomainFilter
    // ------------------
 
    template< class GridPartImp, class DomainArrayImp = DynamicArray< int > >
    class DomainFilter
    : public FilterDefaultImplementation< DomainFilterTraits< GridPartImp, DomainArrayImp > >
    {
    public:
      typedef GridPartImp GridPartType;
 
      typedef DomainArrayImp DomainArrayType;
 
      typedef typename DomainArrayType::value_type FieldType;
 
      typedef DomainFilterTraits< GridPartType, DomainArrayType > Traits;
 
      typedef BoundaryIdProvider< typename GridPartType::GridType >
        BoundaryIdProviderType;
    protected:
      typedef DomainFilter< GridPartType, DomainArrayType > ThisType;
 
      typedef FilterDefaultImplementation< Traits > BaseType;
 
    public:
      typedef typename Traits::FilterType FilterType;
 
      typedef typename GridPartType :: IndexSetType IndexSetType;
 
      template< int cd >
      struct Codim
      {
        typedef typename Traits::template Codim< cd >::EntityType EntityType;
      };
 
      typedef typename Traits::EntityType EntityType;
 
      DomainFilter ( const GridPartType & gridPart,
                     const DomainArrayType& tags,
                     const FieldType tag )
      : indexSet_( gridPart.indexSet() ),
        tags_( tags ),
        tag_( tag )
      {}
 
      DomainFilter ( const ThisType & ) = default;
      DomainFilter ( ThisType && ) = default;
 
      ThisType &operator= ( const ThisType & ) = default;
      ThisType &operator= ( ThisType && ) = default;
 
      template< class Intersection >
      bool interiorIntersection( const Intersection & ) const
      {
        return false;
      }
 
      template< int cd >
      bool contains ( const typename Codim< cd >::EntityType & entity ) const
      {
        if( cd == 0 )
        {
          return ( tag_ == tags_[ indexSet_.index( entity ) ] );
        }
        else
          return false;
      }
 
      template< class Entity >
      bool contains ( const Entity & entity ) const
      {
        return contains< Entity::codimension >( entity );
      }
 
      template< class Intersection >
      bool intersectionBoundary( const Intersection & intersection ) const
      {
        return BoundaryIdProviderType::boundaryId( intersection );
      }
 
      template< class Intersection >
      int intersectionBoundaryId ( const Intersection & intersection ) const
      {
        return BoundaryIdProviderType::boundaryId( intersection );
      }
 
      template< class Intersection >
      bool intersectionNeighbor ( const Intersection & intersection ) const
      {
        return intersection.neighbor();
      }
 
    protected:
      const IndexSetType& indexSet_;
      const DomainArrayType& tags_;
      const FieldType tag_;
    };
 
  }  // end namespace Fem
 
}  // end namespace Dune
 
#endif // #ifndef DUNE_FEM_DOMAINFILTER_HH