localoperator.hh

Go to the documentation of this file.

#ifndef DUNE_FEM_LOCALOPERATORS_HH
#define DUNE_FEM_LOCALOPERATORS_HH
 
#include <iostream>
 
#include "objpointer.hh"
 
namespace Dune
{
 
  namespace Fem
  {
 
    //***********************************************************************
    //
    //***********************************************************************
    template <class FstPType, class SecPType, class SType ,
        class LocalOperatorImp>
    class LocalOperatorInterface
    {
    public:
      typedef FstPType FirstParamType;
      typedef SecPType SecondParamType;
      typedef SType ScalarType;
 
      //**************************************************************
 
      void prepareGlobal(const FirstParamType &pa, SecondParamType &pb)
      {
        asImp().prepareGlobal(pa,pb);
      }
 
      void prepareGlobal ()
      {
        asImp().prepareGlobal();
      }
 
      void finalizeGlobal()
      {
        asImp().finalizeGlobal();
      }
 
      template<class EntityType>
      void prepareLocal (EntityType & en)
      {
        asImp().prepareLocal(en);
      }
 
      template<class EntityType>
      void finalizeLocal(EntityType & en)
      {
        asImp().finalizeLocal(en);
      }
 
      template<class EntityType>
      void prepareLocal (EntityType & en1, EntityType &en2)
      {
        asImp().prepareLocal(en1,en2);
      }
 
      template<class EntityType>
      void finalizeLocal(EntityType & en1, EntityType &en2)
      {
        asImp().finalizeLocal(en1,en2);
      }
 
      template<class EntityType>
      void applyLocal(EntityType & en)
      {
        asImp().applyLocal(en);
      }
 
      template<class EntityType>
      void applyLocal(EntityType & en1, EntityType &en2)
      {
        asImp().applyLocal(en1,en2);
      }
    private:
      LocalOperatorImp & asImp()
      {
        return static_cast<LocalOperatorImp &> (*this);
      }
    };
 
    //**************************************************************************
    //  Default implemenations for LocalOperators
    //**************************************************************************
    template <class FstPType, class SecPType, class SType ,
        class LocalOperatorImp>
    class LocalOperatorDefault
    : public LocalOperatorInterface <FstPType,SecPType,
                          SType,LocalOperatorImp>
    {
    public:
      typedef FstPType FirstParamType;
      typedef SecPType SecondParamType;
      typedef SType ScalarType;
 
      LocalOperatorDefault () : scalar_ (1.0) {}
 
      void scaleIt ( const ScalarType scalar )
      {
        scalar_ = scalar;
      }
 
      //**************************************************************
      // prepare for grid walktrough
      void prepareGlobal () {}
 
      // finalize the walktrough
      void finalizeGlobal() {}
 
      // one entity
      template<class EntityType>
      void prepareLocal (EntityType & en) {}
 
      template<class EntityType>
      void finalizeLocal(EntityType & en) {}
 
      // two entities
      template<class EntityType>
      void prepareLocal (EntityType & en1, EntityType &en2){}
 
      template<class EntityType>
      void finalizeLocal(EntityType & en1, EntityType &en2){}
      //**************************************************************
 
    protected:
      // scalar for operator
      ScalarType scalar_;
    };
 
    //*******************************************************************
    //
    //*******************************************************************
    template <class A, class B >
    class CombinedLocalOperator
      : public ObjPointerStorage
    {
    public:
      typedef A FirstOperatorType;
      typedef B SecondOperatorType;
 
      CombinedLocalOperator ( A & a, B & b , bool printMsg = false )
        : _a ( a ) , _b ( b ) , printMSG_ ( printMsg )
      {
        if(printMSG_)
          std::cout << "Create CombinedLocalOperator " << this << std::endl;
      }
 
      ~CombinedLocalOperator ()
      {
        if(printMSG_)
          std::cout << "Delete CombinedLocalOperator " << this << std::endl;
      }
 
      template <class ScalarType>
      void scaleIt( const ScalarType scalar);
 
      //*******************************************************
 
      template <class FirstParamType, class SecondParamType>
      void prepareGlobal(const FirstParamType &pa, SecondParamType &pb);
 
      void finalizeGlobal();
 
      //*******************************************************
      // one entity
      template<class EntityType>
      void prepareLocal (EntityType & en);
 
      template<class EntityType>
      void finalizeLocal(EntityType & en);
 
      // two entities
      template<class EntityType>
      void prepareLocal (EntityType & en1, EntityType &en2);
 
      template<class EntityType>
      void finalizeLocal(EntityType & en1, EntityType &en2);
 
      //**********************************************************
      // things to do on one entity
      template<class EntityType>
      void applyLocal(EntityType & en);
 
      // things to do on two entity
      template<class EntityType>
      void applyLocal(EntityType & en1, EntityType &en2);
 
      //****************************************************************
    private:
      A & _a;
      B & _b;
 
      // if true some messages in Constructor and Destructor are printed
      bool printMSG_;
    };
 
 
    //********************************************************************
    //
    //  Implementation
    //
    //********************************************************************
    template <class A, class B >
    template <class ScalarType>
    inline void CombinedLocalOperator<A,B>::
    scaleIt(const ScalarType scalar)
    {
      _a.scaleIt(scalar);
      _b.scaleIt(scalar);
    }
    template <class A, class B >
    template <class FirstParamType, class SecondParamType>
    inline void CombinedLocalOperator<A,B>::
    prepareGlobal(const FirstParamType &pa, SecondParamType &pb)
    {
      _a.scaleIt(1.0);
      _b.scaleIt(1.0);
      _b.prepareGlobal(pa,pb);
      _a.prepareGlobal(pa,pb);
    }
 
    template <class A, class B >
    inline void CombinedLocalOperator<A,B>::finalizeGlobal()
    {
      _b.finalizeGlobal();
      _a.finalizeGlobal();
    }
 
 
    template <class A, class B >
    template <class EntityType>
    inline void CombinedLocalOperator<A,B>::prepareLocal(EntityType &en)
    {
      _b.prepareLocal(en);
      _a.prepareLocal(en);
    }
 
    template <class A, class B >
    template <class EntityType>
    inline void CombinedLocalOperator<A,B>::finalizeLocal(EntityType &en)
    {
      _b.finalizeLocal(en);
      _a.finalizeLocal(en);
    }
 
    template <class A, class B >
    template <class EntityType>
    inline void CombinedLocalOperator<A,B>::applyLocal(EntityType &en)
    {
      _b.applyLocal(en);
      _a.applyLocal(en);
    }
 
 
    template <class A, class B >
    template <class EntityType>
    inline void CombinedLocalOperator<A,B>::prepareLocal(EntityType &en1, EntityType & en2)
    {
      _b.prepareLocal(en1,en2);
      _a.prepareLocal(en1,en2);
    }
 
    template <class A, class B >
    template <class EntityType>
    inline void CombinedLocalOperator<A,B>::applyLocal(EntityType &en1, EntityType &en2 )
    {
      _b.applyLocal(en1,en2);
      _a.applyLocal(en1,en2);
    }
 
    template <class A, class B >
    template <class EntityType>
    inline void CombinedLocalOperator<A,B>::finalizeLocal(EntityType &en1, EntityType & en2)
    {
      _b.finalizeLocal(en1,en2);
      _a.finalizeLocal(en1,en2);
    }
 
 
    //********************************************************************
    //********************************************************************
    //********************************************************************
    //********************************************************************
    //
    //
    //********************************************************************
    template <class A,class ScalarType>
    class ScaledLocalOperator
      : public ObjPointerStorage
    {
    public:
      ScaledLocalOperator ( A & a , const ScalarType scalar,
            bool printMsg = false)
        : _a ( a ) , scalar_ (scalar), tmpScalar_ (scalar) ,
          printMSG_ ( printMsg )
      {
        if(printMSG_)
          std::cout << "Create ScaledLocalOperator " << this << std::endl;
      }
 
      ~ScaledLocalOperator ()
      {
        if(printMSG_)
          std::cout << "Delete ScaledLocalOperator " << this << std::endl;
      }
      // scale this operator from outside
      void scaleIt ( const ScalarType & scalar);
 
      //*******************************************************
 
      template <class FirstParamType, class SecondParamType>
      void prepareGlobal(const FirstParamType &pa, SecondParamType &pb);
 
      void finalizeGlobal();
 
      //*******************************************************
      // one entity
      template<class EntityType>
      void prepareLocal (EntityType & en);
 
      template<class EntityType>
      void finalizeLocal(EntityType & en);
 
      // two entities
      template<class EntityType>
      void prepareLocal (EntityType & en1, EntityType &en2);
 
      template<class EntityType>
      void finalizeLocal(EntityType & en1, EntityType &en2);
 
      //**********************************************************
      // things to do on one entity
      template<class EntityType>
      void applyLocal(EntityType & en);
 
      // things to do on two entity
      template<class EntityType>
      void applyLocal(EntityType & en1, EntityType &en2);
    protected:
      A & _a;
 
      const ScalarType scalar_;
      ScalarType tmpScalar_;
 
      // if true some messages in Contructor and Destructor are printed
      bool printMSG_;
    }; // end class ScaledLocalOperator
 
    //****************************************************
    //  Implementation
    //****************************************************
    template <class A, class ScalarType>
    inline void ScaledLocalOperator<A,ScalarType>::
    scaleIt ( const ScalarType & scalar )
    {
      tmpScalar_ = scalar_ * scalar;
    }
 
    template <class A, class ScalarType>
    template <class FirstParamType, class SecondParamType>
    inline void ScaledLocalOperator<A,ScalarType>::
    prepareGlobal(const FirstParamType &pa, SecondParamType &pb)
    {
      _a.scaleIt(tmpScalar_);
      _a.prepareGlobal(pa,pb);
    }
 
    template <class A, class ScalarType>
    inline void ScaledLocalOperator<A,ScalarType>::finalizeGlobal()
    {
      _a.finalizeGlobal();
    }
 
    template <class A, class ScalarType>
    template <class EntityType>
    inline void ScaledLocalOperator<A,ScalarType>::prepareLocal(EntityType &en)
    {
      _a.prepareLocal(en);
    }
 
    template <class A, class ScalarType>
    template <class EntityType>
    inline void ScaledLocalOperator<A,ScalarType>::prepareLocal(EntityType &en1, EntityType & en2)
    {
      _a.prepareLocal(en1,en2);
    }
 
    template <class A, class ScalarType>
    template <class EntityType>
    inline void ScaledLocalOperator<A,ScalarType>::finalizeLocal(EntityType &en)
    {
      _a.finalizeLocal(en);
    }
 
    template <class A, class ScalarType>
    template <class EntityType>
    inline void ScaledLocalOperator<A,ScalarType>::finalizeLocal(EntityType &en1, EntityType & en2)
    {
      _a.finalizeLocal(en1,en2);
    }
 
    template <class A, class ScalarType>
    template <class EntityType>
    inline void ScaledLocalOperator<A,ScalarType>::applyLocal(EntityType &en)
    {
      _a.applyLocal(en);
    }
 
    template <class A, class ScalarType>
    template <class EntityType>
    inline void ScaledLocalOperator<A,ScalarType>::applyLocal(EntityType &en1, EntityType &en2 )
    {
      _a.applyLocal(en1,en2);
    }
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_LOCALOPERATORS_HH