BasicRelax_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_DOMAINS_BASICRELAX_FWD_HPP_
#define MEDUSA_BITS_DOMAINS_BASICRELAX_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <medusa/bits/types/Range_fwd.hpp>
 
namespace mm {
 
 
class BasicRelax {
  public:
    enum ProjectionType {
        DO_NOT_PROJECT,
        PROJECT_IN_DIRECTION,
        PROJECT_BETWEEN_CLOSEST
    };
 
  private:
    int num_neighbours = 1;  
    int num_iterations = 50;  
    double initial_heat = 1;  
    double final_heat = 0;  
    int potential_order = 2;  
    int rebuild_tree_after = 1;  
    Range<int> nodes_;  
    ProjectionType projection_type = DO_NOT_PROJECT;  
    double boundary_projection_threshold = 0.75;  
 
  public:
    BasicRelax() = default;
 
    BasicRelax& onlyNodes(Range<int> nodes);
 
    BasicRelax& initialHeat(double in);
 
    BasicRelax& finalHeat(double in);
 
    BasicRelax& numNeighbours(int neighbours);
 
    BasicRelax& potentialOrder(int order);
 
    BasicRelax& iterations(int iterations);
 
    BasicRelax& rebuildTreeAfter(int iterations);
 
    BasicRelax& projectionType(ProjectionType in);
 
    BasicRelax& boundaryProjectionThreshold(double in);
 
    template<class domain_t>
    void operator()(domain_t& domain) const {
        typedef typename domain_t::vector_t vec_t;
        operator()(domain, [](const vec_t& /* p */) { return -1.0; });
    }
 
    template<class domain_t>
    void operator()(domain_t& domain, double r) const {
        typedef typename domain_t::vector_t vec_t;
        operator()(domain, [r](const vec_t& /* p */) { return r; });
    }
 
    template<class domain_t, class radius_func_type>
    void operator()(domain_t& domain, const radius_func_type& r_func) const;
};  // class BasicRelax
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_DOMAINS_BASICRELAX_FWD_HPP_