partitioner.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
// NOTE: Classes in this file were originally defined in 'load_balancer.h'
 
#ifndef __H__UG_partitioner
#define __H__UG_partitioner
 
#include "process_hierarchy.h"
#include "lib_grid/multi_grid.h"
#include "lib_grid/tools/subset_handler_grid.h"
 
namespace ug{
 
 
class IPartitioner;
 
class IBalanceWeights{
  public:
 
    virtual ~IBalanceWeights()  {}
    virtual void refresh_weights(int baseLevel) {};
 
    virtual number get_weight(Vertex*)  {return 1.;}
    virtual number get_weight(Edge*)  {return 1.;}
    virtual number get_weight(Face*)  {return 1.;}
    virtual number get_weight(Volume*)  {return 1.;}
 
    virtual number get_refined_weight(Vertex* e)  {return get_weight(e);}
    virtual number get_refined_weight(Edge* e)    {return 2. * get_weight(e);}
    virtual number get_refined_weight(Face* e)    {return 4. * get_weight(e);}
    virtual number get_refined_weight(Volume* e)  {return 8. * get_weight(e);}
    
    virtual bool has_level_offsets()    {return false;}
 
 
    virtual bool consider_in_level_above(Vertex*) {return false;}
    virtual bool consider_in_level_above(Edge*)   {return false;}
    virtual bool consider_in_level_above(Face*)   {return false;}
    virtual bool consider_in_level_above(Volume*) {return false;}   
};
 
typedef SmartPtr<IBalanceWeights>   SPBalanceWeights;
 
 
class ICommunicationWeights
{
  public:
    virtual ~ICommunicationWeights() {};
 
    virtual number get_weight(GridObject* conn) = 0;
 
    virtual bool reweigh(GridObject* conn) {return false;}
};
class ICommunicationWeights {…};
 
typedef SmartPtr<ICommunicationWeights> SPCommunicationWeights;
 
 
 
class IPartitionPreProcessor{
  public:
    virtual ~IPartitionPreProcessor() {}
    
    virtual void partitioning_starts (  MultiGrid* mg,
                                      IPartitioner* partitioner) = 0;
    virtual void partitioning_done (  MultiGrid* mg,
                                      IPartitioner* partitioner) = 0;
};
class IPartitionPreProcessor {…};
 
typedef SmartPtr<IPartitionPreProcessor>  SPPartitionPreProcessor;
 
 
 
 
class IPartitionPostProcessor{
  public:
    virtual ~IPartitionPostProcessor()  {}
    
    virtual void init_post_processing(  MultiGrid* mg,
                                        SubsetHandler* partitions) = 0;
    virtual void post_process(int lvl) = 0;
    virtual void partitioning_done() = 0;
};
class IPartitionPostProcessor {…};
 
typedef SmartPtr<IPartitionPostProcessor> SPPartitionPostProcessor;
 
 
 
 
class IPartitioner{
  public:
    IPartitioner() :
      m_problemsOccurred(false),
      m_verbose(true),
      m_clusteredSiblings(true) {}
    IPartitioner() : {…}
 
    virtual ~IPartitioner() {}
 
    virtual void set_next_process_hierarchy(SPProcessHierarchy procHierarchy) = 0;
 
    virtual void set_balance_weights(SPBalanceWeights balanceWeights) {
      UG_COND_THROW(!supports_balance_weights(),
                    "This partitioner does not support balance weights.");
    };
    virtual void set_balance_weights(SPBalanceWeights balanceWeights) {…}
 
    virtual void set_communication_weights(SPCommunicationWeights commWeights)  {
      UG_COND_THROW(!supports_communication_weights(),
                    "This partitioner does not support communication weights.");
    };
    virtual void set_communication_weights(SPCommunicationWeights commWeights) {…}
 
    virtual void set_partition_pre_processor(SPPartitionPreProcessor) {
      UG_THROW("Partition-Pre-Processing is currently not supported by the chosen partitioner.");
    }
    virtual void set_partition_pre_processor(SPPartitionPreProcessor) {…}
 
    virtual void set_partition_post_processor(SPPartitionPostProcessor){
      UG_THROW("Partition-Post-Processing is currently not supported by the chosen partitioner.");
    }
    virtual void set_partition_post_processor(SPPartitionPostProcessor) {…}
 
    virtual ConstSPProcessHierarchy current_process_hierarchy() const = 0;
    virtual ConstSPProcessHierarchy next_process_hierarchy() const = 0;
 
    virtual bool supports_balance_weights() const       {return false;}
    virtual bool supports_communication_weights() const   {return false;}
    virtual bool supports_repartitioning() const      {return false;}
 
    virtual void enable_clustered_siblings(bool bEnable)  {m_clusteredSiblings = bEnable;}
    virtual bool clustered_siblings_enabled()       {return m_clusteredSiblings;}
    virtual bool partition(size_t baseLvl, size_t elementThreshold) = 0;
 
    virtual SubsetHandler& get_partitions() = 0;
 
    virtual void set_subset_handler(SmartPtr<SubsetHandler>) {
      UG_LOG("IPartitioner::set_subset_handler not implemented");
    };
    virtual void set_subset_handler(SmartPtr<SubsetHandler>) {…}
    virtual void enable_static_partitioning(bool) {
      UG_LOG("IPartitioner::enable_static_partitioning not implemented");
    };
    virtual void enable_static_partitioning(bool) {…}
 
 
    virtual const std::vector<int>* get_process_map() const = 0;
 
 
    virtual bool problems_occurred()  {return m_problemsOccurred;}
 
    void set_verbose(bool verbose)  {m_verbose = verbose;}
    bool verbose() const      {return m_verbose;}
 
  protected:
    bool m_problemsOccurred;
 
  private:
    bool m_verbose;
    bool m_clusteredSiblings;
};
class IPartitioner {…};
 
typedef SmartPtr<IPartitioner>    SPPartitioner;
 
 
}// end of namespace
 
#endif  //__H__UG_partitioner
    virtual number get_refined_weight(Volume* e)  {return 8. * get_weight(e);} {…}
class IBalanceWeights {…};