patch_meshpart_factory.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
 
// includes, FEAT
#include <kernel/adjacency/graph.hpp>
#include <kernel/geometry/mesh_part.hpp>
 
namespace FEAT
{
  namespace Geometry
  {
    template<typename MeshType_>
    class PatchMeshPartFactory : public Factory< MeshPart<MeshType_> >
    {
    public:
      typedef typename MeshType_::ShapeType ShapeType;
      typedef MeshPart<MeshType_> MeshPartType;
      typedef typename MeshType_::VertexSetType::CoordType AttributeDataType;
      typedef typename MeshPartType::AttributeSetContainer AttributeSetContainer;
      typedef typename MeshPartType::IndexSetHolderType IndexSetHolderType;
      typedef typename MeshPartType::TargetSetHolderType TargetSetHolderType;
      static constexpr int shape_dim = ShapeType::dimension;
 
    private:
      std::vector<Index> _cells_patch;
 
    public:
      explicit PatchMeshPartFactory(Index my_rank, const Adjacency::Graph& elems_at_rank)
      {
        XASSERT(my_rank < elems_at_rank.get_num_nodes_domain());
 
        // extract the elements of our rank
        _cells_patch.reserve(elems_at_rank.degree(my_rank));
        for(auto it = elems_at_rank.image_begin(my_rank); it != elems_at_rank.image_end(my_rank); ++it)
          _cells_patch.push_back(*it);
      }
 
      explicit PatchMeshPartFactory(std::vector<Index>&& cells_patch) :
        _cells_patch(std::forward<std::vector<Index>>(cells_patch))
      {
      }
 
      virtual ~PatchMeshPartFactory()
      {
      }
 
      bool empty() const
      {
        return _cells_patch.empty();
      }
 
      virtual Index get_num_entities(int dim) override
      {
        XASSERT(dim >= 0);
        XASSERT(dim <= shape_dim);
        return (dim < shape_dim ? Index(0) : Index(_cells_patch.size()));
      }
 
      virtual void fill_attribute_sets(AttributeSetContainer& DOXY(attribute_set_holder)) override
      {
        // Do nothing
        return;
      }
 
      virtual void fill_index_sets(std::unique_ptr<IndexSetHolderType>& DOXY(index_set_holder)) override
      {
        // Do nothing
        return;
      }
 
      virtual void fill_target_sets(TargetSetHolderType& target_set_holder) override
      {
        TargetSet& target_set = target_set_holder.template get_target_set<shape_dim>();
        for(Index k(0); k < Index(_cells_patch.size()); ++k)
          target_set[k] = _cells_patch[k];
      }
    }; // class PatchMeshPartFactory<MeshPart<...>>
  } // namespace Geometry
} // namespace FEAT