cluster.hpp

Go to the documentation of this file.

 
#ifndef NIHU_CLUSTER_HPP_INCLUDED
#define NIHU_CLUSTER_HPP_INCLUDED
 
#include "bounding_box.hpp"
#include "util/crtp_base.hpp"
 
#include <algorithm>    // std::find, std::copy
#include <cstddef>
#include <iostream>     // std::ostream
#include <iterator>     // std::ostream_iterator
#include <vector>       // idx_list
#include <stdexcept>    // std::logic_error
 
namespace NiHu
{
namespace fmm
{
template <class Derived>
struct cluster_traits;
 
template <class Derived>
class cluster_base
{
public:
    typedef cluster_traits<Derived> traits_t;
 
    static size_t const dimension = traits_t::dimension;
 
    typedef bounding_box<dimension, double> bounding_box_t;
    typedef typename bounding_box_t::location_t location_t;
 
    typedef std::vector<size_t> idx_list_t;
 
    typedef typename traits_t::multipole_t multipole_t;
    typedef typename traits_t::local_t local_t;
 
public:
    NIHU_CRTP_HELPERS
    
    void set_level(size_t level)
    {
        m_level = level;
    }
 
    size_t get_level() const
    {
        return m_level;
    }
 
    void set_parent(size_t parent)
    {
        m_parent = parent;
    }
 
    size_t get_parent() const
    {
        return m_parent;
    }
 
    void set_bounding_box(bounding_box_t const &bb)
    {
        m_bb = bb;
    }
 
    bounding_box_t const &get_bounding_box() const
    {
        return m_bb;
    }
 
    void set_src_node_idx(idx_list_t const &node_idx)
    {
        m_src_node_idx = node_idx;
    }
 
    template <class ForwardIt>
    void set_src_node_idx(ForwardIt begin, ForwardIt end)
    {
        m_src_node_idx = idx_list_t(begin, end);
    }
 
    idx_list_t const &get_src_node_idx() const
    {
        return m_src_node_idx;
    }
 
    size_t get_n_src_nodes() const
    {
        return m_src_node_idx.size();
    }
 
    void set_rec_node_idx(idx_list_t const &node_idx)
    {
        m_rec_node_idx = node_idx;
    }
 
    template <class ForwardIt>
    void set_rec_node_idx(ForwardIt begin, ForwardIt end)
    {
        m_rec_node_idx = idx_list_t(begin, end);
    }
 
    idx_list_t const &get_rec_node_idx() const
    {
        return m_rec_node_idx;
    }
 
    size_t get_n_rec_nodes() const
    {
        return m_rec_node_idx.size();
    }
 
    void add_child(size_t child)
    {
        if (std::find(m_children.begin(), m_children.end(), child) ==
            m_children.end())
            m_children.push_back(child);
        else throw std::logic_error("Child already contained");
    }
 
    idx_list_t const &get_children() const
    {
        return m_children;
    }
 
    bool is_leaf() const
    {
        return m_children.empty();
    }
 
    bool is_root() const
    {
        return m_level == 0;
    }
 
    bool is_source() const
    {
        return !m_src_node_idx.empty();
    }
 
    bool is_receiver() const
    {
        return !m_rec_node_idx.empty();
    }
 
    void print_debug(std::ostream &os = std::cout) const
    {
        os << "Level:" << this->get_level() << std::endl;
        os << "Bounding box: " << m_bb << std::endl;
        std::ostream_iterator<size_t> out_it(os, ", ");
        os << "Source indices:" << std::endl;
        std::copy(this->get_src_node_idx().begin(), this->get_src_node_idx().end(), out_it);
        os << std::endl;
        os << "Receiver indices:" << std::endl;
        std::copy(this->get_rec_node_idx().begin(), this->get_rec_node_idx().end(), out_it);
    }
 
    multipole_t zero_multipole() const
    {
        return derived().zero_multipole();
    }
 
    local_t zero_local() const
    {
        return derived().zero_local();
    }
 
private:
    bounding_box_t m_bb;
    size_t m_level;
    size_t m_parent;
    idx_list_t m_children;
 
    idx_list_t m_src_node_idx;
    idx_list_t m_rec_node_idx;
};
 
template <class Derived>
std::ostream &operator<<(std::ostream &os, cluster_base<Derived> const &c)
{
    c.print_debug(os);
    return os;
}
 
} // namespace fmm
} // namespace NiHu
 
#endif /* NIHU_CLUSTER_HPP_INCLUDED */