emptyblockconstraints.hh

Go to the documentation of this file.

 
#ifndef _DUNE_ACFEM_EMPTY_BLOCKCONSTRAINTS_HH_
#define _DUNE_ACFEM_EMPTY_BLOCKCONSTRAINTS_HH_
 
#include "blockconstraintsoperator.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class DiscreteFunction>
    class EmptyBlockConstraints;
 
    template<class DiscreteFunction>
    class LocalEmptyBlockConstraints;
 
    template<class DiscreteFunction>
    struct EmptyBlockConstraintsTraits
      : BlockConstraintsDefaultTraits<EmptyBlockConstraints<DiscreteFunction>,
                                      LocalEmptyBlockConstraints<DiscreteFunction> >
    {};
 
    template<class DiscreteFunction>
    class EmptyBlockConstraints
      : public BlockConstraintsOperatorInterface<DiscreteFunction,
                                                 EmptyBlockConstraintsTraits<DiscreteFunction> >
    {
      typedef EmptyBlockConstraints ThisType;
     public:
      typedef EmptyBlockConstraintsTraits<DiscreteFunction> TraitsType;
      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 {}
      void operator()(const DiscreteFunctionType& arg, DiscreteFunctionType& result) const {}
      void constrain(DiscreteFunctionType& w) const {}
      void zeroConstrain(DiscreteFunctionType& w) const {}
      size_t size() const { return 0; }
 
      LocalOperatorType localOperator(const EntityType& entity) const
      {
        return LocalOperatorType();
      }
 
      LocalOperatorType localOperator() const
      {
        return LocalOperatorType();
      }
 
    };
 
    template<class DiscreteFunction>
    class LocalEmptyBlockConstraints
    {
     protected:
      typedef EmptyBlockConstraints<DiscreteFunction> OperatorType;
      typedef typename OperatorType::EntityType EntityType;
      friend OperatorType;
 
      LocalEmptyBlockConstraints() {}
     public:
      typedef typename OperatorType::DiscreteFunctionType::LocalFunctionType LocalFunctionType;
 
      void init(const EntityType& entity) {}
      void operator()(const LocalFunctionType& u, LocalFunctionType& w) const {}
      void constrain(LocalFunctionType& u) const {}
      void zeroConstrain(LocalFunctionType& u) const {}
      size_t numConstrained() { return 0; }
      bool unconstrained() { return true; }
      bool totallyConstrained() { return false; }
    };
 
 
    template<class JacobianOperator>
    class DifferentiableEmptyBlockConstraints;
 
    template<class JacobianOperator>
    class LocalDifferentiableEmptyBlockConstraints;
 
    template<class JacobianOperator>
    struct DifferentiableEmptyBlockConstraintsTraits
      : public BlockConstraintsDefaultTraits<DifferentiableEmptyBlockConstraints<JacobianOperator>,
                                             LocalDifferentiableEmptyBlockConstraints<JacobianOperator> >
    {};
 
    template<class JacobianOperator>
    class DifferentiableEmptyBlockConstraints
      : public DifferentiableBlockConstraintsOperatorInterface<JacobianOperator,
                                                               DifferentiableEmptyBlockConstraintsTraits<JacobianOperator> >,
        public EmptyBlockConstraints<typename JacobianOperator::RangeFunctionType>
    {
      typedef DifferentiableEmptyBlockConstraints ThisType;
      typedef EmptyBlockConstraints<typename JacobianOperator::DomainFunctionType> BaseType;
     public:
      typedef DifferentiableEmptyBlockConstraintsTraits<JacobianOperator> TraitsType;
      typedef typename BaseType::DiscreteFunctionType DiscreteFunctionType;
      typedef typename TraitsType::LocalOperatorType LocalOperatorType;
      typedef JacobianOperator JacobianOperatorType;
      typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
 
      // using BaseType::operator(); does not work here
 
      //an accept-all constructor that is the default constructor
      template <typename ...Args>
      DifferentiableEmptyBlockConstraints(const Args  & ...){}
 
      void operator()(const DiscreteFunctionType& arg, DiscreteFunctionType& result) const {}
      void jacobian(const DiscreteFunctionType& u, JacobianOperatorType& jOp) const {}
 
      LocalOperatorType localOperator(const EntityType& entity) const
      {
        return LocalOperatorType();
      }
 
      LocalOperatorType localOperator() const
      {
        return LocalOperatorType();
      }
 
      using BaseType::size;
      using BaseType::rebuild;
      using BaseType::constrain;
      using BaseType::zeroConstrain;
    };
 
    template<class JacobianOperator>
    class LocalDifferentiableEmptyBlockConstraints
      : public LocalEmptyBlockConstraints<typename JacobianOperator::DomainFunctionType>
    {
      typedef JacobianOperator JacobianOperatorType;
      typedef LocalEmptyBlockConstraints<typename JacobianOperator::DomainFunctionType> BaseType;
     protected:
      typedef DifferentiableEmptyBlockConstraints<JacobianOperator> OperatorType;
      typedef typename OperatorType::EntityType EntityType;
      friend OperatorType;
 
      LocalDifferentiableEmptyBlockConstraints()
        : BaseType() {}
     public:
      typedef typename OperatorType::DiscreteFunctionType::LocalFunctionType LocalFunctionType;
 
      using BaseType::init;
      using BaseType::operator();
      using BaseType::constrain;
      using BaseType::zeroConstrain;
 
      template<class LocalMatrix>
      void jacobian(const LocalFunctionType& u /* unused */, LocalMatrix& jOpLocal) const {}
    };
 
 
 
  } // ACFem::
 
} // Dune::
 
 
#endif // _DUNE_ACFEM_EMPTY_BLOCKCONSTRAINTS_HH_