hp3D/shortestDist.hh

Go to the documentation of this file.

/* weighted functions for regularization, which takes
   the vertex or edge with shortest distance
*/

#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