element.hh

Go to the documentation of this file.

 
#ifndef bemElement_hh
#define bemElement_hh
 
#include "basics/vectorsMatricesForward.hh"
#include "geometry/cell2D.hh"
#include "space/tmatrix.hh"
#include "space/element.hh"
 
namespace concepts {
  // forward declatation
  template<typename F> class ElementGraphics;
}
 
namespace bem {
 
  // ************************************************************ Dirac3d000 **
 
#if 1
  template <class F = concepts::Real>
  class Dirac3d000 : public concepts::ElementWithCell<F> {
  public:
    Dirac3d000(const concepts::Triangle3d& cell, uint idx[],
         uint vtx[], uint n);
 
    inline const concepts::TMatrixBase<F>& T() const {return T_;}
    inline const concepts::Vertex& support(uint i) const;
    inline const concepts::Real3d& vertex(uint i) const {return v_[i];}
    virtual const concepts::Triangle3d& cell() const { return cell_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
 
  private:
    const concepts::Triangle3d& cell_;
    concepts::uchar             ctrl_;
    concepts::TIndex<F>         T_;
    concepts::Real3d            v_[3];
  };
 
 
  template <class F>
  inline const concepts::Vertex& Dirac3d000<F>::support(uint i) const {
    uint j = ctrl_ >> (i << 1);
    return *cell_.connector().vertex(j & 3);
  }
 
#else
 
  template <class F = concepts::Real>
  class Dirac3d000 : public conceptsElement<F> {
  public:
    inline Dirac3d000(const concepts::Triangle3d& cell, uint idx[],
          uint vtx[], uint n);
 
    inline const concepts::TMatrixBase<F>& T() const {return T_;}
    inline const concepts::Vertex& support(uint i) const;
    concepts::Real3d vertex(uint i) const;
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
 
  private:
    const concepts::Triangle3d& cell_;
    concepts::uchar             ctrl_;
    concepts::TIndex<F>         T_;
  };
 
  template <class F>
  inline Dirac3d000<F>::Dirac3d000(const concepts::Triangle3d& cell,
           uint idx[], uint vtx[], uint n)
    : cell_(cell), T_(n, n, idx) {
 
    ctrl_ = 0;
    for(uint i = n; i--;)  {ctrl_ <<= 2; ctrl_ |= vtx[i] & 3;}
  }
 
  template <class F>
  inline const concepts::Vertex& Dirac3d000<F>::support(uint i) const {
    uint j = ctrl_ >> (i << 1);
    return *cell_.connector().vertex(j & 3);
  }
 
#endif
 
  // *********************************************************** Linear3d000 **
 
#if 1
 
  template <class F = concepts::Real>
  class Linear3d000 : public concepts::ElementWithCell<F> {
  public:
    Linear3d000(const concepts::Triangle3d& cell, uint idx[]);
 
    inline const concepts::TMatrixBase<F>& T() const {return T_;}
    inline const concepts::Unit3d& n() const {return n_;}
    inline const concepts::Triangle& support() const;
    inline const concepts::Real3d& vertex(uint i) const {return v_[i];}
 
    virtual const concepts::Triangle3d& cell() const {return cell_;}
 
    virtual const concepts::ElementGraphics<F>* graphics() const;
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  private:
    const concepts::Triangle3d& cell_;
    concepts::TIndex<F>         T_;
    concepts::Real3d            v_[3];
    concepts::Unit3d            n_;
 
    static std::unique_ptr<concepts::ElementGraphics<F> > graphics_;
  };
 
  template <class F>
  inline const concepts::Triangle& Linear3d000<F>::support() const {
    return cell_.connector();
  }
 
#else
 
  template <class F = concepts::Real>
  class Linear3d000 : public concepts::ElementWithCell<F> {
  public:
    Linear3d000(const concepts::Triangle3d& cell, uint idx[]);
 
    inline const concepts::TMatrixBase<F>& T() const {return T_;}
    inline const concepts::Unit3d& n() const {return n_;}
    inline const concepts::Triangle& support() const;
    concepts::Real3d vertex(uint i) const;
 
    virtual const concepts::Triangle3d& cell() const {return cell_;}
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  private:
    const concepts::Triangle3d& cell_;
    concepts::TIndex<F>         T_;
    concepts::Unit3d            n_;
  };
 
  template <class F>
  inline const concepts::Triangle& Linear3d000<F>::support() const {
    return cell_.connector();
  }
 
#endif
 
  // ********************************************************* Constant3d000 **
 
#if 1
 
  template <class F = concepts::Real>
  class Constant3d000 : public concepts::ElementWithCell<F> {
  public:
    Constant3d000(const concepts::Triangle3d& cell, uint idx);
 
    inline const concepts::TMatrixBase<F>& T() const {return T_;}
    inline const concepts::Unit3d& n() const {return n_;}
    inline const concepts::Triangle& support() const;
    inline const concepts::Real3d& vertex(uint i) const {return v_[i];}
 
    virtual const concepts::Triangle3d& cell() const {return cell_;}
 
    virtual const concepts::ElementGraphics<F>* graphics() const;
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  private:
    const concepts::Triangle3d& cell_;
    concepts::TIndex<F>         T_;
    concepts::Unit3d            n_;
    concepts::Real3d            v_[3];
 
    static std::unique_ptr<concepts::ElementGraphics<F> > graphics_;
  };
 
  template <class F>
  inline const concepts::Triangle& Constant3d000<F>::support() const {
    return cell_.connector();
  }
 
#else
 
  template <class F = concepts::Real>
  class Constant3d000 : public concepts::ElementWithCell<F> {
  public:
    Constant3d000(const concepts::Triangle3d& cell, uint idx);
 
    inline const concepts::TMatrixBase<F>& T() const {return T_;}
    inline const concepts::Unit3d& n() const {return n_;}
    inline const concepts::Triangle& support() const;
    concepts::Real3d vertex(uint i) const;
 
    virtual const concepts::Triangle3d& cell() const {return cell_;}
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  private:
    const concepts::Triangle3d& cell_;
    concepts::TIndex<F>         T_;
    concepts::Unit3d            n_;
  };
 
  template <class F>
  inline const concepts::Triangle& Constant3d000<F>::support() const {
    return cell_.connector();
  }
 
#endif
 
  // ********************************************************* Constant3d001 **
 
  template<class F = concepts::Real>
  class Constant3d001 : public concepts::ElementWithCell<F> {
  public:
    class Key {
    public:
      inline Key(uint l, uint j) : l_(l), j_(j) {}
      inline Key(const Key& key) : l_(key.l()), j_(key.j()) {}
 
      inline int operator==(const Key& key) const {
  return l_ == key.l() && j_ == key.j();
      }
      inline uint l() const {return l_;}
      inline uint j() const {return j_;}
 
    private:
      uint l_;
      uint j_;
    };
 
    Constant3d001(concepts::Triangle3d& cell,
      const Constant3d001<F>::Key& key, uint idx);
 
    inline const concepts::TMatrixBase<F>& T() const {return T_;}
    inline const concepts::Unit3d& n() const {return n_;}
    inline const concepts::Triangle& support() const;
    inline const concepts::Real3d& vertex(uint i) const {return v_[i];}
 
    virtual concepts::Triangle3d& cell() const {return *cell_;}
    inline const Key& key() const {return key_;};
 
    static inline uint maxlevel() {return maxlvl_;}
    static inline uint minlevel() {return minlvl_;}
    static inline void setmaxlevel(uint maxlvl) {maxlvl_ = maxlvl;}
    static inline void setminlevel(uint minlvl) {minlvl_ = minlvl;}
 
    virtual const concepts::ElementGraphics<F>* graphics() const;
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  private:
    concepts::Triangle3d* cell_;
    concepts::TIndex<F> T_;
    concepts::Unit3d n_;
    concepts::Real3d v_[3];
    Key key_;
 
    static uint maxlvl_;
    static uint minlvl_;
 
    static std::unique_ptr<concepts::ElementGraphics<F> > graphics_;
  };
 
  template<class F>
  inline const concepts::Triangle& Constant3d001<F>::support() const {
    return cell_->connector();
  }
 
  // ********************************************************* Constant3d002 **
 
#if 1
 
  template <class F = concepts::Real>
  class Constant3d002 : public concepts::ElementWithCell<F> {
  public:
    Constant3d002(const concepts::Triangle3d& cell, uint idx);
    virtual ~Constant3d002();
 
    inline const concepts::TMatrixBase<F>& T() const {return T_;}
    inline const concepts::Unit3d& n() const {return n_;}
    inline const concepts::Triangle& support() const;
    inline const concepts::Real3d& vertex(uint i) const {return v_[i];}
 
    virtual const concepts::Triangle3d& cell() const {return cell_;}
 
    virtual const concepts::ElementGraphics<F>* graphics() const;
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  private:
    const concepts::Triangle3d& cell_;
    concepts::TIndex<F>         T_;
    concepts::Unit3d            n_;
    concepts::Real3d            v_[3];
 
    static std::unique_ptr<concepts::ElementGraphics<F> > graphics_;
  };
 
  template <class F>
  inline const concepts::Triangle& Constant3d002<F>::support() const {
    return cell_.connector();
  }
 
#else
 
  template <class F = concepts::Real>
  class Constant3d002 : public concepts::ElementWithCell<F> {
  public:
    Constant3d002(const concepts::Triangle3d& cell, uint idx);
 
    inline const concepts::TMatrixBase<F>& T() const {return T_;}
    inline const concepts::Unit3d& n() const {return n_;}
    inline const concepts::Triangle& support() const;
    concepts::Real3d vertex(uint i) const;
 
    virtual const concepts::Triangle3d& cell() const {return cell_;}
 
  protected:
    std::ostream& info(std::ostream& os) const;
 
  private:
    const concepts::Triangle3d& cell_;
    concepts::TIndex<F>         T_;
    concepts::Unit3d            n_;
  };
 
  template <class F>
  inline const concepts::Triangle& Constant3d002<F>::support() const {
    return cell_.connector();
  }
 
#endif
 
} // namespace bem
 
#endif // bemElement_hh