distributor.h

Go to the documentation of this file.

#ifndef _RHEO_DISTRIBUTOR_H
#define _RHEO_DISTRIBUTOR_H

# include "rheolef/distributed.h"
# include "rheolef/dis_macros.h"
# include "rheolef/Vector.h"

namespace rheolef {

class distributor : public Vector<std::allocator<int>::size_type> {
public:


        typedef std::allocator<int>::size_type size_type;
        typedef Vector<size_type>              _base;
        typedef _base::iterator                iterator;
        typedef _base::const_iterator          const_iterator;
        typedef int                            tag_type;
        typedef communicator                   communicator_type;


        static const size_type decide = size_type(-1);

// allocators/deallocators:

        distributor(
                size_type dis_size = 0,
                const communicator_type& c = communicator_type(),
                size_type loc_size = decide);

        distributor(const distributor&);
        ~distributor();

        void resize(
                size_type dis_size = 0,
                const communicator_type& c = communicator_type(),
                size_type loc_size = decide);


        const communicator_type& comm() const;

        size_type dis_size () const;

        size_type process () const;
        
        size_type n_process () const;

        size_type find_owner (size_type dis_i) const;

        size_type first_index (size_type ip) const;
        size_type last_index (size_type ip) const;
        size_type size (size_type ip) const;

        size_type first_index () const;
        size_type last_index () const;
        size_type size () const;

        bool is_owned (size_type dis_i, size_type ip) const;

        bool is_owned (size_type dis_i) const;


        static tag_type get_new_tag();


        bool operator== (const distributor&) const;
        bool operator!= (const distributor&) const;
protected:
        communicator_type _comm;
};
@endcode

inline
const distributor::communicator_type&
distributor::comm() const
{
        return _comm;
}
inline
distributor::size_type
distributor::first_index(size_type j) const 
{
        return at(j);
}
inline
distributor::size_type
distributor::last_index(size_type j) const 
{
        return at(j+1);
}
inline
distributor::size_type
distributor::size(size_type j) const 
{
        return last_index(j) - first_index(j);
}
inline
distributor::size_type
distributor::n_process() const 
{
#ifdef _RHEOLEF_HAVE_MPI
        return _comm.size();
#else // _RHEOLEF_HAVE_MPI
        return 1;
#endif // _RHEOLEF_HAVE_MPI
}
inline
distributor::size_type
distributor::process() const 
{
#ifdef _RHEOLEF_HAVE_MPI
        return _comm.rank();
#else // _RHEOLEF_HAVE_MPI
        return 0;
#endif // _RHEOLEF_HAVE_MPI
}
inline
distributor::size_type
distributor::first_index() const 
{
        return first_index(process());
}
inline
distributor::size_type
distributor::last_index() const 
{
        return last_index(process());
}
inline
distributor::size_type
distributor::size() const 
{
        return size(process());
}
inline
distributor::size_type
distributor::dis_size() const 
{
        return at(n_process());
}
inline
bool
distributor::is_owned (size_type dis_i, size_type ip) const
{
        return dis_i >= first_index(ip) && dis_i < last_index(ip);
}
inline
bool
distributor::is_owned (size_type dis_i) const
{
        return is_owned (dis_i, process());
}
inline
bool
distributor::operator!= (const distributor& x) const
{
  return !operator==(x);
}
inline
bool
distributor::operator== (const distributor& x) const
{
  return (x.n_process() == n_process()) && (x.size() == size()) && (x.dis_size() == dis_size());
}

} // namespace rheolef
#endif // _RHEO_DISTRIBUTOR_H