hp3D/hexahedron.hh

Go to the documentation of this file.

/* hexahedral element for 3D hp FEM
 */

#ifndef hexahedron_hh
#define hexahedron_hh

#include <iostream>
#include <memory>
#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"
#include "geometry/cell3D.hh"
#include "integration/quadrature.hh"
#include "integration/karniadakis.hh"
#include "space/tmatrix.hh"
#include "space/hpMethod.hh"
#include "element.hh"
#include "hexahedronGraphics.hh"

// 0: Gauss Lobatto (good for graphics)
// 4: Gauss Jacobi (highest order)
#ifdef INTEGRATION_RULE
#undef INTEGRATION_RULE
#endif
#define INTEGRATION_RULE 4

namespace hp3D {

  using concepts::Real;

  // ************************************************************ Hexahedron **

  class Hexahedron : public Element<Real> {
  public:
    Hexahedron(concepts::Hexahedron3d& cell, const ushort* p, 
         concepts::TColumn<Real>* T0, concepts::TColumn<Real>* T1);
    virtual ~Hexahedron();

    virtual const concepts::Hexahedron& support() const {
      return cell_.connector(); }
    virtual concepts::Real3d vertex(uint i) const { return cell_.vertex(i); }
    virtual const concepts::Hexahedron3d& cell() const { return cell_; }

    inline const concepts::Karniadakis<1,0>* shpfctX() const {
      return shpfctX_.get(); }
    inline const concepts::Karniadakis<1,0>* shpfctY() const {
      return shpfctY_.get(); }
    inline const concepts::Karniadakis<1,0>* shpfctZ() const {
      return shpfctZ_.get(); }

    inline const concepts::Karniadakis<1,1>* shpfctDX() const {
      return shpfctDX_.get(); }
    inline const concepts::Karniadakis<1,1>* shpfctDY() const {
      return shpfctDY_.get(); }
    inline const concepts::Karniadakis<1,1>* shpfctDZ() const {
      return shpfctDZ_.get(); }

    inline const concepts::Quadrature<INTEGRATION_RULE>* integrationX() const {
      return intX_.get(); }
    inline const concepts::Quadrature<INTEGRATION_RULE>* integrationY() const {
      return intY_.get(); }
    inline const concepts::Quadrature<INTEGRATION_RULE>* integrationZ() const {
      return intZ_.get(); }

    inline concepts::Real3d chi(const Real x, const Real y,
        const Real z) const {
      return cell_.chi(x, y, z); }

    inline concepts::MapReal3d jacobian(const Real x, const Real y,
          const Real z) const {
      concepts::MapReal3d jac = cell_.jacobian(x, y, z);
      jac *= 0.5;
      return jac; }

    inline concepts::MapReal3d jacobianInverse(const Real x, const Real y, 
                 const Real z) const {
      return jacobian(x, y, z).inverse(); }

    inline Real jacobianDeterminant(const Real x, const Real y,
            const Real z) const {
      return jacobian(x, y, z).determinant(); }

    void setStrategy(const concepts::Hex3dSubdivision* strategy = 0)
      throw(concepts::StrategyChange) { cell_.setStrategy(strategy); }

    const concepts::Hex3dSubdivision* getStrategy() const {
      return cell_.getStrategy(); }

    virtual const concepts::ElementGraphics<Real>* graphics() const;

    virtual bool operator<(const Element<Real>& elm) const;

    bool hasSameMatrix(const Hexahedron& elm) const;

    void edgeP(const uint i, const concepts::AdaptiveControlP<1>& p) {
      conceptsAssert(i < 12, concepts::Assertion());
      edges_[i] = &p; }
    const concepts::AdaptiveControlP<1>& edgeP(const uint i) const {
      conceptsAssert(i < 12, concepts::Assertion());
      conceptsAssert(edges_[i], concepts::Assertion());
      return *(edges_[i]); }
    void faceP(const uint i, const concepts::AdaptiveControlP<2>& p) {
      conceptsAssert(i < 6, concepts::Assertion());
      faces_[i] = &p; }
    const concepts::AdaptiveControlP<2>& faceP(const uint i) const {
      conceptsAssert(i < 6, concepts::Assertion());
      conceptsAssert(faces_[i], concepts::Assertion());
      return *(faces_[i]); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    concepts::Hexahedron3d& cell_;
    std::auto_ptr<concepts::Karniadakis<1,0> > shpfctX_, shpfctY_, shpfctZ_;
    std::auto_ptr<concepts::Karniadakis<1,1> > shpfctDX_, shpfctDY_, shpfctDZ_;
    std::auto_ptr<concepts::Quadrature<INTEGRATION_RULE> > intX_, intY_, intZ_;

    const concepts::AdaptiveControlP<1>* edges_[12];
    const concepts::AdaptiveControlP<2>* faces_[6];

    static std::auto_ptr<HexahedronGraphics> graphics_;
  };

} // namespace hp3D

#endif // hexahedron_hh