partition_set.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>
#include <kernel/adjacency/dynamic_graph.hpp>
#include <kernel/adjacency/graph.hpp>
#include <kernel/adjacency/permutation.hpp>
#include <kernel/util/string.hpp>
 
#include <deque>
 
namespace FEAT
{
  namespace Geometry
  {
    class Partition
    {
    protected:
      String _name;
      int _prio;
      int _level;
 
      Adjacency::Graph _patches;
 
    public:
      Partition() :
        _prio(0),
        _level(0)
      {
      }
 
      explicit Partition(Adjacency::Graph&& graph_, const String& name_, int prio_ = 0, int level_ = 0) :
        _name(name_),
        _prio(prio_),
        _level(level_),
        _patches(std::forward<Adjacency::Graph>(graph_))
      {
      }
 
 
      explicit Partition(const Adjacency::DynamicGraph& graph_, const String& name_, int prio_ = 0, int level_ = 0) :
        _name(name_),
        _prio(prio_),
        _level(level_),
        _patches(Adjacency::RenderType::as_is, graph_)
      {
      }
 
      Partition(Partition&& other) :
        _name(other._name),
        _prio(other._prio),
        _level(other._level),
        _patches(std::forward<Adjacency::Graph>(other._patches))
      {
      }
 
      Partition& operator=(Partition&& other)
      {
        if(this == &other)
          return *this;
        _name = other._name;
        _prio = other._prio;
        _level = other._level;
        _patches = std::forward<Adjacency::Graph>(other._patches);
        return *this;
      }
 
      virtual ~Partition()
      {
      }
 
      Index size() const
      {
        return Index(_patches.get_num_nodes_domain());
      }
 
      Index get_num_patches() const
      {
        return Index(_patches.get_num_nodes_domain());
      }
 
      Index get_num_elements() const
      {
        return Index(_patches.get_num_nodes_image());
      }
 
      String get_name() const
      {
        return _name;
      }
 
      int get_priority() const
      {
        return _prio;
      }
 
      int get_level() const
      {
        return _level;
      }
 
      const Adjacency::Graph& get_patches() const
      {
        return _patches;
      }
 
      void permute(const Adjacency::Permutation& inv_perm)
      {
        _patches.permute_indices(inv_perm);
      }
    }; // class Partition
 
    class PartitionSet
    {
    protected:
      std::deque<Partition> _parts;
 
    public:
      PartitionSet()
      {
      }
 
      PartitionSet(PartitionSet&& other) :
        _parts(std::move(other._parts))
      {
      }
 
      virtual ~PartitionSet()
      {
      }
 
      void clear()
      {
        _parts.clear();
      }
 
      std::deque<Partition>& get_partitions()
      {
        return _parts;
      }
 
      const std::deque<Partition>& get_partitions() const
      {
        return _parts;
      }
 
      void add_partition(Partition&& part)
      {
        _parts.emplace_back(std::forward<Partition>(part));
      }
 
      const Partition* find_partition(int size, const String& name = "", int prio = 0) const
      {
        std::deque<String> names;
        if(!name.empty())
          names.push_back(name);
        return find_partition(size, names, prio);
      }
 
      const Partition* find_partition(int size, const std::deque<String>& names, int prio = 0) const
      {
        const Partition* part(nullptr);
 
        // loop over all partitions
        for(auto it = _parts.begin(); it != _parts.end(); ++it)
        {
          // check size
          if(int(it->size()) != size)
            continue;
 
          // check name
          if(!names.empty())
          {
            bool match = false;
            for(const auto& name : names)
            {
              match = match || (name == it->get_name());
            }
            if(!match)
              continue;
          }
 
          // check priority
          if((it->get_priority() <= 0) || (it->get_priority() < prio))
            continue;
 
          // okay, that's a candidate
          // does it have a greater or equal priority to the previously found one?
          if((part != nullptr) && (part->get_priority() > it->get_priority()))
            continue;
 
          // we have found a matching partition
          part = &(*it);
        }
 
        return part;
      }
    }; // class PartitionSet
  } // namespace Geometry
} // namespace FEAT