restrictprolongtuple.hh

Go to the documentation of this file.

 
#ifndef __DUNE_ACFEM_RESTRICT_PROLONG_TUPLE_HH__
#define __DUNE_ACFEM_RESTRICT_PROLONG_TUPLE_HH__
 
#if HAVE_DUNE_FEM_SPACE_COMMON_RESTRICTPROLONGTUPLE_HH
 
# include <dune/fem/space/common/restrictprolongtuple.hh>
 
namespace Dune {
 
  namespace ACFem {
    // ? does this work ?
    using Fem::makeRestrictProlongDefault;
    using Fem::RestrictProlongDefaultTraits;
 
#warning Using <dune/acfem/operators/restrictprolongtuple.hh> is deprecated, redirecting to <dune/fem/space/common/restrictprolongtuple.hh>
  }
}
 
#else
 
#include <dune/fem/space/common/restrictprolonginterface.hh>
#include <dune/fem/function/common/function.hh>
#include <dune/common/tuples.hh>
 
namespace Dune {
 
  namespace ACFem {
 
    template<class RP1, class RP2>
    class RestrictProlongPair
      : public Fem::RestrictProlongInterface<
      Fem::RestrictProlongTraits<RestrictProlongPair<RP1, RP2>,
                                       typename RP1::DomainFieldType> >,
        public std::pair<RP1, RP2>
    {
      typedef std::pair<RP1, RP2> StorageType;
      typedef Fem::RestrictProlongInterface<
        Fem::RestrictProlongTraits<RestrictProlongPair<RP1, RP2>,
                                         typename RP1::DomainFieldType> >
      InterfaceType;
 
      using StorageType::first;
      using StorageType::second;
 
     public:
      typedef typename RP1::DomainFieldType DomainFieldType; // do we really need to check that ...
 
      RestrictProlongPair(const RP1& rp1, const RP2& rp2)
        : StorageType(rp1, rp2)
      {}
 
      void setFatherChildWeight(const DomainFieldType &weight) const {
        first.setFatherChildWeight(weight);
        second.setFatherChildWeight(weight);
      }
 
      template<class Entity>
      void restrictLocal(const Entity &father, const Entity &son, bool initialize) const {
        first.restrictLocal(father, son, initialize);
        second.restrictLocal(father, son, initialize);
      }
 
      template<class Entity, class LocalGeometry>
      void restrictLocal(const Entity &father, const Entity &son,
                         const LocalGeometry &geometryInFather,
                         bool initialize) const {
        first.restrictLocal(father, son, geometryInFather, initialize);
        second.restrictLocal(father, son, geometryInFather, initialize);
      }
 
      template<class Entity>
      void prolongLocal(const Entity &father, const Entity &son, bool initialize) const {
        first.prolongLocal(father, son, initialize);
        second.prolongLocal(father, son, initialize);
      }
 
      template<class Entity, class LocalGeometry>
      void prolongLocal(const Entity &father, const Entity &son,
                        const LocalGeometry &geometryInFather,
                        bool initialize) const {
        first.prolongLocal(father, son, geometryInFather, initialize);
        second.prolongLocal(father, son, geometryInFather, initialize);
      }
 
      template<class Communicator>
      void addToList(Communicator &comm) {
        first.addToList(comm);
        second.addToList(comm);
      }
 
      template<class LoadBalancer>
      void addToLoadBalancer(LoadBalancer &lb) {
        first.addToLoadBalancer(lb);
        second.addToLoadBalancer(lb);
      }
    };
 
    template<class DiscreteFunction, class... Rest>
    struct RestrictProlongDefaultTraits
    {
      typedef DiscreteFunction FirstDiscreteFunctionType;
      typedef Fem::RestrictProlongDefault<FirstDiscreteFunctionType> FirstRestrictProlongType;
      typedef RestrictProlongPair<FirstRestrictProlongType, typename RestrictProlongDefaultTraits<Rest...>::Type> Type;
    };
 
    template<class DiscreteFunction>
    struct RestrictProlongDefaultTraits<DiscreteFunction>
    {
      typedef DiscreteFunction FirstDiscreteFunctionType;
      typedef Fem::RestrictProlongDefault<FirstDiscreteFunctionType> FirstRestrictProlongType;
      typedef FirstRestrictProlongType Type;
    };
 
    template<class DF>
    static inline
    Fem::RestrictProlongDefault<DF>
    makeRestrictProlongDefault(Fem::Function<typename DF::FunctionSpaceType, DF>& df_)
    {
      DF& df(static_cast<DF&>(df_));
 
      return Fem::RestrictProlongDefault<DF>(df);
    }
 
    template<class DF1, class DF2, class... Rest>
    static inline
    typename RestrictProlongDefaultTraits<DF1, DF2, Rest...>::Type
    makeRestrictProlongDefault(DF1& df1, DF2& df2, Rest&... rest)
    {
      typedef typename RestrictProlongDefaultTraits<DF1, DF2, Rest...>::Type ResultType;
 
      return ResultType(makeRestrictProlongDefault(df1), makeRestrictProlongDefault(df2, rest...));
    }
 
    template<class Tuple, class Index = std::integral_constant<size_t, 0> >
    struct RestrictProlongDefaultTupleHelper
    {
      enum { index = Index::value };
      typedef std::integral_constant<size_t, index+1> NextIndexType;
      typedef typename remove_reference<typename tuple_element<index, Tuple>::type>::type DiscreteFunctionType;
      typedef Fem::RestrictProlongDefault<DiscreteFunctionType> RestrictProlongType;
      typedef RestrictProlongDefaultTupleHelper<Tuple, NextIndexType> NextHelperType;
      typedef RestrictProlongPair<RestrictProlongType, typename NextHelperType::Type> Type;
 
      static Type construct(const Tuple& arg)
      {
        return Type(RestrictProlongType(get<index>(arg)), NextHelperType::construct(arg));
      }
    };
 
    template<class Tuple>
    struct RestrictProlongDefaultTupleHelper<Tuple, std::integral_constant<size_t, std::tuple_size<Tuple>::value-1> >
    {
      enum { index = tuple_size<Tuple>::value - 1 };
      typedef typename remove_reference<typename tuple_element<index, Tuple>::type>::type DiscreteFunctionType;
      typedef Fem::RestrictProlongDefault<DiscreteFunctionType> RestrictProlongType;
      typedef RestrictProlongType Type;
 
      static Type construct(const Tuple& arg)
      {
        return Type(get<index>(arg));
      }
    };
 
    template<class... Args>
    struct RestrictProlongDefaultTraits<tuple<Args...> >
    {
      typedef
      typename RestrictProlongDefaultTupleHelper<tuple<Args...> >::Type
      Type;
    };
 
    template<class... Rest>
    static inline
    typename RestrictProlongDefaultTraits<Rest...>::Type
    makeRestrictProlongDefault(const tuple<Rest&...>& arg)
    {
      typedef tuple<Rest&...> TupleType;
      return RestrictProlongDefaultTupleHelper<TupleType>::construct(arg);
    }
 
 
 
  } // ACFem
 
} // Dune
 
#endif // HAVE_DUNE_FEM_SPACE_COMMON_RESTRICTPROLONGTUPLE_HH
 
#endif // __DUNE_ACFEM_RESTRICT_PROLONG_TUPLE_HH__