hp2D/shapeFunction2d.hh

Go to the documentation of this file.

/* shape function in 2D: data for shape values, abscissas and quadratur weights
 */

#ifndef shapeFucntion2d_hh
#define shapeFucntion2d_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 // shapeFucntion2d_hh