zerofunctional.hh

#ifndef __DUNE_ACFEM_ZERO_FUNCTIONAL_HH__
#define __DUNE_ACFEM_ZERO_FUNCTIONAL_HH__
 
#include "functionalexpressionbase.hh"
 
namespace Dune {
 
  namespace ACFem {
 
// #define FUNCTIONAL_TESTING 1
 
    template<class DiscreteFunctionSpace>
    class ZeroFunctional;
 
    template<class DiscreteFunctionSpace>
    class LocalZeroFunctional;
 
    template<class DiscreteFunctionSpace>
    struct ZeroFunctionalTraits
      : public LinearFunctionalTraitsDefault<ZeroFunctional<DiscreteFunctionSpace>,
                                             LocalZeroFunctional<DiscreteFunctionSpace> >
    {};
 
    template<class DiscreteFunctionSpace>
    class ZeroFunctional
      : public ZeroFunctionalExpression<DiscreteFunctionSpace,
                                        ZeroFunctionalTraits<DiscreteFunctionSpace> >
    {
     public:
      typedef ZeroFunctionalTraits<DiscreteFunctionSpace> TraitsType;
     private:
      typedef ZeroFunctional ThisType;
      typedef ZeroFunctionalExpression<DiscreteFunctionSpace, TraitsType> BaseType;
     public:
      typedef typename TraitsType::LocalFunctionalType LocalFunctionalType;
      typedef DiscreteFunctionSpace DiscreteFunctionSpaceType;
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
      typedef typename DiscreteFunctionSpace::FunctionSpaceType FunctionSpaceType;
      typedef typename FunctionSpaceType::RangeFieldType FieldType;
      typedef FieldType RangeType;
 
      ZeroFunctional(const DiscreteFunctionSpaceType& space)
        : BaseType(space)
      {}
 
#if !FUNCTIONAL_TESTING
      template<class DFTraits>
      RangeType operator()(const Fem::DiscreteFunctionInterface<DFTraits>& arg) const
      {
        static_assert(std::is_same<DiscreteFunctionSpaceType, typename DFTraits::DiscreteFunctionSpaceType>::value,
                      "Invalid Argument");
        return 0;
      }
 
      template<class DFTraits>
      void coefficients(Fem::DiscreteFunctionInterface<DFTraits>& coeffs)
      {
        static_assert(std::is_same<DiscreteFunctionSpaceType, typename DFTraits::DiscreteFunctionSpaceType>::value,
                      "Invalid Argument");
        coeffs.clear();
      }
#else
      using BaseType::operator();
      using BaseType::coefficients;
#endif
      using BaseType::localFunctional;
 
      std::string name() const
      {
        return "<0,...>";
      }
    };
 
    template<class DiscreteFunctionSpace>
    class LocalZeroFunctional
      : public LocalLinearFunctionalDefault<DiscreteFunctionSpace,
                                            ZeroFunctionalTraits<DiscreteFunctionSpace> >
    {
      typedef LocalZeroFunctional ThisType;
      typedef ZeroFunctional<DiscreteFunctionSpace> FunctionalType;
      typedef
      LocalLinearFunctionalDefault<DiscreteFunctionSpace,
                                   ZeroFunctionalTraits<DiscreteFunctionSpace> >
      BaseType;
      friend FunctionalType;
     public:
      typedef DiscreteFunctionSpace DiscreteFunctionSpaceType;
      //typedef typename DiscreteFunctionType::LocalFunctionType LocalFunctionType;
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
      //typedef LocalFunctionType LocalDomainFunctionType;
      typedef typename DiscreteFunctionSpaceType::RangeFieldType FieldType;
      typedef FieldType RangeType;
 
     public:
      LocalZeroFunctional(const FunctionalType& zero)
        : BaseType(zero)
      {}
 
      LocalZeroFunctional(const EntityType& entity, const FunctionalType& zero)
        : BaseType(entity, zero)
      {}
 
      template<class LocalFunction>
      RangeType operator()(const LocalFunction& arg) const
      {
        return 0;
      }
 
      template<class LocalFunction>
      void coefficients(const RangeType& c, LocalFunction& coeffs) const
      {
        // nothing
      }
 
      template<class LocalFunction>
      void coefficients(LocalFunction& coeffs)
      {
        // nothing;
      }
 
      using BaseType::functional;
      using BaseType::entity;
 
     protected:
      using BaseType::entity_;
    };
 
 
 
  } // namespace ACFem
 
} // namespace Dune
 
#endif // __DUNE_ACFEM_ZERO_FUNCTIONAL_HH__