OrthogonalRecursiveBisection.h

//
// Class OrthogonalRecursiveBisection for Domain Decomposition
//
// Simple domain decomposition using an Orthogonal Recursive Bisection,
// domain is divided recursively so as to even weights on each side of the cut,
// works with 2^n processors only.
//
//
 
#ifndef IPPL_ORTHOGONAL_RECURSIVE_BISECTION_H
#define IPPL_ORTHOGONAL_RECURSIVE_BISECTION_H
 
#include "FieldLayout/FieldLayout.h"
#include "Index/Index.h"
#include "Index/NDIndex.h"
#include "Particle/ParticleAttrib.h"
#include "Particle/ParticleSpatialLayout.h"
#include "Region/NDRegion.h"
 
namespace ippl {
    /*
     * @class OrthogonalRecursiveBisection
     * @tparam Field the field type
     * @tparam Tp type of particle position. If not specified, it will be equal to the field's type
     */
 
    template <class Field, class Tp = typename Field::value_type>
    class OrthogonalRecursiveBisection {
        constexpr static unsigned Dim = Field::dim;
        using mesh_type               = typename Field::Mesh_t;
        using Tf                      = typename Field::value_type;
 
    public:
        // Weight for reduction
        Field bf_m;
 
        void initialize(FieldLayout<Dim>& fl, mesh_type& mesh, const Field& rho);
 
        template <typename Attrib>
        bool binaryRepartition(const Attrib& R, FieldLayout<Dim>& fl,
                               const bool& isFirstRepartition);
 
        int findCutAxis(NDIndex<Dim>& dom);
 
        void perpendicularReduction(std::vector<Tf>& rankWeights, unsigned int cutAxis,
                                    NDIndex<Dim>& dom);
 
        int findMedian(std::vector<Tf>& w);
 
        void cutDomain(std::vector<NDIndex<Dim>>& domains, std::vector<int>& procs, int it,
                       int cutAxis, int median);
 
        template <typename Attrib>
        void scatterR(const Attrib& r);
 
    };  // class
 
}  // namespace ippl
 
#include "Decomposition/OrthogonalRecursiveBisection.hpp"
 
#endif  // IPPL_ORTHOGONAL_RECURSIVE_BISECTION_H