mappingQuad3D.hh

Go to the documentation of this file.

#ifndef MAPPINGQUAD3D_HH
#define MAPPINGQUAD3D_HH
 
#if __cplusplus >= 201103L
 
#include "basics/outputOperator.hh"
#include "basics/typedefs.hh"
#include "basics/vectorsMatrices.hh"
#include "basics/debug.hh"
#include "geometry/elementMaps.hh"
#include "geometry/elementMaps3D.hh"
#include "geometry/topology.hh"
 
#include "coordinateChange.hh"
#include "mappingEdge3D.hh"
 
#include <array>
#include <type_traits>
 
namespace concepts {
 
  // ********************************************************* MappingQuad3d **
 
  //forward declaration
  class MappingEdge3d;
  
  class MappingQuad3d : public Map2d {
  public:
    virtual ~MappingQuad3d() {}
    // FIXME: Coordinate parameters should be constant
    virtual Real3d operator()(Real x, Real y) const = 0;
 
    virtual Real faceElement(const Real x, const Real y) const;
 
    virtual Real3d jacobianColumn(uint i, const Real x, const Real y) const = 0;
    
    virtual Real3d hessianColumn(uint i, uint j, const Real x, const Real y) const = 0;
    
    virtual Real3d normal(const Real &x, const Real &y) const;
 
    virtual MappingEdge3d* edge(uint edge) const = 0;
 
    virtual MappingQuad3d* part(const Real2d &x0, const Real2d &y0) const;
    
    virtual MappingQuad3d* invertOrientation(const uint dir, const uint shift) const = 0;
    
    virtual MappingQuad3d* clone() const = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  // ********************************************************* PartMappingQuad3d **
  
  class PartMappingQuad3d : public MappingQuad3d {
  public:
    PartMappingQuad3d(const MappingQuad3d &map,
                      const Real2d &xi0, const Real2d &xi1);
    
    PartMappingQuad3d(const PartMappingQuad3d &partMap);
    
    PartMappingQuad3d* clone() const;
    
    virtual Real3d operator()(Real xi, Real eta) const;
    
    virtual Real3d jacobianColumn(uint i, const Real xi, const Real eta) const;
 
    virtual Real3d hessianColumn(uint i, uint j, const Real x, const Real y) const;
    virtual MappingEdge3d* edge(uint edge) const;
 
    virtual MappingQuad3d* invertOrientation(const uint dir, const uint shift) const;
    
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    
  private:
    std::unique_ptr<const MappingQuad3d> map_;
      
    const Real2d x0_;
    
    const Real2d d_;
    
    inline const Real2d xi_(const Real xi, const Real eta) const
    {
      return x0_ + Real2d(xi * d_[0], eta * d_[1]);
    }
  };      
      
  // ********************************************************** BilinearQuad3d **
 
  class BilinearQuad3d : public MappingQuad3d {
  public:
    BilinearQuad3d(Real3d vtx0, Real3d vtx1, Real3d vtx2, Real3d vtx3);
    BilinearQuad3d(const BilinearQuad3d& v);
    virtual ~BilinearQuad3d();
    virtual Real3d operator()(Real x, Real y) const;
 
    virtual Real3d jacobianColumn(uint i, const Real x, const Real y) const;
    virtual Real3d hessianColumn(uint i, uint j, const Real x, const Real y) const;
    
    virtual MappingEdge3d* edge(uint edge) const;
 
    virtual BilinearQuad3d* part(const Real2d &x0, const Real2d &y0) const;
    
    virtual BilinearQuad3d* invertOrientation(const uint dir, const uint shift) const;
 
    virtual BilinearQuad3d* clone() const;
 
    virtual bool straight() const { return true; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    Real3d vtx_[4];
    
    bool inputCheck(const Real3d &vtx0, const Real3d &vtx1, 
                    const Real3d &vtx2, const Real3d &vtx3) const;
  };
 
  
  // ********************************************************** BallQuad3d **
 
  class BallQuad3d : public MappingQuad3d {
  public:
 
      BallQuad3d(const Real3d& vtx0,const Real3d& vtx1,
                 const Real3d& vtx2,const Real3d& vtx3,
                 const Real radius,const Real3d& center);
      BallQuad3d(Sequence< CircleMappingEdge3d* > edgemap,
                  const Quad& quad);
      BallQuad3d(const CircleMappingEdge3d* edge0, const CircleMappingEdge3d* edge1,
                  const CircleMappingEdge3d* edge2, const CircleMappingEdge3d* edge3,
                  const Quad& quad);        
      BallQuad3d(Sequence< const MappingEdge3d* > edgemap,
                  const Real radius, const Real3d& center,
                  const Quad& quad);
      BallQuad3d(const MappingEdge3d* edge0, const MappingEdge3d* edge1,
                  const MappingEdge3d* edge2, const MappingEdge3d* edge3,
                  const Real radius, const Real3d& center,
                  const Quad& quad);
      BallQuad3d(const BallQuad3d& other);
 
      ~BallQuad3d() override;
      Real3d operator()(Real x, Real y) const override;
      Real3d jacobianColumn(uint i, const Real x, const Real y) const override;
      Real3d hessianColumn(uint i, uint j, const Real x, const Real y) const override;
 
      bool inverseMapping(const Real3d& physicalPoint, Real2d& coord) const;
      
      BallQuad3d* part(const Real2d& x0, const Real2d& y0) const override;
 
      MappingEdge3d* edge(const uint edge) const override;
 
      BallQuad3d* clone() const override;
      
      BallQuad3d* invertOrientation(const uint dir, const uint shift) const override;
 
      Real   getRadius() const { return radius_; }
      Real3d getCenter() const { return center_; }    
  protected:
      std::ostream& info(std::ostream& os) const override;
  private:
      std::array<Real3d,4> vtx_;
      
      Real radius_;
 
      Real3d center_;
      
/*      /// Map of the edges
      std::array<std::unique_ptr<MappingEdge3d>,4> edgemap_;*/
      
      void construct_(const std::array< const MappingEdge3d*,4 >& edgemap, const Quad& quad);
 
      bool isRegular() const;
  };
 
 
 
// ********************************************************* BlendingQuad3d **
 
  template<uint Dim>
  using MappingQuad = typename std::enable_if< (2u <= Dim && Dim <= 3u),
                                     typename std::tuple_element<Dim-2u,
                                     std::tuple<MappingQuad2d,MappingQuad3d>>::type>::type;
                                     
  template<uint Dim>
  using MappingEdge = typename std::enable_if< (1u <= Dim && Dim <= 3u),
                                     typename std::tuple_element<Dim-1u,
                                     std::tuple<MapEdge1d,MappingEdge2d,MappingEdge3d>>::type>::type;
  
  template<uint Dim>
  class BlendingQuad : public MappingQuad<Dim> {
  public:
 
      BlendingQuad(const Sequence< const MappingEdge<Dim>* > edgemap,
                     const Quad& quad);
      BlendingQuad(const MappingEdge<Dim>& edge0, const MappingEdge<Dim>& edge1,
                     const MappingEdge<Dim>& edge2, const MappingEdge<Dim>& edge3,
                     const Quad& quad);
      BlendingQuad(const BlendingQuad& other);
      ~BlendingQuad() override;
      Point<Real,Dim> operator()(Real x, Real y) const override;
      Point<Real,Dim> jacobianColumn(uint i, const Real x, const Real y) const override;
      Point<Real,Dim> hessianColumn(uint i, uint j, const Real x, const Real y) const override;
      MappingEdge<Dim>* edge(const uint edge) const override;
      BlendingQuad* invertOrientation(const uint dir, const uint shift) const override;
      BlendingQuad* clone() const override { return new BlendingQuad(*this); }
  protected:
      std::ostream& info(std::ostream& os) const override;
  private:
      std::array<std::unique_ptr<MappingEdge<Dim>>,4> edgemap_;
      /*/// Vector that contains the vertices.
      Point<Real,Dim> vtx_[4];*/
 
      void construct_(const std::array< const MappingEdge<Dim>*,4 >& edgemap, const Quad& quad);
  };
    
  using BlendingQuad3d = BlendingQuad<3u>;
 
  // ***************************************************** MappingHexahedronQuad3d **
 
  // forward declaration
  class MappingHexahedron3d;
  
  class MappingHexahedronQuad3d : public MappingQuad3d {
  public:
    MappingHexahedronQuad3d(const MappingHexahedron3d& map, const uint face);
    MappingHexahedronQuad3d(const MappingHexahedron3d& map,
                            const Real3d xi, 
                            const Real3d diff0, const Real3d diff1);
    MappingHexahedronQuad3d(const MappingHexahedronQuad3d& other);
    MappingHexahedronQuad3d* clone() const override;
    ~MappingHexahedronQuad3d() override {};
    Real3d operator()(Real x, Real y) const override;
    Real3d jacobianColumn(uint i, const Real x, const Real y) const override;
    Real3d hessianColumn(uint i, uint j, const Real x, const Real y) const override;
    MappingEdge3d* edge(const uint edge) const override;
    MappingHexahedronQuad3d* invertOrientation(const uint dir, const uint shift) const override;
  protected:
    std::ostream& info(std::ostream& os) const override;
  private:
    std::unique_ptr<MappingHexahedron3d> map_;
    Real3d xi_;
    std::array<Real3d,2> diff_;
 
    inline const Real3d lcoord_(const Real x, const Real y) const {
      return xi_ + diff_[0]*x + diff_[1]*y;
    }
    inline const Real3d lderiv_(uint i, const Real x, const Real y) const {
        return i == 0 ? diff_[0] : diff_[1];
    }
  };
  
} // namespace concepts
 
#endif // __cplusplus >= 201103L
 
#endif // mappingQuad3d_HH