istloperator.hh

#ifndef DUNE_FEM_ISTLLINEAROPERATOR_HH
#define DUNE_FEM_ISTLLINEAROPERATOR_HH
 
#if HAVE_DUNE_ISTL
 
// system includes
#include <string>
 
// local includes
#include <dune/fem/operator/matrix/istlmatrix.hh>
 
namespace Dune
{
 
  namespace Fem
  {
    template< class DomainFunction, class RangeFunction >
    struct ISTLLinearOperator;
 
    template< class DomainFunction, class RangeFunction >
    struct ISTLLinearOperator
    : public ISTLMatrixObject< typename DomainFunction::DiscreteFunctionSpaceType, typename RangeFunction::DiscreteFunctionSpaceType >,
      public AssembledOperator< DomainFunction, RangeFunction >
    {
      typedef typename DomainFunction::DiscreteFunctionSpaceType DomainSpaceType;
      typedef typename RangeFunction::DiscreteFunctionSpaceType RangeSpaceType;
      typedef ISTLLinearOperator< DomainFunction, RangeFunction > ThisType;
      typedef ISTLMatrixObject< DomainSpaceType, RangeSpaceType > BaseType;
 
      static constexpr bool assembled = true;
 
      using BaseType::apply;
 
      ISTLLinearOperator( const std::string & ,
                          const DomainSpaceType &domainSpace,
                          const RangeSpaceType &rangeSpace,
                          const ISTLSolverParameter& param = ISTLSolverParameter() )
        : BaseType( domainSpace, rangeSpace, param )
      {}
 
      virtual void clear() { BaseType::clear(); }
 
      virtual void operator()( const DomainFunction &arg, RangeFunction &dest ) const
      {
        apply( arg, dest );
      }
 
      virtual void finalize() { BaseType::compress(); }
 
    };
 
    template< class DomainFunctionSpace, class RangeFunctionSpace,
              class DomainBlock, class RangeBlock >
    struct ISTLLinearOperator< ISTLBlockVectorDiscreteFunction< DomainFunctionSpace, DomainBlock >,
                               ISTLBlockVectorDiscreteFunction< RangeFunctionSpace, RangeBlock > >
    : public ISTLMatrixObject< DomainFunctionSpace, RangeFunctionSpace, DomainBlock, RangeBlock >,
      public AssembledOperator< ISTLBlockVectorDiscreteFunction< DomainFunctionSpace, DomainBlock >,
                                ISTLBlockVectorDiscreteFunction< RangeFunctionSpace, RangeBlock > >
    {
      typedef DomainFunctionSpace DomainSpaceType;
      typedef RangeFunctionSpace  RangeSpaceType;
 
      typedef ISTLBlockVectorDiscreteFunction< DomainFunctionSpace, DomainBlock > DomainFunction;
      typedef ISTLBlockVectorDiscreteFunction< RangeFunctionSpace, RangeBlock >   RangeFunction;
 
      typedef ISTLLinearOperator< DomainFunction, RangeFunction > ThisType;
      typedef ISTLMatrixObject< DomainSpaceType, RangeSpaceType, DomainBlock, RangeBlock > BaseType;
 
      static constexpr bool assembled = true;
 
      using BaseType::apply;
 
      ISTLLinearOperator( const std::string & ,
                          const DomainSpaceType &domainSpace,
                          const RangeSpaceType &rangeSpace,
                          const ISTLSolverParameter& param = ISTLSolverParameter() )
        : BaseType( domainSpace, rangeSpace, param )
      {}
 
      virtual void clear() { BaseType::clear(); }
 
      virtual void operator()( const DomainFunction &arg, RangeFunction &dest ) const
      {
        apply( arg, dest );
      }
 
      virtual void finalize() { BaseType::compress(); }
 
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #if HAVE_DUNE_ISTL
 
#endif // #ifndef DUNE_FEM_ISTLLINEAROPERATOR_HH