shapeFunction2d.hh

Go to the documentation of this file.

 
#ifndef shapeFunction2d_hh
#define shapeFunction2d_hh
 
#include "basics/typedefs.hh"
#include "basics/exceptions.hh"
#include "space/tmatrix.hh"
 
namespace hp2D {
 
  // forward declarations
  template<class F>
  class Quad;
 
  using concepts::Real;
 
  // ******************************************************* ShapeFunction2D **
 
  template<typename F>
  class ShapeFunction2D {
  public:
    ShapeFunction2D();
    ShapeFunction2D(const ShapeFunction2D<F>& s);
 
    uint n(uint i) const {
      conceptsAssert(i < 2, concepts::Assertion());
      conceptsAssert(n_[i] != 0, concepts::Assertion());
      return n_[i]; }
    void n(uint i, uint value) {
      conceptsAssert(i < 2, concepts::Assertion());
      n_[i] = value;
    }
 
    uint nq(uint i) const {
      conceptsAssert(i < 2, concepts::Assertion());
      conceptsAssert(nq_[i] != 0, concepts::Assertion());
      return nq_[i]; }
    void nq(uint i, uint value) {
      conceptsAssert(i < 2, concepts::Assertion());
      nq_[i] = value;
    }
 
    const Real* values(uint i) const {
      conceptsAssert(i < 2, concepts::Assertion());
      conceptsAssert(values_[i] != 0, concepts::Assertion());
      return values_[i]; }
    void values(uint i, const Real* value) {
      conceptsAssert(i < 2, concepts::Assertion());
      values_[i] = value;
    }
 
    const Real* abscissas(uint i) const {
      conceptsAssert(i < 2, concepts::Assertion());
      conceptsAssert(abscissas_[i] != 0, concepts::Assertion());
      return abscissas_[i]; }
    void abscissas(uint i, const Real* value) {
      conceptsAssert(i < 2, concepts::Assertion());
      abscissas_[i] = value;
    }
 
    const Real* weights(uint i) const {
      conceptsAssert(i < 2, concepts::Assertion());
      conceptsAssert(weights_[i] != 0, concepts::Assertion());
      return weights_[i]; }
    void weights(uint i, const Real* value) {
      conceptsAssert(i < 2, concepts::Assertion());
      weights_[i] = value;
    }
    const concepts::TMatrixBase<F>* T() const { return T_; }
    void T(const concepts::TMatrixBase<F>* T) { T_ = T; }
    const concepts::TColumnTensor<bool, 2>* usedIdx() const { return usedIdx_;}
    void usedIdx(const concepts::TColumnTensor<bool, 2>* usedIdx)
    { usedIdx_ = usedIdx; }
  private:
    int n_[2], nq_[2];
    const F* values_[2];
    const Real* abscissas_[2], * weights_[2];
    const concepts::TMatrixBase<F>* T_;
    const concepts::TColumnTensor<bool, 2>* usedIdx_;
  };
 
  // *************************************************** makeShapeFunction2D **
 
  template<class F>
  ShapeFunction2D<F> 
  makeShapeFunction2D(const Quad<F>& quad);
 
} // namespace hp2D
 
#endif // shapeFunction2d_hh