mappingEdge3D.hh

Go to the documentation of this file.

#ifndef MAPPINGEDGE3D_HH
#define MAPPINGEDGE3D_HH
 
#include "geometry/elementMaps.hh"
// #include "basics/outputOperator.hh"
// #include "basics/typedefs.hh"
// #include "basics/vectorsMatrices.hh"
// #include "basics/cloneable.hh"
#include "basics.hh"
#include "toolbox/sequence.hh"
#include "toolbox/arrayOp.hh"
 
#include <array>
 
namespace concepts {
 
 
  // ********************************************************* MappingEdge3d **
 
  class MappingEdge3d : public Map1d {
  public:
    MappingEdge3d(const Real3d& vtx0, const Real3d& vtx1);
    MappingEdge3d(const MappingEdge3d& other);
    ~MappingEdge3d() override;
    virtual MappingEdge3d* clone() const = 0;
    virtual MappingEdge3d* inverse() const = 0;
    virtual Real3d operator()(const Real t) const = 0;
    virtual Real3d derivative(const Real t, const uint n = 1) const = 0;
    inline const Real3d& vtx(uint i) const {return vtx_[i];}
  protected:
    std::ostream& info(std::ostream& os) const override;
    std::array<Real3d,2> vtx_;
  };
 
 
  // ************************************************* MappingQuadEdge3d **  
  // Implementation of this class not yet done since not required to generate
  // 3d geometry with curved hexahedra
  
  // ************************************************* MappingStraightEdge3d **
 
  class MappingStraightEdge3d : public MappingEdge3d {
  public:
    MappingStraightEdge3d(const Real3d& vtx0, const Real3d& vtx1);
    MappingStraightEdge3d(const MappingStraightEdge3d& other);
    ~MappingStraightEdge3d() override;
    MappingStraightEdge3d* clone() const override;
    MappingStraightEdge3d* inverse() const override;
    Real3d operator()(const Real t) const override;
    Real3d derivative(const Real t, const uint n = 1) const override;
  protected:
    std::ostream& info(std::ostream& os) const override;
  };
  
  
  // ************************************************** CircleMappingEdge3d **
 
  class CircleMappingEdge3d : public MappingEdge3d {
  public:
    CircleMappingEdge3d(const Real3d& vtx0, const Real3d& vtx1,
                        const Real radius,  const Real3d& center,
                        const Real tol=1e6*std::numeric_limits<double>::epsilon());
 
    CircleMappingEdge3d(const CircleMappingEdge3d& other);
    ~CircleMappingEdge3d() override;
    CircleMappingEdge3d* clone() const override;
    CircleMappingEdge3d* inverse() const override;
    Real3d operator()(const Real t) const override;
    Real3d derivative(const Real t, const uint n = 1) const override;
    Real   getRadius() const {return radius_;}
    Real3d getCenter() const {return center_;}    
  protected:
    std::ostream& info(std::ostream& os) const override;
  private:
    Real radius_;
    Real3d center_;
  };
 
  // ************************************************** MappingHexahedronEdge3d **
 
  // forward declaration
  class MappingHexahedron3d;
 
  class MappingHexahedronEdge3d : public MappingEdge3d {
  public:
    MappingHexahedronEdge3d(const MappingHexahedron3d& map, const uint edge);
    MappingHexahedronEdge3d(const MappingHexahedron3d& map,
                            const Real3d xi, const Real3d diff);
    MappingHexahedronEdge3d(const MappingHexahedronEdge3d& other);
    MappingHexahedronEdge3d* clone() const override;
    ~MappingHexahedronEdge3d() override {};
    Real3d operator()(const Real t) const override;
    Real3d derivative(const Real t, const uint n = 1) const override;
    MappingHexahedronEdge3d* inverse() const override;
  protected:
    std::ostream& info(std::ostream& os) const override;
  private:
    std::unique_ptr<MappingHexahedron3d> map_;
    Real3d xi_, diff_;
 
    inline const Real3d lcoord_(const Real t) const {
      return xi_ + diff_*t;
    }
    inline const Real3d lderiv_(const Real t) const {
      return diff_;
    }
  };  
 
    
} // namespace concepts
 
#endif // MAPPINGEDGE3D_HH