linearfunctional.hh

#ifndef _DUNE_ACFEM_DISCRETELINEARFUNCTIONAL_HH_
#define _DUNE_ACFEM_DISCRETELINEARFUNCTIONAL_HH_
 
#include <dune/fem/misc/bartonnackmaninterface.hh>
#include <dune/fem/function/common/discretefunction.hh>
#include <dune/fem/function/localfunction/temporary.hh>
 
#include "../../common/localobjectstorage.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class GlobalFunctional, class LocalFunctional>
    struct LinearFunctionalTraitsDefault
    {
      typedef GlobalFunctional GlobalFunctionalType;
      typedef LocalFunctional  LocalFunctionalType;
    };
 
    template<class DiscreteFunctionSpace, class Traits>
    class DiscreteLinearFunctional
      : public Fem::BartonNackmanInterface<DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>,
                                           typename Traits::GlobalFunctionalType>
    {
      typedef DiscreteLinearFunctional ThisType;
      typedef
      Fem::BartonNackmanInterface<DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>,
                                  typename Traits::GlobalFunctionalType>
      BaseType;
     public:
      typedef Traits TraitsType;
      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;
     protected:
      using BaseType::asImp;
 
      DiscreteLinearFunctional()
      {}
 
      DiscreteLinearFunctional(const ThisType& other)
      {}
 
     private:
      ThisType& operator=(const ThisType& other);
 
     public:
      template<class DFImpl>
      RangeType operator()(const Fem::DiscreteFunctionInterface<DFImpl>& arg) const
      {
        static_assert(std::is_same<DiscreteFunctionSpaceType, typename DFImpl::DiscreteFunctionSpaceType>::value,
                      "Invalid Argument");
        CHECK_INTERFACE_IMPLEMENTATION(asImp()(arg));
        return asImp()(arg);
      }
 
      template<class DFImpl>
      void coefficients(Fem::DiscreteFunctionInterface<DFImpl>& coeffs)
      {
        static_assert(std::is_same<DiscreteFunctionSpaceType, typename DFImpl::DiscreteFunctionSpaceType>::value,
                      "Invalid Argument");
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION(asImp().coefficients(coeffs));
      }
 
      const DiscreteFunctionSpaceType& space() const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().space());
        return asImp().space();
      }
 
      LocalFunctionalType localFunctional(const EntityType& entity)
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().localFunctional(entity));
        return asImp().localFunctional(entity);
      }
 
      const LocalFunctionalType localFunctional(const EntityType& entity) const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().localFunctional(entity));
        return asImp().localFunctional(entity);
      }
 
      std::string name() const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().name());
        return asImp().name();
      }
    };
 
    template<class DiscreteFunctionSpace, class Traits>
    class DiscreteLinearFunctionalDefault
      : public DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>
    {
      typedef DiscreteLinearFunctionalDefault ThisType;
      typedef DiscreteLinearFunctional<DiscreteFunctionSpace, Traits> BaseType;
     public:
      typedef Traits TraitsType;
      typedef typename TraitsType::LocalFunctionalType LocalFunctionalType;
      typedef typename TraitsType::GlobalFunctionalType GlobalFunctionalType;
      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;
 
     protected:
      using BaseType::asImp;
 
      DiscreteLinearFunctionalDefault(const DiscreteFunctionSpaceType& space)
        : space_(space)
      {}
 
      DiscreteLinearFunctionalDefault(const ThisType& other)
        : space_(other.space_)
      {}
 
      ThisType& operator=(const ThisType& other) = delete;
 
     public:
      template<class DFTraits>
      RangeType operator()(const Fem::DiscreteFunctionInterface<DFTraits>& arg) const
      {
        static_assert(std::is_same<DiscreteFunctionSpaceType, typename DFTraits::DiscreteFunctionSpaceType>::value,
                      "Invalid Argument");
 
        typedef typename Fem::DiscreteFunctionInterface<DFTraits> DiscreteFunctionType;
        typedef typename DiscreteFunctionType::LocalFunctionType LocalFunctionType;
 
        // get discrete function space
        const auto& dfSpace = arg.space();
 
        auto localPhi = asImp().localFunctional();
        LocalFunctionType localArg(ACFem::asImp(arg));
 
        RangeType value = 0;
        auto end = dfSpace.end();
        for (auto it = dfSpace.begin(); it != end; ++it) {
          // get entity (here element)
          const auto &entity = *it;
          localPhi.init(entity);
          localArg.init(entity);
 
          value += localPhi(localArg);
        }
        return value;
      }
 
      template<class DFTraits>
      void coefficients(Fem::DiscreteFunctionInterface<DFTraits>& coeffs)
      {
        static_assert(std::is_same<DiscreteFunctionSpaceType, typename DFTraits::DiscreteFunctionSpaceType>::value,
                      "Invalid Argument");
 
        typedef typename Fem::DiscreteFunctionInterface<DFTraits> DiscreteFunctionType;
        typedef typename DiscreteFunctionType::LocalFunctionType LocalFunctionType;
 
        // get discrete function space
        const auto& dfSpace = coeffs.space();
 
        auto localPhi = asImp().localFunctional();
        LocalFunctionType localCoeffs(ACFem::asImp(coeffs));
 
        coeffs.clear();
        auto end = dfSpace.end();
        for (auto it = dfSpace.begin(); it != end; ++it) {
          // get entity (here element)
          const auto &entity = *it;
 
          localPhi.init(entity);
          localCoeffs.init(entity);
 
          localPhi.coefficients(localCoeffs);
        }
        coeffs.communicate();
      }
 
      const DiscreteFunctionSpaceType& space() const
      {
        return space_;
      }
 
      LocalFunctionalType localFunctional()
      {
        return LocalFunctionalType(asImp());
      }
 
      const LocalFunctionalType localFunctional() const
      {
        return LocalFunctionalType(asImp());
      }
 
      LocalFunctionalType localFunctional(const EntityType& entity)
      {
        return LocalFunctionalType(entity, asImp());
      }
 
      const LocalFunctionalType localFunctional(const EntityType& entity) const
      {
        return LocalFunctionalType(entity, asImp());
      }
 
      std::string name() const
      {
        return "Functional";
      }
 
     protected:
      const DiscreteFunctionSpaceType& space_;
    };
 
    template<class DiscreteFunctionSpace, class Traits>
    class LocalLinearFunctional
      : public Fem::BartonNackmanInterface<LocalLinearFunctional<DiscreteFunctionSpace, Traits>,
                                           typename Traits::LocalFunctionalType>
    {
      typedef LocalLinearFunctional ThisType;
      typedef
      Fem::BartonNackmanInterface<ThisType, typename Traits::LocalFunctionalType>
      BaseType;
     public:
      typedef Traits TraitsType;
      typedef typename TraitsType::GlobalFunctionalType FunctionalType;
      typedef ThisType LocalFunctionalType;
 
      typedef DiscreteFunctionSpace DiscreteFunctionSpaceType;
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
      typedef typename DiscreteFunctionSpace::FunctionSpaceType FunctionSpaceType;
      typedef typename FunctionSpaceType::RangeFieldType FieldType;
      typedef FieldType RangeType;
     protected:
      using BaseType::asImp;
 
      LocalLinearFunctional()
      {}
 
      LocalLinearFunctional(const ThisType& other)
      {}
 
     private:
      ThisType& operator=(const ThisType& other) = delete;
      ThisType& operator=(ThisType&& other) = delete;
 
     public:
      void init(const EntityType& entity)
      {
        asImp().init(entity);
      }
 
      // TODO: rather use
      //
      // template<Traits>
      // void stuff(const LocalFunction<Traits>)
      //
      // in order to enforce the
      // LocalFunctionInterface her.
 
      template<class LocalFunction>
      RangeType operator()(const LocalFunction& arg) const
      {
        return asImp()(arg);
      }
 
      template<class LocalFunction>
      void coefficients(LocalFunction& coeffs) const
      {
        asImp().coefficients(coeffs);
      }
 
      template<class LocalFunction>
      void coefficients(const RangeType& c, LocalFunction& coeffs) const
      {
        asImp().coefficients(c, coeffs);
      }
 
      const FunctionalType& functional() const
      {
        return asImp().functional();
      }
 
      const EntityType& entity() const
      {
        return asImp().entity();
      }
    };
 
    template<class DiscreteFunctionSpace, class Traits>
    class LocalLinearFunctionalDefault
      : public LocalLinearFunctional<DiscreteFunctionSpace, Traits>
    {
      typedef LocalLinearFunctionalDefault ThisType;
      typedef LocalLinearFunctional<DiscreteFunctionSpace, Traits> BaseType;
     public:
      typedef Traits TraitsType;
      typedef typename TraitsType::GlobalFunctionalType FunctionalType;
      typedef DiscreteFunctionSpace DiscreteFunctionSpaceType;
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
      typedef typename DiscreteFunctionSpace::FunctionSpaceType FunctionSpaceType;
      typedef typename FunctionSpaceType::RangeFieldType FieldType;
      typedef FieldType RangeType;
     protected:
      typedef Fem::TemporaryLocalFunction<DiscreteFunctionSpaceType, FieldType> TemporaryCoefficientsType;
      friend DiscreteLinearFunctionalDefault<DiscreteFunctionSpaceType, TraitsType>;
      using BaseType::asImp;
 
      LocalLinearFunctionalDefault(const FunctionalType& functional)
        : entity_(0),
          functional_(functional),
          localCoeffs_(functional_.space())
      {}
 
      LocalLinearFunctionalDefault(const EntityType& entity,
                                   const FunctionalType& functional)
        : entity_(&entity),
          functional_(functional),
          localCoeffs_(functional_.space())
      {}
 
      LocalLinearFunctionalDefault(const ThisType& other)
        : entity_(other.entity_),
          functional_(other.functional_),
          localCoeffs_(functional_.space())
      {}
 
     private:
      ThisType& operator=(const ThisType& other) = delete;
      ThisType& operator=(ThisType&& other) = delete;
 
     public:
      void init(const EntityType& entity)
      {
        entity_ = &entity;
      }
 
      template<class LocalFunction>
      RangeType operator()(const LocalFunction& arg) const
      {
        typedef LocalFunction LocalDomainFunctionType;
 
        localCoeffs_.init(entity());
        localCoeffs_.clear();
        asImp().coefficients(FieldType(1.0), localCoeffs_);
        RangeType result = 0;
        for (unsigned i = 0; i < arg.size(); ++i) {
          result += arg[i] * localCoeffs_[i];
        }
        return result;
      }
 
      const FunctionalType& functional() const
      {
        return functional_;
      }
 
      const EntityType& entity() const
      {
        return *entity_;
      }
 
      template<class LocalFunction>
      void coefficients(LocalFunction& coeffs) const
      {
        asImp().coefficients(FieldType(1.0), coeffs);
      }
 
      template<class LocalFunction>
      void coefficients(const RangeType& c, LocalFunction& coeffs) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION(asImp().coefficients(c, coeffs));
      }
     protected:
      const EntityType* entity_;
      const FunctionalType& functional_;
      mutable TemporaryCoefficientsType localCoeffs_;
    };
 
 
 
  } // namespace ACFem
 
} // namespace Dune
 
 
 
#endif // _DUNE_ACFEM_DISCRETELINEARFUNCTIONAL_HH_