elementpointlist.hh

#ifndef DUNE_FEM_ELEMENTPOINTLIST_HH
#define DUNE_FEM_ELEMENTPOINTLIST_HH
 
#include <dune/fem/quadrature/elementpointlistbase.hh>
#include <dune/fem/quadrature/caching/twistutility.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< class GridPartImp, int codim, class IntegrationTraits >
    class ElementIntegrationPointList;
 
 
 
    template< class GridPartImp, class IntegrationTraits >
    class ElementIntegrationPointList< GridPartImp, 0, IntegrationTraits >
    : public ElementPointListBase< GridPartImp, 0, IntegrationTraits >
    {
      typedef ElementIntegrationPointList< GridPartImp, 0, IntegrationTraits > This;
      typedef ElementPointListBase< GridPartImp, 0, IntegrationTraits >  Base;
 
    public:
      typedef typename Base::CoordinateType CoordinateType;
 
      typedef typename Base::QuadratureKeyType  QuadratureKeyType;
 
      typedef QuadraturePointWrapper< This > QuadraturePointWrapperType;
      typedef QuadraturePointIterator< This > IteratorType;
 
      typedef typename Base :: IntegrationPointListType  IntegrationPointListType;
 
    public:
      using Base::localPoint;
      using Base::nop;
 
      ElementIntegrationPointList( const GeometryType &geometry, const QuadratureKeyType& quadKey )
      : Base( geometry, quadKey )
      {}
 
      ElementIntegrationPointList( const IntegrationPointListType& ipList )
      : Base( ipList )
      {}
 
      const QuadraturePointWrapperType operator[] ( const size_t i ) const
      {
        return QuadraturePointWrapperType( *this, i );
      }
 
      IteratorType begin () const noexcept { return IteratorType( *this, 0 ); }
      IteratorType end () const noexcept { return IteratorType( *this, nop() ); }
 
      const CoordinateType &point ( const size_t i ) const
      {
        return localPoint( i );
      }
    };
 
 
 
    template< class GridPartImp, class IntegrationTraits >
    class ElementIntegrationPointList< GridPartImp, 1, IntegrationTraits >
    : public ElementPointListBase< GridPartImp, 1, IntegrationTraits >
    {
      typedef ElementIntegrationPointList< GridPartImp, 1, IntegrationTraits > This;
      typedef ElementPointListBase< GridPartImp, 1, IntegrationTraits > Base;
 
    public:
      typedef GridPartImp GridPartType;
 
      static const int dimension = Base::dimension;
 
      typedef typename Base::CoordinateType CoordinateType;
 
      typedef typename Base::QuadratureKeyType  QuadratureKeyType;
 
      typedef typename GridPartType::IntersectionIteratorType IntersectionIteratorType;
      typedef typename IntersectionIteratorType::Intersection IntersectionType;
 
      typedef QuadraturePointWrapper< This > QuadraturePointWrapperType;
      typedef QuadraturePointIterator< This > IteratorType;
 
      typedef This NonConformingQuadratureType;
 
 
      // for compatibility
      typedef typename GridPartType::TwistUtilityType  TwistUtilityType;
      typedef IntersectionIteratorType IntersectionIterator;
 
 
      using Base::localPoint;
      using Base::elementGeometry;
      using Base::nop;
 
      ElementIntegrationPointList ( const GridPartType &gridPart,
                                    const IntersectionType &intersection,
                                    const QuadratureKeyType& quadKey,
                                    const typename Base :: Side side )
      : Base( getPointList( intersection, quadKey, side ) ),
        side_(side),
        intersection_(intersection),
        referenceGeometry_( side == Base::INSIDE ?  intersection.geometryInInside() : intersection.geometryInOutside())
      {}
 
      const QuadraturePointWrapperType operator[] ( size_t i ) const
      {
        return QuadraturePointWrapperType( *this, i );
      }
 
      IteratorType begin () const noexcept { return IteratorType( *this, 0 ); }
      IteratorType end () const noexcept { return IteratorType( *this, nop() ); }
      typename Base :: Side side() const { return side_; }
      bool isInside() const { return side_ == Base::INSIDE; }
 
      const CoordinateType &point ( size_t i ) const
      {
        dummy_ = referenceGeometry_.global( localPoint( i ) );
        return dummy_;
      }
 
      using Base::localFaceIndex;
 
      const IntersectionType &intersection() const
      {
        return intersection_;
      }
 
    protected:
      Base getPointList ( const IntersectionType &intersection, const int order,
                          const typename Base :: Side side )
      {
        switch( side )
        {
          case Base :: INSIDE:
            return Base( TwistUtilityType::elementGeometry( intersection, true ),
                         intersection.type(), intersection.indexInInside(), order );
 
          case Base ::OUTSIDE:
            return Base( TwistUtilityType::elementGeometry( intersection, false ),
                         intersection.type(), intersection.indexInOutside(), order );
 
          default:
            DUNE_THROW( InvalidStateException, "ElementIntegrationPointList: side must either be INSIDE or OUTSIDE." );
        }
      }
 
    private:
      typedef typename IntersectionIteratorType::Intersection::LocalGeometry ReferenceGeometry;
 
      const typename Base :: Side side_;
      const IntersectionType &intersection_;
      ReferenceGeometry referenceGeometry_;
      mutable CoordinateType dummy_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_ELEMENTPOINTLIST_HH