bformAdapt.hh

Go to the documentation of this file.

 
#ifndef bformAdapt_hh
#define bformAdapt_hh
 
#include "operator/bilinearForm.hh"
#include "bemInt.hh"
#include "bem/element.hh"
 
// debugging bilinear forms
#define AdaptLaplaceDL00_D 0
 
namespace bem {
 
  // ****************************************************** AdaptLaplaceDL00 **
 
  template <class F>
  class AdaptLaplaceDL00 : public concepts::BilinearForm<F> {
  public:
    inline AdaptLaplaceDL00(uint stroud = 2, uint gauss = 2,
          concepts::Real dist = 0.0,
          concepts::Real eta = 0.5);
#if AdaptLaplaceDL00_D
    virtual ~AdaptLaplaceDL00() {
      std::cout << "AdaptLaplaceDL00(samel=" << samel_ << ", far=" << far_;
      std::cout << ", recX=" << recX_ << ", recY=" << recY_;
      std::cout << ", rec=" << rec_ << ", farrec=" << farrec_ << ")\n";
    };
#endif
 
    void operator()(const concepts::Element<F>& elmX,
                    const concepts::Element<F>& elmY,
                    concepts::ElementMatrix<F>& em);
    void operator()(const Constant3d001<F>& elmX,
                    const Constant3d001<F>& elmY,
                    concepts::ElementMatrix<F>& em);
 
    virtual AdaptLaplaceDL00* clone() const {
      return new AdaptLaplaceDL00(stroud_, gauss_, dist_, eta_); }
  private:
    void ball_(const Constant3d001<F>& elm, concepts::Real3d* c,
         concepts::Real* r) const;
    void ball_(const concepts::Triangle3d& cell, concepts::Real3d* c,
         concepts::Real* r) const;
    inline bool admissible_(const concepts::Real3d* cX,
          const concepts::Real* rX,
                            const concepts::Real3d* cY,
          const concepts::Real* rY) const;
    void update_(concepts::Triangle3d& cell, const Constant3d001<F>& elm,
                 uint deltal, F* m, bool swp) const;
 
    uint stroud_;
    uint gauss_;
    concepts::Real dist_;
    concepts::Real eta_;
    LplGal014<F> qr_;
 
    concepts::Real3d* c_;
    concepts::Real*   r_;
 
#if AdaptLaplaceDL00_D
    // Debug information
    // # integration (on the same level)
    uint samel_;
    // # integration (elements far away from each other)
    uint far_;
    // # integration (elements far away in recursive call)
    mutable uint farrec_;
    // # integration (recursive with \f$l_X > l_Y\f$)
    uint recX_;
    // # integration (recursive with \f$l_Y > l_X\f$)
    uint recY_;
    // # recursive integration calls
    mutable uint rec_;
#endif
  };
 
  template <class F>
  inline AdaptLaplaceDL00<F>::AdaptLaplaceDL00(uint stroud, uint gauss,
                 concepts::Real dist,
                 concepts::Real eta)
    : stroud_(stroud), gauss_(gauss), dist_(dist), eta_(eta), c_(0), r_(0) {
#if AdaptLaplaceDL00_D
    samel_ = 0;  far_ = 0;  recX_ = 0;  recY_ = 0;  rec_ = 0;  farrec_ = 0;
#endif
  }
 
  template <class F>
  inline bool
  AdaptLaplaceDL00<F>::admissible_(const concepts::Real3d* cX,
           const concepts::Real* rX,
           const concepts::Real3d* cY,
           const concepts::Real* rY) const {
    return concepts::Real3d(*cX - *cY).l2() * eta_ > *rX + *rY;
  }
 
  // ****************************************************** AdaptLaplaceDL01 **
 
  template <class F>
  class AdaptLaplaceDL01 : public concepts::BilinearForm<F> {
  public:
    inline AdaptLaplaceDL01(uint gaussX = 2, uint gaussY = 2,
          concepts::Real deltaG = 1.0,
          concepts::Real dist = 0.0,
          concepts::Real eta = 0.5);
 
    void operator()(const concepts::Element<F>& elmX,
                    const concepts::Element<F>& elmY,
                    concepts::ElementMatrix<F>& em);
    void operator()(const Constant3d001<F>& elmX,
                    const Constant3d001<F>& elmY,
                    concepts::ElementMatrix<F>& em);
 
    virtual AdaptLaplaceDL01* clone() const {
      return new AdaptLaplaceDL01(gaussX_, gaussY_, deltaG_, dist_, eta_); }
  private:
    void ball_(const Constant3d001<F>& elm, concepts::Real3d* c,
         concepts::Real* r) const;
    void ball_(const concepts::Triangle3d& cell, concepts::Real3d* c,
         concepts::Real* r) const;
    inline bool admissible_(const concepts::Real3d* cX,
          const concepts::Real* rX,
                            const concepts::Real3d* cY,
          const concepts::Real* rY) const;
    void update_(concepts::Triangle3d& cell, const Constant3d001<F>& elm,
                 uint deltal, F* m, bool swp) const;
 
    uint gaussX_;
    uint gaussY_;
    concepts::Real deltaG_;
    concepts::Real dist_;
    concepts::Real eta_;
 
    LplGal011<F> qr_;
 
    concepts::Real3d* c_;
    concepts::Real*   r_;
  };
 
  template <class F>
  inline AdaptLaplaceDL01<F>::AdaptLaplaceDL01(uint gaussX, uint gaussY,
                 concepts::Real deltaG,
                 concepts::Real dist,
                 concepts::Real eta)
    : gaussX_(gaussX), gaussY_(gaussY), deltaG_(deltaG), dist_(dist),
      eta_(eta), c_(0), r_(0) {
  }
 
  template <class F>
  inline bool
  AdaptLaplaceDL01<F>::admissible_(const concepts::Real3d* cX,
           const concepts::Real* rX,
           const concepts::Real3d* cY,
           const concepts::Real* rY) const {
    return concepts::Real3d(*cX - *cY).l2() * eta_ > *rX + *rY;
  }
 
  // ****************************************************** AdaptLaplaceSL01 **
 
  template <class F>
  class AdaptLaplaceSL01 : public concepts::BilinearForm<F> {
  public:
    inline AdaptLaplaceSL01(uint stroud = 0, uint gauss = 0,
          concepts::Real deltaI = 1.0,
          concepts::Real dist = 0.0,
          concepts::Real eta = 0.5);
 
    void operator()(const concepts::Element<F>& elmX,
                    const concepts::Element<F>& elmY,
                    concepts::ElementMatrix<F>& em);
    void operator()(const Constant3d001<F>& elmX,
                    const Constant3d001<F>& elmY,
                    concepts::ElementMatrix<F>& em);
 
    virtual AdaptLaplaceSL01* clone() const {
      return new AdaptLaplaceSL01(stroud_, gauss_, deltaI_, dist_, eta_); }
  private:
    void ball_(const Constant3d001<F>& elm, concepts::Real3d* c,
         concepts::Real* r) const;
    void ball_(const concepts::Triangle3d& cell, concepts::Real3d* c,
         concepts::Real* r) const;
    inline bool admissible_(const concepts::Real3d* cX,
          const concepts::Real* rX,
                            const concepts::Real3d* cY,
          const concepts::Real* rY) const;
    void update_(concepts::Triangle3d& cell, const Constant3d001<F>& elm,
                 uint deltal, F* m, bool swp) const;
 
    uint stroud_;
    uint gauss_;
    concepts::Real deltaI_;
    concepts::Real dist_;
    concepts::Real eta_;
 
    LplGal018<F> qr_;
 
    concepts::Real3d* c_;
    concepts::Real*   r_;
  };
 
  template <class F>
  inline AdaptLaplaceSL01<F>::AdaptLaplaceSL01(uint stroud, uint gauss,
                 concepts::Real deltaI,
                 concepts::Real dist,
                 concepts::Real eta)
    : stroud_(stroud), gauss_(gauss), deltaI_(deltaI), dist_(dist),
      eta_(eta), c_(0), r_(0) {
  }
 
  template <class F>
  inline bool
  AdaptLaplaceSL01<F>::admissible_(const concepts::Real3d* cX,
           const concepts::Real* rX,
           const concepts::Real3d* cY,
           const concepts::Real* rY) const {
    return concepts::Real3d(*cX - *cY).l2() * eta_ > *rX + *rY;
  }
 
} // namespace bem
  
#endif // bformAdapt_hh