blockvectordiscretefunction.hh

#ifndef DUNE_FEM_BLOCKVECTORDISCRETEFUNCTION_HH
#define DUNE_FEM_BLOCKVECTORDISCRETEFUNCTION_HH
 
#include <memory>
#include <string>
#include <utility>
 
#include <dune/fem/common/stackallocator.hh>
#include <dune/fem/function/common/discretefunction.hh>
#include <dune/fem/function/common/scalarproducts.hh>
#include <dune/fem/function/localfunction/mutable.hh>
#include <dune/fem/function/blockvectors/referenceblockvector.hh>
#include <dune/fem/storage/envelope.hh>
 
namespace Dune
{
  namespace Fem
  {
 
    template< typename DiscreteFunctionSpace, typename BlockVector >
    class BlockVectorDiscreteFunction;
 
 
 
    struct IsBlockVectorDiscreteFunction {};
 
 
 
    template< typename DiscreteFunctionSpace, typename BlockVector >
    struct DiscreteFunctionTraits< BlockVectorDiscreteFunction< DiscreteFunctionSpace, BlockVector > >
      : public DefaultDiscreteFunctionTraits< DiscreteFunctionSpace, BlockVector >
    {
      typedef BlockVectorDiscreteFunction< DiscreteFunctionSpace, BlockVector >   DiscreteFunctionType;
      typedef MutableLocalFunction< DiscreteFunctionType > LocalFunctionType;
    };
 
 
 
 
    template< typename DiscreteFunctionSpace, typename BlockVector >
    class BlockVectorDiscreteFunction
      : public DiscreteFunctionDefault< BlockVectorDiscreteFunction< DiscreteFunctionSpace, BlockVector > >,
        public IsBlockVectorDiscreteFunction
    {
      typedef BlockVectorDiscreteFunction< DiscreteFunctionSpace, BlockVector > ThisType;
      typedef DiscreteFunctionDefault< ThisType > BaseType;
      typedef ParallelScalarProduct< ThisType > ScalarProductType;
 
    public:
      typedef DiscreteFunctionSpace DiscreteFunctionSpaceType;
      typedef BlockVector BlockVectorType;
      typedef BlockVectorType DofVectorType;
 
      using BaseType::assign;
      using BaseType::name;
 
      BlockVectorDiscreteFunction ( const std::string& name,
                                    const DiscreteFunctionSpaceType& space,
                                    DofVectorType& dofVector )
        : BaseType( name, space ),
          memObject_(),
          dofVector_( dofVector )
      {}
 
      BlockVectorDiscreteFunction ( const std::string& name,
                                    const DiscreteFunctionSpaceType& space )
        : BaseType( name, space ),
          memObject_(),
          dofVector_( allocateDofStorage( space ) )
      {}
 
      BlockVectorDiscreteFunction ( const ThisType& other )
        : BaseType( "copy of "+other.name(), other.space() ),
          memObject_(),
          dofVector_( allocateDofStorage( other.space() ) )
      {
        assign( other );
      }
 
      BlockVectorDiscreteFunction( ThisType&& other )
        : BaseType( static_cast< BaseType && >( other ) ),
          memObject_( std::move( other.memObject_ ) ),
          dofVector_( other.dofVector_ )
      {}
 
      BlockVectorDiscreteFunction () = delete;
      ThisType& operator= ( const ThisType& ) = delete;
      ThisType& operator= ( ThisType&& ) = delete;
 
      const DofVectorType &dofVector () const
      {
        return dofVector_;
      }
 
      DofVectorType &dofVector ()
      {
        return dofVector_;
      }
 
      void enableDofCompression ()
      {
        if( memObject_ )
          memObject_->enableDofCompression();
      }
 
    protected:
      DofVectorType& allocateDofStorage( const DiscreteFunctionSpaceType& space )
      {
        std::pair< DofStorageInterface*, DofVectorType* > memPair(
          allocateManagedDofStorage< DofVectorType >( space.gridPart().grid(), space.blockMapper() ) );
 
        memObject_.reset( memPair.first );
        return *memPair.second;
      }
 
      std::unique_ptr< DofStorageInterface > memObject_;
      DofVectorType& dofVector_;
    };
 
  } // namespace Fem
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_BLOCKVECTORDISCRETEFUNCTION_HH