operator.hh

#ifndef DUNE_FEM_OPERATOR_HH
#define DUNE_FEM_OPERATOR_HH
 
#include <cassert>
#include <typeindex>
#include <cassert>
 
#include <dune/common/exceptions.hh>
 
#include <dune/fem/version.hh>
#include <dune/common/exceptions.hh>
#include <dune/fem/operator/common/mapping.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< class DomainFunction, class RangeFunction = DomainFunction >
    struct Operator
    {
      typedef DomainFunction DomainFunctionType;
      typedef RangeFunction RangeFunctionType;
 
      typedef typename DomainFunction::RangeFieldType DomainFieldType;
      typedef typename RangeFunction::RangeFieldType RangeFieldType;
 
      virtual ~Operator ()
      {}
 
      virtual void operator() ( const DomainFunctionType &u, RangeFunctionType &w ) const = 0;
 
      virtual void finalize () {}
    };
 
    template< class DomainFunction, class RangeFunction = DomainFunction >
    struct LinearOperator
      : public virtual Operator<DomainFunction, RangeFunction>
    {
      virtual bool symmetric() const
      {
              return false;
      }
      virtual bool positiveDefinite() const
      {
              return false;
      }
    };
 
    template< class DomainFunction, class RangeFunction = DomainFunction >
    class AssembledOperator
      : public virtual LinearOperator<DomainFunction, RangeFunction>
    {
    public:
      virtual void flushAssembly() {}
 
      template< class AssembleOperation >
      void beginAssemble ()
      {
        const std::type_index id( typeid( AssembleOperation ) );
        if( assembleOperation_ != id )
        {
          if( assembleOperation_ != std::type_index( typeid( void ) ) )
            DUNE_THROW( InvalidStateException, "Another assemble operation in progress" );
          assembleOperation_ = id;
          assert( assembleCount_ == 0 );
          AssembleOperation::begin( *this );
        }
        ++assembleCount_;
      }
 
      template< class AssembleOperation >
      void endAssemble ()
      {
        const std::type_index id( typeid( AssembleOperation ) );
        if( assembleOperation_ != id )
          DUNE_THROW( InvalidStateException, "Assemble operation not in progress" );
        assert( assembleCount_ > 0 );
        if( --assembleCount_ == 0 )
        {
          AssembleOperation::end( *this );
          assembleOperation_ = std::type_index( typeid( void ) );
        }
      }
 
    protected:
      std::type_index assembleOperation_ = std::type_index( typeid( void ) );
      std::size_t assembleCount_ = 0;
    };
 
 
    // Is*Operator
    // -----------
 
    namespace Impl
    {
 
      template< class T >
      using DomainFunctionType_t = typename T::DomainFunctionType;
 
      template< class T >
      using RangeFunctionType_t = typename T::RangeFunctionType;
 
      template< class T >
      using IsOperatorImpl = std::is_base_of< ::Dune::Fem::Operator< DomainFunctionType_t< T >, RangeFunctionType_t< T > >, T >;
 
      template< class T >
      using IsLinearOperatorImpl = std::is_base_of< ::Dune::Fem::LinearOperator< DomainFunctionType_t< T >, RangeFunctionType_t< T > >, T >;
 
      template< class T >
      using IsAssembledOperatorImpl = std::is_base_of< ::Dune::Fem::AssembledOperator< DomainFunctionType_t< T >, RangeFunctionType_t< T > >, T >;
 
    } // namespace Impl
 
    template< class T >
    using IsOperator = Impl::IsOperatorImpl< std::decay_t< T > >;
 
    template< class T >
    using IsLinearOperator = Impl::IsOperatorImpl< std::decay_t< T > >;
 
    template< class T >
    using IsAssembledOperator = Impl::IsAssembledOperatorImpl< std::decay_t< T > >;
 
  } // namespace Fem
 
 
 
  template <typename DFieldType, typename RFieldType,
            typename DType , typename RType>
  class Operator
  : public Fem::Mapping < DFieldType, RFieldType, DType, RType >,
    public virtual Fem::Operator< DType, RType >
  {
    typedef Fem::Operator< DType, RType > BaseType;
 
  protected:
    typedef Fem::Mapping <DFieldType,RFieldType,DType,RType> MappingType;
 
  public:
    //- remember template parameters for derived classes
    typedef DType DomainType;
    typedef RType  RangeType;
    typedef DFieldType DomainFieldType;
    typedef RFieldType RangeFieldType;
 
    using BaseType::operator();
    using BaseType::finalize;
 
  protected:
    virtual void apply (const DomainType& arg, RangeType& dest) const
    {
      this->operator() (arg, dest);
    }
  }; // class Operator
 
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_OPERATOR_HH