boundaryindicator.hh

#ifndef __DUNE_ACFEM_BOUNDARY_CONSTRAINTS_HH__
#define __DUNE_ACFEM_BOUNDARY_CONSTRAINTS_HH__
 
#include <dune/fem/misc/bartonnackmaninterface.hh>
 
#include "../expressions/expressionoperations.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class Implementation>
    class BoundaryIndicatorInterface
      : public Dune::Fem::BartonNackmanInterface<BoundaryIndicatorInterface<Implementation>,
                                                 Implementation>
    {
      typedef Implementation ImplementationType;
      typedef BoundaryIndicatorInterface ThisType;
      typedef Dune::Fem::BartonNackmanInterface<ThisType, ImplementationType> BaseType;
      using BaseType::asImp;
     protected:
      BoundaryIndicatorInterface() {}
      BoundaryIndicatorInterface(const BoundaryIndicatorInterface& other) {}
      BoundaryIndicatorInterface& operator=(const BoundaryIndicatorInterface& other) { return *this; }
     public:
      template<class Intersection>
      bool applies(const Intersection &intersection) const
      {
        return asImp().applies(intersection);
      }
    };
 
    template<class Implementation>
    struct DefaultBoundaryIndicator
      : public BoundaryIndicatorInterface<Implementation>
    {
      typedef DefaultBoundaryIndicator ThisType;
     protected:
      DefaultBoundaryIndicator() {}
      DefaultBoundaryIndicator(const ThisType& other) {}
      ThisType& operator=(const ThisType& other) { return *this; }
     public:
      template<class Intersection>
      bool applies(const Intersection &intersection) const
      {
        return false;
      }
    };
 
    template<class Implementation, template<class> class ExpressionTag = ExpressionTemplate>
    struct BoundaryIndicatorExpression
      : public DefaultBoundaryIndicator<Implementation>,
        public ExpressionTag<Implementation>
    {
      typedef BoundaryIndicatorExpression ThisType;
     protected:
      BoundaryIndicatorExpression() {}
      BoundaryIndicatorExpression(const ThisType& other) {}
      ThisType& operator=(const ThisType& other) { return *this; }
     public:
    };
 
 
    template<class Intersection>
    bool isDomainBoundary(const Intersection& intersection)
    {
      return !intersection.neighbor() && intersection.boundary();
    }
 
    template<class Intersection>
    bool isPeriodicBoundary(const Intersection& intersection)
    {
      return intersection.neighbor() && intersection.boundary();
    }
 
    template<class Intersection>
    bool isProcessorBoundary(const Intersection& intersection)
    {
      if (intersection.neighbor()) {
        return intersection.outside().partitionType() == GhostEntity;
      } else {
        return !intersection.boundary();
      }
    }
 
    template<class Intersection>
    bool isInterior(const Intersection& intersection)
    {
      return intersection.neighbor();
    }
 
    template<bool answer = true>
    struct ConstantBoundaryIndicator;
 
    template<>
    struct ConstantBoundaryIndicator<true>
      : public BoundaryIndicatorExpression<ConstantBoundaryIndicator<true>, NonZeroExpression>
    {
     private:
      enum { answer = true };
     public:
 
      template<class Intersection>
      bool applies(const Intersection &intersection) const
      {
        return answer;
      }
    };
 
    template<>
    struct ConstantBoundaryIndicator<false>
      : public BoundaryIndicatorExpression<ConstantBoundaryIndicator<false>, ZeroExpression>
    {};
 
    typedef ConstantBoundaryIndicator<false> EmptyBoundaryIndicatorType;
    typedef ConstantBoundaryIndicator<true>  EntireBoundaryIndicatorType;
 
    struct BoundaryIdIndicator
      : public BoundaryIndicatorExpression<BoundaryIdIndicator>
    {
      BoundaryIdIndicator(int id)
        : id_(id)
      {};
 
      template<class Intersection>
      bool applies(const Intersection &intersection) const
      {
        return intersection.boundaryId() == id_;
      }
     protected:
      const int id_;
    };
 
    template<class Indicator>
    struct ComplementBoundaryIndicator
      : public BoundaryIndicatorExpression<ComplementBoundaryIndicator<Indicator> >
    {
      typedef Indicator ContainedIndicatorType;
      ComplementBoundaryIndicator(const BoundaryIndicatorInterface<ContainedIndicatorType>& indicator)
        : indicator_(indicator)
      {}
 
      template<class Intersection>
      bool applies(const Intersection &intersection) const
      {
        return !indicator_().applies(intersection);
      }
 
      const ContainedIndicatorType& containedExpression() const
      {
        return indicator_();
      }
     protected:
      ExpressionStorage<ContainedIndicatorType> indicator_;
    };
 
    template<class Indicator>
    struct BoundaryIndicatorWrapper
      : public BoundaryIndicatorExpression<BoundaryIndicatorWrapper<Indicator> >
    {
      typedef Indicator ContainedIndicatorType;
      BoundaryIndicatorWrapper(const BoundaryIndicatorInterface<ContainedIndicatorType>& indicator)
        : indicator_(indicator)
      {}
 
      template<class Intersection>
      bool applies(const Intersection &intersection) const
      {
        return indicator_().applies(intersection);
      }
     protected:
      // The wrapper makes a real copy in any case
      ExpressionCopyStorage<ContainedIndicatorType> indicator_;
    };
 
    template<class One, class Two>
    struct UnionBoundaryIndicator
      : public BoundaryIndicatorExpression<UnionBoundaryIndicator<One, Two> >
    {
      typedef One IndicatorOneType;
      typedef Two IndicatorTwoType;
      UnionBoundaryIndicator(const BoundaryIndicatorInterface<IndicatorOneType>& one,
                                 const BoundaryIndicatorInterface<IndicatorTwoType>& two)
        : one_(one), two_(two)
      {}
 
      template<class Intersection>
      bool applies(const Intersection &intersection) const
      {
        return one_().applies(intersection) || two_().applies(intersection);
      }
 
     protected:
      ExpressionCopyStorage<IndicatorOneType> one_;
      ExpressionCopyStorage<IndicatorTwoType> two_;
    };
 
    template<class One, class Two>
    struct IntersectionBoundaryIndicator
      : public BoundaryIndicatorExpression<IntersectionBoundaryIndicator<One, Two> >
    {
      typedef One IndicatorOneType;
      typedef Two IndicatorTwoType;
      IntersectionBoundaryIndicator(const BoundaryIndicatorInterface<IndicatorOneType>& one,
                                        const BoundaryIndicatorInterface<IndicatorTwoType>& two)
        : one_(one), two_(two)
      {}
 
      template<class Intersection>
      bool applies(const Intersection &intersection) const
      {
        return one_().applies(intersection) && two_().applies(intersection);
      }
 
     protected:
      ExpressionCopyStorage<IndicatorOneType> one_;
      ExpressionCopyStorage<IndicatorTwoType> two_;
    };
 
 
 
    template<class Indicator>
    BoundaryIndicatorWrapper<Indicator>
    operator*(const BoundaryIndicatorInterface<Indicator>& arg)
    {
      typedef BoundaryIndicatorWrapper<Indicator> ExpressionType;
 
      return ExpressionType(arg);
    }
 
    template<class Indicator>
    auto
    operator+(const BoundaryIndicatorInterface<Indicator>& arg)
      -> decltype(*asImp(arg))
    {
      return *asImp(arg);
    }
 
    template<class Indicator>
    Indicator
    operator*(const BoundaryIndicatorExpression<Indicator>& arg)
    {
      return arg.expression();
    }
 
    template<class Indicator>
    ComplementBoundaryIndicator<Indicator>
    operator!(const BoundaryIndicatorInterface<Indicator>& arg)
    {
      typedef ComplementBoundaryIndicator<Indicator> ExpressionType;
 
      return ExpressionType(arg);
    }
 
    template<class Indicator>
    auto
    operator-(const BoundaryIndicatorInterface<Indicator>& arg)
      -> decltype(!asImp(arg))
    {
      return !asImp(arg);
    }
 
    template<class Indicator>
    auto
    operator!(const ComplementBoundaryIndicator<Indicator>& arg)
      -> decltype(*arg.containedExpression())
    {
      return *arg.containedExpression();
    }
 
    template<class One, class Two>
    UnionBoundaryIndicator<One, Two>
    operator||(const BoundaryIndicatorInterface<One>& one,
               const BoundaryIndicatorInterface<Two>& two)
    {
      typedef UnionBoundaryIndicator<One, Two> ExpressionType;
 
      return ExpressionType(one, two);
    }
 
    template<class One, class Two>
    auto
    operator+(const BoundaryIndicatorInterface<One>& one,
              const BoundaryIndicatorInterface<Two>& two)
      -> decltype(asImp(one) || asImp(two))
    {
      return asImp(one) || asImp(two);
    }
 
    template<class One, class Two>
    IntersectionBoundaryIndicator<One, Two>
    operator&&(const BoundaryIndicatorInterface<One>& one,
               const BoundaryIndicatorInterface<Two>& two)
    {
      typedef IntersectionBoundaryIndicator<One, Two> ExpressionType;
 
      return ExpressionType(one, two);
    }
 
    template<class One, class Two>
    auto
    operator*(const BoundaryIndicatorInterface<One>& one,
              const BoundaryIndicatorInterface<Two>& two)
      -> decltype(asImp(one) && asImp(two))
    {
      return asImp(one) && asImp(two);
    }
 
    template<class One, class Two>
    auto
    operator-(const BoundaryIndicatorInterface<One>& one,
              const BoundaryIndicatorInterface<Two>& two)
      -> decltype(asImp(one) && (!asImp(two)))
    {
      return asImp(one) && (!asImp(two)); // aka one * (-two)
    }
 
    static inline
    EntireBoundaryIndicatorType
    operator!(const EmptyBoundaryIndicatorType& arg)
    {
      return EntireBoundaryIndicatorType();
    }
 
    static inline
    EmptyBoundaryIndicatorType
    operator!(const EntireBoundaryIndicatorType& arg)
    {
      return EmptyBoundaryIndicatorType();
    }
 
    template<class Other>
    static inline
    auto operator||(const EmptyBoundaryIndicatorType& one,
                    const BoundaryIndicatorInterface<Other>& two)
      -> decltype(*asImp(two))
    {
      return *asImp(two);
    }
 
    template<class Other>
    static inline
    auto operator||(const BoundaryIndicatorInterface<Other>& one,
                    const EmptyBoundaryIndicatorType& two)
      -> decltype(*asImp(one))
    {
      return *asImp(one);
    }
 
    static inline
    EmptyBoundaryIndicatorType
    operator||(const EmptyBoundaryIndicatorType& one,
               const EmptyBoundaryIndicatorType& two)
    {
      return EmptyBoundaryIndicatorType();
    }
 
    template<class Other>
    static inline
    EntireBoundaryIndicatorType
    operator||(const EntireBoundaryIndicatorType& one,
               const BoundaryIndicatorInterface<Other>& two)
    {
      return EntireBoundaryIndicatorType();
    }
 
    template<class Other>
    static inline
    EntireBoundaryIndicatorType
    operator||(const BoundaryIndicatorInterface<Other>& one,
               const EntireBoundaryIndicatorType& two)
    {
      return EntireBoundaryIndicatorType();
    }
 
    static inline
    EntireBoundaryIndicatorType
    operator||(const EntireBoundaryIndicatorType& one,
               const EntireBoundaryIndicatorType& two)
    {
      return EntireBoundaryIndicatorType();
    }
 
#if 0
    // Nope, this would only hold if one == two which is a runtime
    //condition. Boundary indicators need not be stateless.
    //Some || Some = Some
    template<class Some>
    static inline
    auto operator||(const BoundaryIndicatorInterface<Some>& one,
                    const BoundaryIndicatorInterface<Some>& two)
      -> decltype(*asImp(one))
    {
      return *asImp(one);
    }
#endif
 
    static inline
    EntireBoundaryIndicatorType
    operator||(const EntireBoundaryIndicatorType& one,
               const EmptyBoundaryIndicatorType& two)
    {
      return EntireBoundaryIndicatorType();
    }
 
    static inline
    EntireBoundaryIndicatorType
    operator||(const EmptyBoundaryIndicatorType& one,
               const EntireBoundaryIndicatorType& two)
    {
      return EntireBoundaryIndicatorType();
    }
 
    template<class Other>
    static inline
    EmptyBoundaryIndicatorType
    operator&&(const EmptyBoundaryIndicatorType& fixed,
               const BoundaryIndicatorInterface<Other>& other)
    {
      return EmptyBoundaryIndicatorType();
    }
 
    template<class Other>
    auto operator&&(const BoundaryIndicatorInterface<Other>& other,
                    const EmptyBoundaryIndicatorType& fixed)
      -> decltype(*fixed)
    {
      return *fixed;
    }
 
    template<class Other>
    static inline
    auto operator&&(const EntireBoundaryIndicatorType& fixed,
                    const BoundaryIndicatorInterface<Other>& other)
      -> decltype(*asImp(other))
    {
      return *asImp(other);
    }
 
    template<class Other>
    static inline
    auto operator&&(const BoundaryIndicatorInterface<Other>& other,
                    const EntireBoundaryIndicatorType& fixed)
      -> decltype(*asImp(other))
    {
      return *asImp(other);
    }
 
#if 0
    // Only holds if one == two, actually
 
    // Other && Other = Other
    template<class Other>
    auto
    operator&&(const BoundaryIndicatorInterface<Other>& one,
               const EntireBoundaryIndicatorType& two)
      -> decltype(*one)
    {
      return *one;
    }
#endif
 
    static inline
    EmptyBoundaryIndicatorType
    operator&&(const EmptyBoundaryIndicatorType& one,
               const EmptyBoundaryIndicatorType& two)
     {
      return EmptyBoundaryIndicatorType();
    }
 
    static inline
    EntireBoundaryIndicatorType
    operator&&(const EntireBoundaryIndicatorType& one,
               const EntireBoundaryIndicatorType& two)
     {
      return EntireBoundaryIndicatorType();
    }
 
    static inline
    EmptyBoundaryIndicatorType
    operator&&(const EmptyBoundaryIndicatorType& one,
               const EntireBoundaryIndicatorType& two)
    {
      return EmptyBoundaryIndicatorType();
    }
 
    static inline
    EmptyBoundaryIndicatorType
    operator&&(const EntireBoundaryIndicatorType& one,
               const EmptyBoundaryIndicatorType& two)
    {
      return EmptyBoundaryIndicatorType();
    }
 
#if 0
    // This also does only hold if notSome would refer to !some (the
    // instance, not the data-type)
 
    // Some && !Some = Empty
    template<class Other>
    EmptyBoundaryIndicatorType
    operator&&(const BoundaryIndicatorInterface<Other>& some,
               const ComplementBoundaryIndicator<Other>& notSome)
    {
      typedef EmptyBoundaryIndicatorType ExpressionType;
 
      return ExpressionType();
    }
 
    template<class Other>
    auto
    operator&&(const ComplementBoundaryIndicator<Other>& notSome,
               const BoundaryIndicatorInterface<Other>& some)
      -> decltype(asImp(some) && notSome)
    {
      return asImp(some) && notSome;
    }
#endif
 
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_BOUNDARY_CONSTRAINTS_HH__