geometry/arrays.hh

Go to the documentation of this file.

#include "toolbox/array.hh"
#include "cell1D.hh"
#include "cell2D.hh"
#include "cell3D.hh"

#ifndef geometryArrays_hh
#define geometryArrays_hh

namespace concepts {


  // ************************************************************* makeArray **

  template<class F, class G>
  void makeArray(const F& cell, const Array<Real>& p,
                  G (F::*fun)(Real) const, Array<G>& array)
  {
    array.resize(p.size());
    G* coord = array;
    const Real* pAcc = p;
    for (uint i = 0; i < p.size(); ++i)
      *coord++ = (cell.*fun)(*pAcc++);
  }

  template<class F, class G>
  void makeArray(const F& cell, const Array<Real>& pX, const Array<Real>& pY,
                  G (F::*fun)(Real, Real) const, Array<G>& array)
  {
    array.resize(pX.size() * pY.size());
    G* coord = array;
    const Real* pxAcc = pX;
    for (uint i = 0; i < pX.size(); ++i) {
      const Real* pyAcc = pY;
      for (uint j = 0; j < pY.size(); ++j)
        *coord++ = (cell.*fun)(*pxAcc, *pyAcc++);
      pxAcc++;
    }
  }


  // ************************************************************ ArrayCoord **

  template<uint dim>
  class ArrayCoord {};


  // ********************************************************* ArrayCoord<1> **

  template<>
  class ArrayCoord<1> : public Array<Real> {
  public:
    ArrayCoord(const Edge1d& edge,
               const Array<Real>& p);
  };


  // ********************************************************* ArrayCoord<2> **

  template<>
  class ArrayCoord<2> : public Array<Real2d> {
  public:
    ArrayCoord(const Quad2d& quad,
               const Array<Real>& qX,
               const Array<Real>& qY);
    ArrayCoord(const Edge2d& edge,
               const Array<Real>& p);
  };


  // ********************************************************* ArrayJacobian **

  template<int gdim, int ldim>
  class ArrayJacobian {
  };

  // **************************************************** ArrayJacobian<1,1> **
  
  template<>
  class ArrayJacobian<1,1> : public Array<Real> {
  public:
    ArrayJacobian(const EdgeNd& edge,
                  const Array<Real>& p);
    ArrayJacobian(const Quad2d& quad,
                  const Array<Real>& qX,
                  const Array<Real>& qY);
  };

  // **************************************************** ArrayJacobian<2,2> **

  template<>
  class ArrayJacobian<2,2> : public Array<Mapping<Real,2> > {
  public:
    ArrayJacobian(const Quad2d& quad,
                  const Array<Real>& qX,
                  const Array<Real>& qY);

    ArrayJacobian(const Quad2d& quad, uint k,
                  const Array<Real>& q);
  };

  // ******************************************************** ArrayLocalCoord **

  class ArrayLocalCoord : public Array<Real> {
  public:
    ArrayLocalCoord(const Quad2d& quad, uint k, uint dim,
                    const Array<Real>& q);
  private:
    inline bool alongEdge(uint k, uint dim)
    {
      return 
        (k == 0 && dim == 1) || (k == 3 && dim == 0) || 
        (k == 1 && dim == 0) || (k == 2 && dim == 1);
    }
  };

} // namespace concepts


#endif // geometryArrays_hh