parti_2lvl.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
#include <kernel/adjacency/graph.hpp>
#include <kernel/geometry/conformal_mesh.hpp>
#include <kernel/geometry/intern/standard_refinement_traits.hpp>
#include <kernel/util/assertion.hpp>
 
namespace FEAT
{
  namespace Geometry
  {
    namespace Intern
    {
      template<typename Shape_>
      struct Parti2LvlHelper
      {
        static constexpr Index factor = StandardRefinementTraits<Shape_, Shape_::dimension>::count;
        static constexpr Index lvlinc = Index(1);
      };
 
      template<int dim_>
      struct Parti2LvlHelper<Shape::Hypercube<dim_>>
      {
        static constexpr Index factor = Index(2);
        static constexpr Index lvlinc = Index(dim_);
      };
    } // namespace Intern
 
    template<typename Mesh_>
    class Parti2Lvl;
 
    template<typename Shape_, int num_coords_, typename Coord_>
    class Parti2Lvl<ConformalMesh<Shape_, num_coords_, Coord_>>
    {
    public:
      typedef ConformalMesh<Shape_, num_coords_, Coord_> MeshType;
 
    protected:
      const Index _num_elems;
      const Index _num_ranks;
      bool _success;
      Index _ref_lvl;
      Index _ref_elems;
 
    public:
      explicit Parti2Lvl(const MeshType& mesh, Index num_ranks) :
        _num_elems(mesh.get_num_elements()),
        _num_ranks(num_ranks),
        _success(false),
        _ref_lvl(0),
        _ref_elems(0)
      {
        XASSERT(num_ranks > Index(0));
 
        const Index factor = Intern::Parti2LvlHelper<Shape_>::factor;
        const Index lvlinc = Intern::Parti2LvlHelper<Shape_>::lvlinc;
        Index count(_num_elems);
        Index power(0);
 
        while(count < _num_ranks)
        {
          count *= factor;
          ++power;
        }
 
        if(count != _num_ranks)
        {
          // no 2-level partitioning possible
          return;
        }
 
        _success = true;
 
        // compute refinement level
        _ref_lvl = (power + lvlinc - Index(1)) / lvlinc;
 
        // compute refined element count
        const Index ref_fac(Intern::StandardRefinementTraits<Shape_, Shape_::dimension>::count);
        _ref_elems = _num_elems;
        for(Index i(0); i < _ref_lvl; ++i)
          _ref_elems *= ref_fac;
      }
 
      bool success() const
      {
        return _success;
      }
 
      Index parti_level() const
      {
        return _ref_lvl;
      }
 
      Adjacency::Graph build_elems_at_rank() const
      {
        Adjacency::Graph graph(_num_ranks, _ref_elems, _ref_elems);
        Index* ptr = graph.get_domain_ptr();
        Index* idx = graph.get_image_idx();
 
        // build pointer array
        const Index elems_per_rank = _ref_elems / _num_ranks;
        for(Index i(0); i <= _num_ranks; ++i)
          ptr[i] = elems_per_rank * i;
 
        // build index array
        for(Index i(0); i < _ref_elems; ++i)
          idx[i] = i;
 
        return graph;
      }
    }; // class Parti2Lvl
  } // namespace Geometry
} // namespace FEAT