shortestDist.hh

Go to the documentation of this file.

 
#ifndef shortestDist_hh
#define shortestDist_hh
 
#include <cmath>
#include "basics/vectorsMatrices.hh"
#include "singularSet.hh"
 
namespace hp3D {
 
  // forward declarations
  class Hexahedron;
  using concepts::Real;
 
  // ********************************************************* TrivialWeight **
 
  class TrivialWeight {
  public:
    Real operator()(const SingularSet&, concepts::Real3d,
        const Hexahedron*) const { return 1.0; }
  };
 
  std::ostream& operator<<(std::ostream& os, const TrivialWeight& p);
 
  // ********************************************************** ShortestDist **
 
  class ShortestDist {
  public:
    Real operator()(const SingularSet& singularities,
        concepts::Real3d point, const Hexahedron* elm) const;
  };
 
  std::ostream& operator<<(std::ostream& os, const ShortestDist& p);
 
  // ***************************************************** PostprocessSquare **
 
  class PostprocessSquare {
  public:
    static Real post(Real x) { return x*x; }
  };
 
  std::ostream& operator<<(std::ostream& os, const PostprocessSquare& p);
 
  // ******************************************************* PostprocessRoot **
 
  class PostprocessRoot {
  public:
    static Real post(Real x) { return std::sqrt(x); }
  };
 
  std::ostream& operator<<(std::ostream& os, const PostprocessRoot& p);
 
  // ****************************************************** PostprocessRoot4 **
 
  class PostprocessRoot4 {
  public:
    static Real post(Real x) { return std::sqrt(std::sqrt(x)); }
  };
 
  std::ostream& operator<<(std::ostream& os, const PostprocessRoot4& p);
 
  // ********************************************************* Postprocess34 **
 
  class Postprocess34 {
  public:
    static Real post(Real x) { return std::pow(x, 0.75); }
  };
 
  std::ostream& operator<<(std::ostream& os, const Postprocess34& p);
 
  // ********************************************************* Postprocess14 **
 
  class Postprocess14 {
  public:
    static Real post(Real x) { return std::pow(x, 0.25); }
  };
 
  std::ostream& operator<<(std::ostream& os, const Postprocess14& p);
 
  // ********************************************************** Postprocess4 **
 
  class Postprocess4 {
  public:
    static Real post(Real x) { return x*x*x*x; }
  };
 
  std::ostream& operator<<(std::ostream& os, const Postprocess4& p);
 
  // ********************************************************** Postprocess3 **
 
  class Postprocess3 {
  public:
    static Real post(Real x) { return x*x*x; }
  };
 
  std::ostream& operator<<(std::ostream& os, const Postprocess3& p);
 
  // ********************************************************** DistancePost **
 
  template<typename DistClass, typename Function>
  class DistancePost {
  public:
    Real operator()(const SingularSet& singularities,
        concepts::Real3d point, const Hexahedron* elm) const {
      return Function::post(dist_(singularities, point, elm));
    }
  private:
    DistClass dist_;
  };
 
  template<typename DistClass, typename Function>
  inline std::ostream& operator<<(std::ostream& os,
          const DistancePost<DistClass, Function>& p) {
    return os << Function() << '(' << DistClass() << ')';
  }
 
  // ********************************************************** ProductOfAll **
 
  class ProductOfAll {
  public:
    Real operator()(const SingularSet& singularities,
        concepts::Real3d point, const Hexahedron* elm) const;
  };  
 
  std::ostream& operator<<(std::ostream& os, const ProductOfAll& p);
 
  // *********************************************************** DaugeWeight **
 
  class DaugeWeight {
  public:
    Real operator()(const SingularSet& singularities,
        concepts::Real3d point, const Hexahedron* elm) const;
  };
 
  std::ostream& operator<<(std::ostream& os, const DaugeWeight& p);
 
  // *************************************************** ShortestDistLimited **
 
  class ShortestDistLimited {
  public:
    ShortestDistLimited() : shortestdist_() {}
    Real operator()(const SingularSet& singularities,
        concepts::Real3d point, const Hexahedron* elm) const {
      return shortestdist_(singularities, point, elm);
    }
  private:
    const ShortestDist shortestdist_;
  };
 
  std::ostream& operator<<(std::ostream& os, const ShortestDistLimited& p);
 
} // namespace hp3D
 
#endif // shortestDist_hh