parti_parmetis.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/base_header.hpp>
 
#if defined(FEAT_HAVE_PARMETIS) || defined(DOXYGEN)
#include <kernel/util/dist.hpp>
#include <kernel/adjacency/graph.hpp>
#include <kernel/adjacency/coloring.hpp>
#include <kernel/geometry/conformal_mesh.hpp>
 
namespace FEAT
{
  namespace Geometry
  {
    class PartiParMETIS
    {
    private:
      const Dist::Comm& _comm;
      Dist::Comm _sub_comm;
      int _max_procs;
      Index _min_elems;
      Index _num_elems;
      Index _num_parts;
      Index _first_elem;
      Index _num_local_elems;
      Adjacency::Graph _subgraph;
      std::vector<Real> _midpoints;
      std::vector<Real> _weights;
      std::vector<Index> _parts;
      Adjacency::Coloring _coloring;
 
    public:
      explicit PartiParMETIS(const Dist::Comm& comm, Index min_elems = 1000u, int max_procs = 1000);
 
      virtual ~PartiParMETIS();
 
      template<int nf_, int nv_, typename VertexSet_>
      bool execute(const IndexSet<nf_>& faces_at_elem, const IndexSet<nv_>& verts_at_elem,
        const VertexSet_& vertices, const Index num_parts, const std::vector<Real>& weights)
      {
        Adjacency::Graph graph(Adjacency::RenderType::as_is, faces_at_elem);
        _create_subgraph(graph, num_parts);
        _compute_midpoints(verts_at_elem, vertices);
        _weights = weights;
        return _execute();
      }
 
      Adjacency::Graph build_elems_at_rank() const
      {
        return _coloring.create_partition_graph();
      }
 
      int get_sub_comm_size() const
      {
        return _sub_comm.size();
      }
 
    protected:
      void _create_subgraph(const Adjacency::Graph& faces_at_elem, const Index num_parts);
      bool _execute();
      bool _apply_parmetis();
      bool _gather_coloring();
      bool _broadcast_coloring(bool metis_ok);
      template<int nv_, typename VertexSet_>
      void _compute_midpoints(const IndexSet<nv_>& verts_at_elem, const VertexSet_& vertices)
      {
        typename VertexSet_::VertexType vx;
        const Real sc = Real(1) / Real(verts_at_elem.num_indices);
        static constexpr int nc = VertexSet_::num_coords;
        _midpoints.reserve(_num_local_elems * Index(nc));
        for(Index i(0); i < _num_local_elems; ++i)
        {
          vx.format();
          for(int j(0); j < verts_at_elem.num_indices; ++j)
            vx += vertices[verts_at_elem(i,j)];
          for(int k(0); k < nc; ++k)
            _midpoints.push_back(Real(vx[k]) * sc);
        }
      }
    }; // class PartiParMETIS
  } // namespace Geometry
} // namespace FEAT
 
#endif // FEAT_HAVE_PARMETIS