localmatrixwrapper.hh

#ifndef DUNE_FEM_LOCALMATRIXWRAPPER_HH
#define DUNE_FEM_LOCALMATRIXWRAPPER_HH
 
#include <dune/fem/operator/common/localmatrix.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // Internal Forward Declarations
    // -----------------------------
 
    template< class LocalMatrixStack >
    class LocalMatrixWrapper;
 
 
 
    // LocalMatrixWrapperTraits
    // ------------------------
 
    template< class LocalMatrixStack >
    struct LocalMatrixWrapperTraits
    {
      typedef LocalMatrixStack LocalMatrixStackType;
 
      typedef typename LocalMatrixStack::ObjectType WrappedLocalMatrixType;
 
      typedef LocalMatrixWrapper< LocalMatrixStackType > LocalMatrixType;
 
      typedef typename WrappedLocalMatrixType::RangeFieldType RangeFieldType;
 
      typedef typename WrappedLocalMatrixType::DomainSpaceType DomainSpaceType;
      typedef typename WrappedLocalMatrixType::RangeSpaceType RangeSpaceType;
 
      typedef typename WrappedLocalMatrixType::LittleBlockType LittleBlockType;
    };
 
 
 
    // LocalMatrixWrapper
    // ------------------
 
    template< class LocalMatrixStack >
    class LocalMatrixWrapper
    : public LocalMatrixInterface< LocalMatrixWrapperTraits< LocalMatrixStack > >
    {
      typedef LocalMatrixWrapper< LocalMatrixStack > ThisType;
      typedef LocalMatrixInterface< LocalMatrixWrapperTraits< LocalMatrixStack > > BaseType;
 
    public:
      typedef LocalMatrixStack LocalMatrixStackType;
 
      typedef LocalMatrixWrapperTraits< LocalMatrixStackType > Traits;
 
      typedef typename Traits::WrappedLocalMatrixType WrappedLocalMatrixType;
 
      typedef typename Traits::RangeFieldType RangeFieldType;
 
      typedef typename BaseType::DomainSpaceType DomainSpaceType;
      typedef typename BaseType::RangeSpaceType RangeSpaceType;
 
      typedef typename BaseType::DomainBasisFunctionSetType DomainBasisFunctionSetType;
      typedef typename BaseType::RangeBasisFunctionSetType RangeBasisFunctionSetType;
 
      typedef typename BaseType::DomainEntityType DomainEntityType;
      typedef typename BaseType::RangeEntityType RangeEntityType;
 
    private:
      typedef typename LocalMatrixStackType::PointerType WrappedLocalMatrixPtrType;
 
      // ObjectPointer to the actual local matrix
      // (the pointer is required to keep the reference alive)
      WrappedLocalMatrixPtrType localMatrixPtr_;
 
      // reference to the actual local matrix
      WrappedLocalMatrixType &localMatrix_;
 
    public:
      explicit LocalMatrixWrapper ( LocalMatrixStackType &stack )
      : localMatrixPtr_( stack.getObject() ),
        localMatrix_( *localMatrixPtr_ )
      {}
 
      template< class DomainEntityType, class RangeEntityType >
      LocalMatrixWrapper( LocalMatrixStackType &stack,
                                 const DomainEntityType &domainEntity,
                                 const RangeEntityType &rangeEntity )
      : localMatrixPtr_( stack.getObject() ),
        localMatrix_( *localMatrixPtr_ )
      {
        // initialize the wrapped local matrix with the entities
        localMatrix().init( domainEntity, rangeEntity );
      }
 
      LocalMatrixWrapper ( const ThisType &other )
      : localMatrixPtr_( other.localMatrixPtr_ ),
        localMatrix_( *localMatrixPtr_ )
      {}
 
      ~LocalMatrixWrapper ( )
      {
        // call finalize on local matrix implementation
        // (e.g. needed for PETSc to add values to the real matrix)
        localMatrix().finalize();
      }
 
      ThisType& operator= ( const ThisType& ) = delete;
 
      void init ( const DomainEntityType &domainEntity, const RangeEntityType &rangeEntity )
      {
        localMatrix().init( domainEntity, rangeEntity );
      }
 
      void add ( int localRow, int localCol, const RangeFieldType &value )
      {
        localMatrix().add( localRow, localCol, value );
      }
 
      void set ( int localRow, int localCol, const RangeFieldType &value )
      {
        localMatrix().set( localRow, localCol, value );
      }
 
      void clearRow ( const int localRow )
      {
        localMatrix().clearRow( localRow );
      }
 
      void clearCol ( const int localCol )
      {
        localMatrix().clearCol( localCol );
      }
 
      const RangeFieldType get ( const int localRow,
                                        const int localCol ) const
      {
        return localMatrix().get( localRow, localCol );
      }
 
      void scale ( const RangeFieldType& scalar )
      {
        return localMatrix().scale( scalar );
      }
 
      void clear ()
      {
        return localMatrix().clear();
      }
 
      void resort ()
      {
        return localMatrix().resort();
      }
 
      int rows () const
      {
        return localMatrix().rows();
      }
 
      int columns () const
      {
        return localMatrix().columns();
      }
 
      template <class DomainLocalFunctionImp,
                class RangeLocalFunctionImp>
      void multiplyAdd(const DomainLocalFunctionImp& dLf,
                              RangeLocalFunctionImp& rLf)
      {
        localMatrix().multiplyAdd( dLf, rLf);
      }
 
      const DomainSpaceType &domainSpace () const
      {
        return localMatrix().domainSpace();
      }
 
      const RangeSpaceType &rangeSpace () const
      {
        return localMatrix().rangeSpace();
      }
 
      const DomainEntityType &domainEntity () const { return localMatrix().domainEntity(); }
      const RangeEntityType &rangeEntity () const { return localMatrix().rangeEntity(); }
 
      const DomainBasisFunctionSetType &domainBasisFunctionSet () const
      {
        return localMatrix().domainBasisFunctionSet();
      }
 
      const RangeBasisFunctionSetType &rangeBasisFunctionSet () const
      {
        return localMatrix().rangeBasisFunctionSet();
      }
 
    protected:
      const WrappedLocalMatrixType &localMatrix () const { return localMatrix_; }
      WrappedLocalMatrixType &localMatrix () { return localMatrix_; }
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_LOCALMATRIXWRAPPER_HH