restrictprolonginterface.hh

#ifndef DUNE_FEM_RESTRICTPROLONGINTERFACE_HH
#define DUNE_FEM_RESTRICTPROLONGINTERFACE_HH
 
//- Dune includes
#include <dune/common/bartonnackmanifcheck.hh>
#include <dune/grid/common/capabilities.hh>
 
//- local includes
#include <dune/fem/function/localfunction/const.hh>
#include <dune/fem/function/localfunction/mutable.hh>
#include <dune/fem/space/common/localrestrictprolong.hh>
#include <dune/fem/gridpart/common/indexset.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< class Traits >
    class RestrictProlongInterface
    {
      typedef RestrictProlongInterface< Traits > ThisType;
 
    public:
      typedef typename Traits::RestProlImp RestProlImp;
 
      typedef typename Traits::DomainFieldType DomainFieldType;
 
      void initialize ()
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().initialize() );
      }
 
      void finalize ()
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().finalize() );
      }
 
      void setFatherChildWeight ( const DomainFieldType &weight ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().setFatherChildWeight( weight ) );
      }
 
      template< class Entity >
      void restrictLocal ( const Entity &father, const Entity &son, bool initialize ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().restrictLocal( father, son, initialize ) );
      }
 
      template< class Entity, class LocalGeometry >
      void restrictLocal ( const Entity &father, const Entity &son,
                           const LocalGeometry &geometryInFather,
                           bool initialize ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().restrictLocal( father, son, geometryInFather, initialize ) );
      }
 
      template <class Entity>
      void restrictFinalize(const Entity &father) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().restrictFinalize( father ) );
      }
 
      template< class Entity >
      void prolongLocal ( const Entity &father, const Entity &son, bool initialize ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().prolongLocal( father, son, initialize ) );
      }
 
      template< class Entity, class LocalGeometry >
      void prolongLocal ( const Entity &father, const Entity &son,
                          const LocalGeometry &geometryInFather,
                          bool initialize ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().prolongLocal( father, son, geometryInFather, initialize ) );
      }
 
      template< class Communicator >
      void addToList ( Communicator &comm )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().addToList( comm ) );
      }
 
      template< class LoadBalancer >
      void addToLoadBalancer ( LoadBalancer &lb )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().addToLoadBalancer( lb ) );
      }
 
    protected:
      template< class Entity >
      DomainFieldType calcWeight ( const Entity &father, const Entity &son ) const
      {
        const DomainFieldType weight = son.geometry().volume() / father.geometry().volume();
        assert( weight > DomainFieldType( 0 ) );
        return weight;
      }
 
    protected:
      const RestProlImp &asImp () const { return static_cast< const RestProlImp & >( *this ); }
      RestProlImp &asImp () { return static_cast< RestProlImp & >( *this ); }
    };
 
 
    template< class Impl, class DomainField >
    struct RestrictProlongTraits
    {
      typedef Impl RestProlImp;
      typedef DomainField DomainFieldType;
    };
 
 
 
    template< class Traits >
    class RestrictProlongInterfaceDefault
    : public RestrictProlongInterface< Traits >
    {
      typedef RestrictProlongInterfaceDefault< Traits > ThisType;
      typedef RestrictProlongInterface< Traits > BaseType;
 
    public:
      typedef typename BaseType::DomainFieldType DomainFieldType;
 
    protected:
      template< class IndexSet, class Entity >
      bool entitiesAreCopies ( const IndexSet &indexSet,
                               const Entity &father, const Entity &son ) const
      {
        // adaptation and restriction/prolongation only works
        // for index set derived from Dune::Fem::IndexSet
        assert( Capabilities::isDuneFemIndexSet< IndexSet >::v );
        return (indexSet.index( father ) == indexSet.index( son ));
      }
 
 
    public:
      void setFatherChildWeight ( const DomainFieldType &weight ) const {}
 
      void initialize () {}
      void finalize   () {}
 
      template <class Entity>
      void restrictFinalize( const Entity& father ) const {}
    };
 
 
 
    template< class DiscreteFunction >
    class RestrictProlongDefault
    : public RestrictProlongInterfaceDefault< RestrictProlongTraits< RestrictProlongDefault< DiscreteFunction >, typename DiscreteFunction::DomainFieldType > >
    {
      typedef RestrictProlongDefault< DiscreteFunction > ThisType;
      typedef RestrictProlongInterfaceDefault< RestrictProlongTraits< ThisType, typename DiscreteFunction::DomainFieldType > > BaseType;
 
    public:
      typedef DiscreteFunction DiscreteFunctionType;
 
      typedef typename BaseType::DomainFieldType DomainFieldType;
 
      typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
 
      typedef ConstLocalFunction< DiscreteFunctionType > ConstLocalFunctionType;
      typedef MutableLocalFunction< DiscreteFunctionType > MutableLocalFunctionType;
 
      typedef typename DiscreteFunctionType::GridPartType GridPartType;
 
      typedef DefaultLocalRestrictProlong< DiscreteFunctionSpaceType > LocalRestrictProlongType;
 
      RestrictProlongDefault ( const RestrictProlongDefault& other )
        : discreteFunction_( const_cast< RestrictProlongDefault& > (other).discreteFunction_ ),
          constLf_( discreteFunction_ ),
          targetLf_( discreteFunction_ ),
          localRP_( discreteFunction_.space() )
      {
        // enable dof compression for this discrete function
        discreteFunction_.enableDofCompression();
      }
 
      explicit RestrictProlongDefault ( DiscreteFunctionType &discreteFunction )
      : discreteFunction_( discreteFunction ),
        constLf_( discreteFunction ),
        targetLf_( discreteFunction_ ),
        localRP_( discreteFunction_.space() )
      {
        // enable dof compression for this discrete function
        discreteFunction_.enableDofCompression();
      }
 
    protected:
      using BaseType::calcWeight;
      using BaseType::entitiesAreCopies;
 
    public:
      void setFatherChildWeight ( const DomainFieldType &weight ) const
      {
        localRP_.setFatherChildWeight( weight );
      }
 
      template< class Entity >
      void restrictLocal ( const Entity &father, const Entity &son, bool initialize ) const
      {
        assert( !father.isLeaf() );
 
        // convert from grid entities to grid part entities
        typedef typename GridPartType::template Codim< Entity::codimension >::EntityType GridPartEntityType;
        const GridPartType &gridPart = discreteFunction_.gridPart();
        const GridPartEntityType &gpFather = gridPart.convert( father );
        const GridPartEntityType &gpSon    = gridPart.convert( son );
 
        if( !entitiesAreCopies( gridPart.indexSet(), gpFather, gpSon ) )
          restrictLocal( gpFather, gpSon, son.geometryInFather(), initialize );
      }
 
      template< class Entity, class LocalGeometry >
      void restrictLocal ( const Entity &father, const Entity &son,
                           const LocalGeometry &geometryInFather,
                           bool initialize ) const
      {
        auto clf = bindGuard( constLf_, son );
 
        if( initialize || ! targetLf_.valid() )
        {
          targetLf_.bind( father );
          // unbind is done in restrictFinalize
        }
 
        assert( father == targetLf_.entity() );
        localRP_.restrictLocal( targetLf_, constLf_, geometryInFather, initialize );
      }
 
      template <class Entity>
      void restrictFinalize(const Entity &father) const
      {
        // make sure targetLf_ still is bound to father
        assert( discreteFunction_.gridPart().convert( father ) == targetLf_.entity() );
 
        localRP_.restrictFinalize( targetLf_ );
 
        // release target local function
        targetLf_.unbind();
      }
 
 
      template< class Entity >
      void prolongLocal ( const Entity &father, const Entity &son, bool initialize ) const
      {
        assert( !father.isLeaf() );
 
        // convert from grid entities to grid part entities
        typedef typename GridPartType::template Codim< Entity::codimension >::EntityType GridPartEntityType;
        const GridPartType &gridPart = discreteFunction_.gridPart();
        const GridPartEntityType &gpFather = gridPart.convert( father );
        const GridPartEntityType &gpSon    = gridPart.convert( son );
 
        if( !entitiesAreCopies( gridPart.indexSet(), gpFather, gpSon ) )
          prolongLocal( gpFather, gpSon, son.geometryInFather(), initialize );
      }
 
      template< class Entity, class LocalGeometry >
      void prolongLocal ( const Entity &father, const Entity &son,
                          const LocalGeometry &geometryInFather,
                          bool initialize ) const
      {
        // initialize father local function (only once)
        //if( initialize )
        {
          constLf_.unbind();
          constLf_.bind( father );
        }
 
        auto tlf = bindGuard( targetLf_, son );
 
        localRP_.prolongLocal( constLf_, targetLf_, geometryInFather, initialize );
        // write to discrete function
        discreteFunction_.setLocalDofs( son, targetLf_ );
      }
 
      template< class Communicator, class Operation >
      void addToList ( Communicator &comm, const Operation& op)
      {
        if( localRP_.needCommunication() )
          comm.addToList( discreteFunction_, op );
      }
 
      template< class Communicator >
      void addToList ( Communicator &comm  )
      {
        if( localRP_.needCommunication() )
          comm.addToList( discreteFunction_ );
      }
 
      template< class Communicator >
      void removeFromList ( Communicator &comm )
      {
        if( localRP_.needCommunication() )
          comm.removeFromList( discreteFunction_ );
      }
 
      template< class LoadBalancer >
      void addToLoadBalancer ( LoadBalancer& lb )
      {
        lb.addToLoadBalancer( discreteFunction_ );
      }
 
    protected:
      DiscreteFunctionType &discreteFunction_;
      mutable ConstLocalFunctionType   constLf_;
      mutable MutableLocalFunctionType targetLf_;
      mutable LocalRestrictProlongType localRP_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_RESTRICTPROLONGINTERFACE_HH