geometry/cell1D.hh

Go to the documentation of this file.

/* 1D Cells, ie. triangles and quads
 * Geometrical information (coordinates), brings element maps and
 * topology together
 */

#ifndef cell1D_hh
#define cell1D_hh

#include <iostream>
#include <memory>
#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"
#include "topology.hh"
#include "cell.hh"

namespace concepts {

  // forward declaration
  class MapEdge1d;
  class MappingEdge2d;

  // **************************************************************** EdgeNd **

  class EdgeNd : public Cell1 {
  public:
    EdgeNd(Edge& cntr) : cntr_(cntr) {}
    virtual ~EdgeNd() {}

    virtual EdgeNd* child(uint i) = 0;
    virtual const EdgeNd* child(uint i) const = 0;

    inline Edge& connector() const { return cntr_; }

    virtual Real jacobianDeterminant(const Real x) const = 0;

    virtual Real3d vertex(const uint i) const;
    virtual Real3d center() const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    Edge& cntr_;
  };


  // **************************************************************** Edge1d **

  class Edge1d : public EdgeNd {
  public:
    Edge1d(Edge& cntr, const MapEdge1d& map);
    virtual ~Edge1d();

    virtual Edge1d* child(uint i);
    virtual const Edge1d* child(uint i) const;

    Real chi(Real xi) const;

    virtual concepts::Real3d elemMap(const Real xi) const;
    virtual concepts::Real3d elemMap(const Real2d& xi) const;
    virtual concepts::Real3d elemMap(const Real3d& xi) const;

    inline Real jacobianDeterminant(const Real x) const { return jacobian(x); }

    Real jacobian(Real x) const;

    Real size() const;

    inline Real jacobianInverse(const Real x) const { return 1.0/jacobian(x); }

    inline const MapEdge1d* map() const { return map_; }

    inline Edge1d* clone(Edge& cntr, MapEdge1d* map) const {
      return new Edge1d(cntr, map, l_, i_); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    Edge1d* lnk_;

    Edge1d* chld_;

    MapEdge1d* map_;

    uint l_;

    uint i_;

    Edge1d(Edge& cntr, MapEdge1d* map, const uint l, const uint i);
  };

  // **************************************************************** Edge2d **

  class Edge2d : public EdgeNd {
  public:
    Edge2d(Edge& cntr, const MappingEdge2d& map, const Z2 dir = 0);
    
    virtual ~Edge2d();

    virtual Edge2d* child(uint i);
    virtual const Edge2d* child(uint i) const;

    Real2d chi(Real xi) const;

    virtual concepts::Real3d elemMap(const Real xi) const;
    virtual concepts::Real3d elemMap(const Real2d& xi) const;
    virtual concepts::Real3d elemMap(const Real3d& xi) const;

    inline Real jacobianDeterminant(const Real x) const { 
      return jacobian(x).l2();
    }

    Real2d jacobian(Real x) const;
    
    inline const MappingEdge2d* map() const { return map_; }

    virtual Edge2d* clone() const;

    virtual Edge2d* clone(Edge& cntr, MappingEdge2d* map) const {
      return new Edge2d(cntr, map, dir_, l_, i_); }

    uchar level() const { return l_; }

    Z2 dir() const { return dir_; }
    Z2& dir() { return dir_; }
    inline void swapdir() { ++dir_; }
    Real2d n0(Real x) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;

    MappingEdge2d* map_;
    uint l_;

    uint i_;

    Z2 dir_;

    Edge2d(Edge& cntr, MappingEdge2d* map, const Z2 dir,
           const uint l, const uint i);
  private:
    Edge2d* lnk_;

    Edge2d* chld_;
  };

} // namespace concepts

#endif // cell1D_hh