cell3D.hh

Go to the documentation of this file.

 
#ifndef cell3D_hh
#define cell3D_hh
 
#include <iostream>
#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"
#include "basics/level.hh"
#include "topology3D.hh"
#include "cell.hh"
#include "elementMaps3D.hh"
 
 
namespace concepts {
 
  // ****************************************************** NegativeJacobian **
 
  class NegativeJacobian : public MissingFeature {
  public:
    NegativeJacobian(const std::string& errMsg) throw();
  protected:
    virtual std::ostream& info(std::ostream& os) const throw();
  };
 
  // ********************************************************* Tetrahedron3d **
 
  class Tetrahedron3d : public Cell3 {
  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;
 
    struct Index {
      uchar  l_;
 
      index_type i_;
 
      index_type j_;
 
      index_type k_;
 
      inline Index() : l_(0), i_(0), j_(0), k_(0) {}
      inline Index(uchar l, index_type i, index_type j, index_type k) :
  l_(l), i_(i), j_(j), k_(k) {}
      inline std::ostream& info(std::ostream& os) const;
    };
 
    Tetrahedron3d(Tetrahedron& cntr, const MapTetrahedron3d& map);
    virtual ~Tetrahedron3d();
  
    virtual Tetrahedron3d* child(uint i);
    virtual const Tetrahedron3d* child(uint i) const;
    Tetrahedron& connector() const { return cntr_; }
 
    Real3d chi(Real xi, Real eta, Real zeta) const;
    Real3d center() const {return chi(0.5, 0.5, 0.5);};
 
    Real3d vertex(uint i) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    Index idx_;
 
    Tetrahedron& cntr_;
 
    Tetrahedron3d* lnk_;
 
    Tetrahedron3d* chld_;
 
    MapTetrahedron3d* map_;
 
    Tetrahedron3d(Tetrahedron& cntr, MapTetrahedron3d* map, 
          const Index& idx);
  };
 
  inline std::ostream& Tetrahedron3d::Index::info(std::ostream& os) const {
    return os << '(' << (uint)l_ << ", " 
        << i_ << ", " << j_ << ", " << k_ << ')';
  }
 
  // ****************************************************** Hex3dSubdivision **
 
  class Hexahedron3d;
 
  class Hex3dSubdivision : public OutputOperator {
  public:
    virtual void createChildren(Hexahedron3d& h) const = 0;
    virtual void removeChildren(Hexahedron3d& h) const;
    virtual const HexSubdivision* topologicalStrategy() const = 0;
  };
 
  // ********************************************************** Hex3dSubdiv8 **
 
  class Hex3dSubdiv8 : public Hex3dSubdivision {
  public:
    virtual void createChildren(Hexahedron3d& h) const;
    virtual const HexSubdiv8* topologicalStrategy() const;
    static const Hex3dSubdiv8* instance();
    virtual ~Hex3dSubdiv8();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    static std::unique_ptr<Hex3dSubdiv8> instance_;
  };
 
  // ********************************************************* Hex3dSubdiv2x **
 
  class Hex3dSubdiv2x : public Hex3dSubdivision {
  public:
    virtual void createChildren(Hexahedron3d& h) const;
    virtual const HexSubdiv2x* topologicalStrategy() const;
    static const Hex3dSubdiv2x* instance();
    virtual ~Hex3dSubdiv2x();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    static std::unique_ptr<Hex3dSubdiv2x> instance_;
  };
 
  // ********************************************************* Hex3dSubdiv2y **
 
  class Hex3dSubdiv2y : public Hex3dSubdivision {
  public:
    virtual void createChildren(Hexahedron3d& h) const;
    virtual const HexSubdiv2y* topologicalStrategy() const;
    static const Hex3dSubdiv2y* instance();
    virtual ~Hex3dSubdiv2y();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    static std::unique_ptr<Hex3dSubdiv2y> instance_;
  };
 
  // ********************************************************* Hex3dSubdiv2z **
 
  class Hex3dSubdiv2z : public Hex3dSubdivision {
  public:
    virtual void createChildren(Hexahedron3d& h) const;
    virtual const HexSubdiv2z* topologicalStrategy() const;
    static const Hex3dSubdiv2z* instance();
    virtual ~Hex3dSubdiv2z();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    static std::unique_ptr<Hex3dSubdiv2z> instance_;
  };
 
  // ********************************************************* Hex3dSubdiv4x **
 
  class Hex3dSubdiv4x : public Hex3dSubdivision {
  public:
    virtual void createChildren(Hexahedron3d& h) const;
    virtual const HexSubdiv4x* topologicalStrategy() const;
    static const Hex3dSubdiv4x* instance();
    virtual ~Hex3dSubdiv4x();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    static std::unique_ptr<Hex3dSubdiv4x> instance_;
  };
 
  // ********************************************************* Hex3dSubdiv4y **
 
  class Hex3dSubdiv4y : public Hex3dSubdivision {
  public:
    virtual void createChildren(Hexahedron3d& h) const;
    virtual const HexSubdiv4y* topologicalStrategy() const;
    static const Hex3dSubdiv4y* instance();
    virtual ~Hex3dSubdiv4y();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    static std::unique_ptr<Hex3dSubdiv4y> instance_;
  };
 
  // ********************************************************* Hex3dSubdiv4z **
 
  class Hex3dSubdiv4z : public Hex3dSubdivision {
  public:
    virtual void createChildren(Hexahedron3d& h) const;
    virtual const HexSubdiv4z* topologicalStrategy() const;
    static const Hex3dSubdiv4z* instance();
    virtual ~Hex3dSubdiv4z();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    static std::unique_ptr<Hex3dSubdiv4z> instance_;
  };
 
  // ********************************************************** Hexahedron3d **
 
  // forward declaration
  class MappingQuad3d;
 
  class Hexahedron3d : public Cell3 {
    friend class Hex3dSubdivision;
    friend class Hex3dSubdiv8;
    friend class Hex3dSubdiv2x;
    friend class Hex3dSubdiv2y;
    friend class Hex3dSubdiv2z;
    friend class Hex3dSubdiv4x;
    friend class Hex3dSubdiv4y;
    friend class Hex3dSubdiv4z;
  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;
 
    struct Index {
      Level<3> level_;
 
      index_type i_;
 
      index_type j_;
 
      index_type k_;
 
      inline Index() : level_(0), i_(0), j_(0), k_(0) {}
      inline Index(uchar l, uchar m, uchar n, index_type i, index_type j, index_type k) :
  level_(l), i_(i), j_(j), k_(k) { level_.l_[1] = m; level_.l_[2] = n; }
      inline Index(const Index& i) : level_(i.level_), i_(i.i_), j_(i.j_),
             k_(i.k_) {}
    };
 
    friend std::ostream& operator<<(std::ostream& os,
            const Hexahedron3d::Index& i);
 
    Hexahedron3d(Hexahedron& cntr, const MappingHexahedron3d& map);
    virtual ~Hexahedron3d();
  
    virtual Hexahedron3d* child(uint i);
    virtual const Hexahedron3d* child(uint i) const;
    inline Hexahedron& connector() const { return cntr_; }
 
    Real3d chi(Real xi, Real eta, Real zeta) const;
 
    Real3d elemMap(const Real3d& coord_local) const
    {
      return chi(coord_local[0], coord_local[1], coord_local[2]);
    }
    
    MapReal3d jacobian(const Real xi, const Real eta, const Real zeta) const;
 
    MapReal3d jacobian(const concepts::Real3d& p) const;
 
  /*
   * Hessian of the mapping
   */
 
    MapReal3d hessian(const uint i,const Real xi, const Real eta, const Real zeta) const;
 
    MapReal3d hessian(const uint i,const concepts::Real3d& p) const;
 
    MapReal3d jacobianInverse(const Real xi, const Real eta,
            const Real zeta) const {
      return jacobian(xi, eta, zeta).inverse();
    }
 
    Real jacobianDeterminant(const Real xi, const Real eta,
           const Real zeta) const {
      return jacobian(xi, eta, zeta).determinant();
    }
 
    const Level<3>& level() const { return idx_.level_; }
 
    Real3d vertex(uint i) const;
    Real3d center() const {return chi(0.5, 0.5, 0.5);};
    
    inline const MappingHexahedron3d* map() const {return map_;};
        
    MappingQuad3d* faceMap(uint face) const;
 
    void setStrategy(const Hex3dSubdivision* strategy = 0);
 
    const Hex3dSubdivision* getStrategy() const { return subdivStrategy_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    Index idx_;
 
    Hexahedron& cntr_;
 
    Hexahedron3d* lnk_;
 
    Hexahedron3d* chld_;
 
    MappingHexahedron3d* map_;
 
    const Hex3dSubdivision* subdivStrategy_;
 
    Hexahedron3d(Hexahedron& cntr, MappingHexahedron3d* map, 
     const Index& idx);
  };
 
  // ****************************************************** Parallelepiped3d **
 
  class Parallelepiped3d : public Cell3 {
  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;
 
    struct Index {
      uchar  l_;
 
      index_type i_;
 
      index_type j_;
 
      index_type k_;
 
      inline Index() : l_(0), i_(0), j_(0), k_(0) {}
      inline Index(uchar l, index_type i, index_type j, index_type k) :
  l_(l), i_(i), j_(j), k_(k) {}
      inline std::ostream& info(std::ostream& os) const;
    };
 
    Parallelepiped3d(Hexahedron& cntr, const MapParallelepiped3d& map);
    virtual ~Parallelepiped3d();
  
    virtual Parallelepiped3d* child(uint c);
    virtual const Parallelepiped3d* child(uint c) const;
    Hexahedron& connector() const { return cntr_; }
 
    Real3d chi(Real xi, Real eta, Real zeta) const;
    Real3d center() const {return chi(0.5, 0.5, 0.5);};
 
    Real3d vertex(uint i) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    Index idx_;
 
    Hexahedron& cntr_;
 
    Parallelepiped3d* lnk_;
 
    Parallelepiped3d* chld_;
 
    MapParallelepiped3d* map_;
 
    Parallelepiped3d(Hexahedron& cntr, MapParallelepiped3d* map, 
         const Index& idx);
  };
 
  inline std::ostream& Parallelepiped3d::Index::info(std::ostream& os) const {
    return os << '(' << (uint)l_ << ", " 
        << i_ << ", " << j_ << ", " << k_ << ')';
  }
 
} // namespace concepts
 
#endif // cell3D_hh