ZoltanPartition.hpp

Go to the documentation of this file.

/*----------------------------------------------------------------------*/
/*                                                                      */
/*       author: Jonathan Scott Rath                                    */
/*      author2: Michael W. Glass   (DEC/2000)                          */
/*     filename: ZoltanPartition.h                                      */
/*      purpose: header file for stk toolkit zoltan methods             */
/*                                                                      */
/*----------------------------------------------------------------------*/
/*    Copyright 2001,2010 Sandia Corporation.                           */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a         */
/*    non-exclusive license for use of this work by or on behalf        */
/*    of the U.S. Government.  Export of this program may require       */
/*    a license from the United States Government.                      */
/*----------------------------------------------------------------------*/

// Copyright 2001 Sandia Corporation, Albuquerque, NM.

#ifndef stk_rebalance_ZoltanPartition_hpp
#define stk_rebalance_ZoltanPartition_hpp

#include <utility>
#include <vector>
#include <string>

#include <Teuchos_ParameterList.hpp>
#include <stk_mesh/base/Types.hpp>
#include <stk_rebalance/GeomDecomp.hpp>

//Forward declaration for pointer to a Zoltan structrue.
struct Zoltan_Struct;

namespace stk_classic {
namespace rebalance {

typedef Teuchos::ParameterList Parameters;

class Zoltan : public GeomDecomp {

public:

  struct MeshInfo {
    std::vector<mesh::Entity *>      mesh_entities;
    const VectorField              * nodal_coord_ref ;
    const ScalarField              * elem_weight_ref;
    std::vector<unsigned>            dest_proc_ids ;

    MeshInfo():
      nodal_coord_ref(NULL),
      elem_weight_ref(NULL) {}

    ~MeshInfo() {}
  };

  virtual void set_mesh_info ( const std::vector<mesh::Entity *> &mesh_entities,
                               const VectorField   * nodal_coord_ref,
                               const ScalarField   * elem_weight_ref=NULL);

  void reset_dest_proc_data ();

  static const std::string zoltan_parameters_name();

  static const std::string default_parameters_name();


  explicit Zoltan(ParallelMachine pm, 
                  const unsigned ndim, 
                  Teuchos::ParameterList & rebal_region_parameters, 
                  std::string parameters_name=default_parameters_name());

  virtual ~Zoltan();

  unsigned num_elems() const { return m_total_number_entities_ ; }

  double entity_weight(const unsigned moid) const;

  void set_destination_proc(const unsigned moid,
                            const unsigned proc );

  int globalID         (const unsigned moid) const
  { return m_mesh_information_.mesh_entities[ moid ]->identifier(); }

  unsigned num_moid() const;

  bool find_mesh_entity(const mesh::Entity * entity, unsigned & moid) const;

  mesh::Entity *mesh_entity(const unsigned moid ) const;

  const VectorField * entity_coord_ref () const;

  const ScalarField * entity_weight_ref () const;


  static void merge_default_values   (const Teuchos::ParameterList &from,
                                      Teuchos::ParameterList &to);

  static void convert_names_and_values (const Teuchos::ParameterList &from,
                                        Teuchos::ParameterList &to);


  virtual void determine_new_partition (bool & RebalancingNeeded);

  virtual int get_new_partition(stk_classic::mesh::EntityProcVec &new_partition);

  bool partition_dependents_needed() const
  { return true; /* Zoltan partitions elements and leaves the rest to someone else */ }

  int evaluate ( int      print_stats,
                 int     *nentity,
                 double  *entity_wgt,
                 int     *ncuts,
                 double  *cut_wgt,
                 int     *nboundary,
                 int     *nadj  );

  double zoltan_version()  const;

  const std::string & parameter_entry_name() const;

  Zoltan_Struct * zoltan() {
    return m_zoltan_id_;
  }

  const Zoltan_Struct * zoltan() const {
    return m_zoltan_id_;
  }

  unsigned spatial_dimension() const {
    return m_spatial_dimension_;
  }

private:
  struct    Zoltan_Struct *m_zoltan_id_;

  const     unsigned       m_spatial_dimension_;
  std::string              m_parameter_entry_name_;

  static const std::string m_zoltanparametersname_;
  static const std::string m_defaultparametersname_;
  Parameters               m_default_parameters_;
  MeshInfo                 m_mesh_information_;
  unsigned                 m_total_number_entities_;

  void init_default_parameters();
  void init(const std::vector< std::pair<std::string, std::string> >
            &dynamicLoadRebalancingParameters);
  static double init_zoltan_library();

  unsigned destination_proc(const unsigned moid) const;

  int register_callbacks();


};

}
} // namespace stk_classic

#endif