cell1D.hh

Go to the documentation of this file.

 
#ifndef cell1D_hh
#define cell1D_hh
 
#include <iostream>
#include <memory>
#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"
#include "topology.hh"
#include "cell.hh"
#include "operator/matrix.hh"
 
namespace concepts {
 
  // forward declaration
  class MapEdge1d;
  class MappingEdge2d;
 
  // **************************************************************** EdgeNd **
 
  class EdgeNd: public Cell1 {
  public:
 
  /* Type for indices in the hierarchical definition of the cells
 
   Use a type with a larger range depending on the number of cell
   refinements.
   */
  typedef uint index_type;
 
  // Maximal number of levels in the cell refinement
 
  static uint MAX_LEVEL;
 
    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;
 
    virtual uint dim() const = 0;
  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;
 
    virtual inline uint dim() const {
      return 1;
    }
 
    Real chi(Real xi) const;
 
    virtual concepts::Real3d elemMap(const Real xi) const;
    virtual concepts::Real3d elemMap(const Real1d& xi) const { return this->elemMap(xi[0]); };
    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 jacobian(concepts::Point<Real, 1>& 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 const Level<1>& level() const{
      return lvl_;
    }
 
    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_;
    Level<1> lvl_;
 
    index_type 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;
 
    virtual inline uint dim() const {
      return 2;
    }
 
    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;
 
    Real tangentialSecondDerivative(const Real x) const;
 
    Real2d hessian(Real x) const;
 
    Array<Real> hessianInverse(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_;
 
    index_type 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