intersectionquadrature.hh

#ifndef DUNE_FEM_INTERSECTIONQUADRATURE_HH
#define DUNE_FEM_INTERSECTIONQUADRATURE_HH
 
//- Dune includes
#include <dune/common/math.hh>
 
//- Local includes
#include "elementquadrature.hh"
#include "caching/twistutility.hh"
#include "caching/pointmapper.hh"
#include "caching/cacheprovider.hh"
 
#include "elementquadrature.hh"
#include "cachingquadrature.hh"
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< typename FaceQuadrature, bool conforming  >
    class IntersectionQuadrature
    {
      template < typename FaceQuadratureImp, bool isConforming >
      struct QuadSelector
      {
        // use given quadrature
        typedef FaceQuadratureImp  FaceQuadratureType;
      };
 
      template < typename FaceQuadratureImp >
      struct QuadSelector<FaceQuadratureImp, false>
      {
        // in this case non conforming type is used
        typedef typename  FaceQuadratureImp ::
          NonConformingQuadratureType  FaceQuadratureType;
      };
 
    public:
      typedef typename FaceQuadrature :: GridPartType GridPartType;
 
      typedef typename GridPartType::IntersectionIteratorType IntersectionIteratorType;
      typedef typename IntersectionIteratorType::Intersection IntersectionType;
 
      enum { codimension = FaceQuadrature :: codimension };
 
      typedef typename QuadSelector<FaceQuadrature, conforming> :: FaceQuadratureType FaceQuadratureType;
 
      enum { dimension = FaceQuadratureType ::dimension };
 
      typedef typename FaceQuadratureType :: RealType RealType;
      typedef typename FaceQuadratureType :: CoordinateType CoordinateType;
 
      typedef typename FaceQuadratureType::LocalCoordinateType LocalCoordinateType;
 
      // for compatibility
      typedef typename GridPartType::template Codim< 0 >::EntityType EntityType;
 
      IntersectionQuadrature( const GridPartType &gridPart,
                              const IntersectionType &intersection,
                              const int order)
      : inside_ ( gridPart, intersection, order, FaceQuadratureType::INSIDE ),
        outside_( gridPart, intersection, order, intersection.neighbor() ? FaceQuadratureType::OUTSIDE : FaceQuadratureType::INSIDE )
      {}
 
      IntersectionQuadrature( const GridPartType &gridPart,
                              const IntersectionType &intersection,
                              const int order,
                              const bool noNeighborCheck )
      : inside_ ( gridPart, intersection, order, FaceQuadratureType::INSIDE  ),
        outside_( gridPart, intersection, order, FaceQuadratureType::OUTSIDE )
      {
        // make sure neighbor is true
        assert( intersection.neighbor() );
      }
 
      const FaceQuadratureType& inside()  const { return inside_;  }
 
      const FaceQuadratureType& outside() const { return outside_; }
 
      size_t nop () const
      {
        assert( inside().nop() == outside().nop() );
        return inside().nop();
      }
 
      const LocalCoordinateType &localPoint ( const int qp ) const
      {
        assert( inside().localPoint( qp ) == outside().localPoint( qp ) );
        return inside().localPoint( qp );
      }
 
      auto weight ( const int qp ) const
      {
        assert( inside().weight( qp ) == outside().weight( qp ) );
        return inside().weight( qp );
      }
 
      IntersectionQuadrature( const IntersectionQuadrature& ) = delete;
 
    protected:
      const FaceQuadratureType inside_;
      const FaceQuadratureType outside_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_INTERSECTIONQUADRATURE_HH