blockconstraintsoperator.hh

#ifndef _DUNE_ACFEM_BLOCKCONSTRAINTSOPERATORINTERFACE_HH_
#define _DUNE_ACFEM_BLOCKCONSTRAINTSOPERATORINTERFACE_HH_
 
#include <dune/fem/operator/common/differentiableoperator.hh>
#include <dune/fem/misc/bartonnackmaninterface.hh>
 
#include "../../common/localobjectstorage.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    // Forward
    template<class LocalObjectStorage>
    class LocalBlockConstraintsWrapper;
 
    template<class GlobalOperator, class LocalOperator>
    struct BlockConstraintsDefaultTraits
    {
      typedef GlobalOperator GlobalOperatorType;
      typedef LocalOperator LocalOperatorType;
    };
 
    template<class GlobalOperator, class LocalOperator>
    struct BlockConstraintsDefaultStorageTraits
      : public BlockConstraintsDefaultTraits<GlobalOperator, LocalOperator>
    {
      typedef GlobalOperator GlobalObjectType;
      typedef LocalOperator LocalObjectType;
      typedef LocalObjectFactory<GlobalObjectType, LocalObjectType> LocalObjectFactoryType;
      typedef
      LocalObjectStack<LocalObjectFactoryType, LocalBlockConstraintsWrapper>
      LocalObjectStorageType;
      typedef typename LocalObjectStorageType::LocalWrapperType LocalObjectWrapperType;
 
      typedef GlobalObjectType GlobalOperatorType;
      typedef LocalObjectWrapperType LocalOperatorType;
    };
 
    template<class DiscreteFunction, class Traits>
    class BlockConstraintsOperatorInterface
      : public Fem::BartonNackmanInterface<BlockConstraintsOperatorInterface<DiscreteFunction, Traits>,
                                           typename Traits::GlobalOperatorType>,
        public Fem::LinearOperator<DiscreteFunction>
    {
      typedef BlockConstraintsOperatorInterface ThisType;
      typedef Traits TraitsType;
      typedef typename TraitsType::GlobalOperatorType ImplementationType;
      typedef Fem::BartonNackmanInterface<ThisType, ImplementationType> BaseType;
     protected:
      using BaseType::asImp;
     protected:
      BlockConstraintsOperatorInterface() {}
      BlockConstraintsOperatorInterface(const ThisType& other) {}
      ThisType& operator=(const ThisType& Other) {}
     public:
      typedef DiscreteFunction DiscreteFunctionType;
      typedef typename TraitsType::LocalOperatorType LocalOperatorType;
      typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
 
      void rebuild() const {
        asImp().rebuild();
      }
 
      void operator()(const DiscreteFunctionType& arg, DiscreteFunctionType& w) const
      {
        asImp()(arg, w);
      }
 
      void constrain(DiscreteFunctionType& w) const
      {
        return asImp().constrain(w);
      }
 
      void zeroConstrain(DiscreteFunctionType& w) const
      {
        return asImp().zeroConstrain(w);
      }
 
      size_t size() const
      {
        return asImp().size();
      }
 
      LocalOperatorType localOperator(const EntityType& entity) const
      {
        return asImp().localOperator(entity);
      }
 
      LocalOperatorType localOperator() const
      {
        return asImp().localOperator();
      }
 
    };
 
    template<class JacobianOperator, class Traits>
    class DifferentiableBlockConstraintsOperatorInterface
      : public BlockConstraintsOperatorInterface<typename JacobianOperator::RangeFunctionType, Traits>,
        public Fem::DifferentiableOperator<JacobianOperator>,
        public Fem::AssembledOperator<typename JacobianOperator::DomainFunctionType>
    {
      typedef DifferentiableBlockConstraintsOperatorInterface ThisType;
      typedef Traits TraitsType;
      typedef typename TraitsType::GlobalOperatorType ImplementationType;
      typedef
      BlockConstraintsOperatorInterface<typename JacobianOperator::DomainFunctionType, Traits>
      BaseType;
     protected:
      using BaseType::asImp;
     protected:
      DifferentiableBlockConstraintsOperatorInterface() {}
      DifferentiableBlockConstraintsOperatorInterface(const ThisType& other) {}
      ThisType& operator=(const ThisType& Other) {}
     public:
      typedef JacobianOperator JacobianOperatorType;
      typedef typename BaseType::DiscreteFunctionType DiscreteFunctionType;
      typedef typename TraitsType::LocalOperatorType LocalOperatorType;
      typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
 
      // DifferentiableOperator interface
 
      void jacobian(const DiscreteFunctionType& u, JacobianOperatorType& jOp) const
      {
        asImp().jacobian(u, jOp);
      }
 
      using BaseType::operator();
      using BaseType::size;
      using BaseType::rebuild;
      using BaseType::constrain;
      using BaseType::zeroConstrain;
      using BaseType::localOperator;
    };
 
    template<class LocalObjectStorage>
    class LocalBlockConstraintsWrapper
    {
     protected:
      typedef LocalObjectStorage LocalObjectStorageType;
      typedef typename LocalObjectStorageType::LocalObjectType LocalObjectType;
      typedef typename LocalObjectStorageType::GlobalObjectType GlobalObjectType;
      typedef typename LocalObjectStorageType::PointerType LocalObjectPtrType;
      friend GlobalObjectType;
 
     public:
      typedef typename LocalObjectType::LocalFunctionType LocalFunctionType;
      typedef typename LocalObjectType::EntityType EntityType;
 
     protected:
 
      LocalObjectPtrType localObjectPtr_;
      LocalObjectType& localObject_;
 
     public:
      // public is questionable, but makes things easier for inheriting from
      // default implementations.
 
      LocalBlockConstraintsWrapper(LocalObjectStorageType& storage)
        : localObjectPtr_(storage.getObject()),
          localObject_(*localObjectPtr_)
      {}
 
      LocalBlockConstraintsWrapper(const EntityType& entity,
                                   LocalObjectStorageType& storage)
        : localObjectPtr_(storage.getObject()),
          localObject_(*localObjectPtr_)
      {
        asImp().init(entity);
      }
 
     public:
      void operator()(const LocalFunctionType& u, LocalFunctionType& w) const
      {
        asImp()(u, w);
      }
 
      template<class LocalMatrix>
      void jacobian(const LocalFunctionType& u /* unused */, LocalMatrix& jOpLocal) const
      {
        asImp().jacobian(u, jOpLocal);
      }
 
      void init(const EntityType& entity)
      {
        asImp().init(entity);
      }
 
      size_t numConstrained() const
      {
        return asImp().numConstrained();
      }
 
      bool unconstrained() const
      {
        return asImp().unconstrained();
      }
 
      bool totallyConstrained() const
      {
        return asImp().totallyConstrained();
      }
 
      void constrain(LocalFunctionType& w) const
      {
        asImp().constrain(w);
      }
 
      void zeroConstrain(LocalFunctionType& w) const
      {
        asImp().zeroConstrain(w);
      }
 
     protected:
      const LocalObjectType& asImp() const
      {
        return localObject_;
      }
 
      LocalObjectType& asImp()
      {
        return localObject_;
      }
    };
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif // _DUNE_ACFEM_BLOCKCONSTRAINTSOPERATORINTERFACE_HH_