hexahedron.hh

Go to the documentation of this file.

 
#ifndef hexahedron_hh
#define hexahedron_hh
 
#include <iostream>
#include <memory>
#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"
#include "toolbox/array.hh"
#include "geometry/cell3D.hh"
#include "geometry/integral.hh"
#include "integration/quadRule.hh"
#include "integration/karniadakis.hh"
#include "space/tmatrix.hh"
#include "space/hpMethod.hh"
#include "element.hh"
#include "hexahedronGraphics.hh"
 
#include <map>
 
 
namespace hp3D {
  //forward declaration
  class HexahedronGraphics;
  using concepts::Real; 
 
  // ************************************************************ Hexahedron **
 
  class Hexahedron : public Element<Real>, public concepts::IntegrationCell {
  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::QuadratureRule1d* integrationX() const {
      return intX_.get();
    }
    inline const concepts::QuadratureRule1d* integrationY() const {
      return intY_.get();
    }
    inline const concepts::QuadratureRule1d* 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();
    }
    inline concepts::MapReal3d hessian(const uint i, const Real x, const Real y,
        const Real z) const {
      concepts::MapReal3d hes = cell_.hessian(i,x, y, z);
      hes *= 0.25;
      return hes;
    }
 
    void setStrategy(const concepts::Hex3dSubdivision* strategy = 0)
    {
      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]);
    }
 
    static concepts::QuadRuleFactory& rule() {
      return rule_;
    }
 
    virtual bool quadraturePoint(uint i, intPoint &p, intFormType form,
                                 bool localCoord) const;
 
    void recomputeShapefunctions();
    void recomputeShapefunctions(const uint nq[2]);
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    void computeShapefunctions_(const concepts::QuadratureRule1d *intX,
        const concepts::QuadratureRule1d *intY,
        const concepts::QuadratureRule1d *intZ);
  private:
    concepts::Hexahedron3d& cell_;
    std::unique_ptr<concepts::Karniadakis<1, 0> > shpfctX_, shpfctY_, shpfctZ_;
    std::unique_ptr<concepts::Karniadakis<1, 1> > shpfctDX_, shpfctDY_, shpfctDZ_;
    std::unique_ptr<concepts::QuadratureRule1d> intX_, intY_, intZ_;
 
    const concepts::AdaptiveControlP<1>* edges_[12];
    const concepts::AdaptiveControlP<2>* faces_[6];
 
    static std::unique_ptr<HexahedronGraphics> graphics_;
 
    // Factory for the integration rule
    static concepts::QuadRuleFactory rule_;
 
    ushort p_[3];
        
  };
 
 
  // ****************************************************** ArrayHexaWeights **
 
  class ArrayHexaWeights : public concepts::Array<Real> {
  public:
    ArrayHexaWeights(const Hexahedron& hex);
  };
 
} // namespace hp3D
 
#endif // hexahedron_hh