geometry/cell3D.hh

Go to the documentation of this file.

/* 3D cells, ie. hexahedrons and tetrahedrons
 * Geometrical information (coordinates), brings element maps and
 * topology together
 */

#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:
    struct Index {
      uchar  l_;

      ushort i_;

      ushort j_;

      ushort k_;

      inline Index() : l_(0), i_(0), j_(0), k_(0) {}
      inline Index(uchar l, ushort i, ushort j, ushort 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::auto_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::auto_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::auto_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::auto_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::auto_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::auto_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::auto_ptr<Hex3dSubdiv4z> instance_;
  };

  // ********************************************************** Hexahedron3d **

  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:
    struct Index {
      Level<3> level_;

      ushort i_;

      ushort j_;

      ushort k_;

      inline Index() : level_(0), i_(0), j_(0), k_(0) {}
      inline Index(uchar l, uchar m, uchar n, ushort i, ushort j, ushort 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 MapHexahedron3d& 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 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 MapHexahedron3d* map() const {return map_;};

    void setStrategy(const Hex3dSubdivision* strategy = 0)
      throw(StrategyChange);

    const Hex3dSubdivision* getStrategy() const { return subdivStrategy_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    Index idx_;

    Hexahedron& cntr_;

    Hexahedron3d* lnk_;

    Hexahedron3d* chld_;

    MapHexahedron3d* map_;

    const Hex3dSubdivision* subdivStrategy_;

    Hexahedron3d(Hexahedron& cntr, MapHexahedron3d* map, 
     const Index& idx);
  };

  // ****************************************************** Parallelepiped3d **

  class Parallelepiped3d : public Cell3 {
  public:
    struct Index {
      uchar  l_;

      ushort i_;

      ushort j_;

      ushort k_;

      inline Index() : l_(0), i_(0), j_(0), k_(0) {}
      inline Index(uchar l, ushort i, ushort j, ushort 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