partitioning.hh

Go to the documentation of this file.

/*!
 *
 * Copyright (C) 2015 Technical University of Liberec.  All rights reserved.
 * 
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 3 as published by the
 * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
 * 
 * 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 General Public License for more details.
 *
 * 
 * @file    partitioning.hh
 * @brief   
 */

#ifndef PARTITIONING_HH_
#define PARTITIONING_HH_

#include "input/input_type_forward.hh"
#include "input/accessors.hh"

class Mesh;
class SparseGraph;
class Distribution;

/**
 * @brief Class for the mesh partitioning.
 * This should provide:
 * - construction of cenectivity graph from the mesh
 * - call a partitioner
 * - provide new element numbering and new element distribution
 *   (global numbers for the local part - at least for ghost part)
 *   (+ old indices of elements for the local part of the mesh - in order to do not change current implementation)
 * TODO:
 * - deal with partitioining of boundary mesh
 */
class Partitioning {
public:

    /// Input specification objects.
    static const Input::Type::Selection & get_graph_type_sel();
    static const Input::Type::Selection & get_tool_sel();
    static const Input::Type::Record & get_input_type();

    TYPEDEF_ERR_INFO(EI_MeshFile, std::string);
    TYPEDEF_ERR_INFO(EI_NElems, unsigned int);
    TYPEDEF_ERR_INFO(EI_NProcs, unsigned int);
    DECLARE_INPUT_EXCEPTION(ExcDecomposeMesh,
            << "Number of processors " << EI_NProcs::val << " greater then number of elements "
            << EI_NElems::val << ". Can not make partitioning of the mesh " << EI_MeshFile::qval << ".\n" );

    /**
     *  Constructor. A pointer to the mesh and accessor to an input record have to be provided.
     */
    Partitioning(Mesh *mesh, Input::Record in);

    /**
     * Get initial distribution.
     */
    const Distribution *get_init_distr() const;
    /**
     * Get local part of mesh partition.
     */
    const int *get_loc_part() const;

    /**
     * Creates and returns vector with element partitioning for output.
     */
    shared_ptr< vector<int> > subdomain_id_field_data();

    /**
     * Obsolete see source file for doc.
     */
    void id_maps(int n_ids, int *id_4_old,
                    Distribution * &new_ds, int * &id_4_loc, int * &new_4_id);


    static void id_maps(int n_ids, int *id_4_old,
            const Distribution &old_ds, int *loc_part,
            Distribution * &new_ds, int * &id_4_loc, int * &new_4_id);

    /// Destructor.
    ~Partitioning();

private:
    /**
     * Types of partitioning algorithms.
     */
    enum PartitionTool {
        PETSc,      ///< Use PETSc interface to various partitioing tools.
        METIS       ///< Use direct interface to Metis.
    };

    /**
     * Types of weights used for element partitioning.
     */
    enum PartitionGraphType {
        any_neighboring,               ///< Add edge for any pair of neighboring elements
        any_weight_lower_dim_cuts,      ///< Same as before and assign higher weight to cuts of lower dimension in order to make them stick to one face
        same_dimension_neighboring,     ///< Add edge for any pair of neighboring elements of same dimension (bad for matrix multiply)
    };

    /// The input mesh
    Mesh        *mesh_;
    /// Input Record accessor.
    Input::Record in_;

    /// Graph used to partitioning the mesh.
    SparseGraph *graph_;
    /// Partition numbers for local elements in original distribution of elements given be @p init_el_ds_.
    int *       loc_part_;
    /// Original distribution of elements. Depends on type of partitioner
    Distribution *init_el_ds_;
    /// Sequential partitioning for output.
    shared_ptr< vector<int> > seq_part_;

    /**
     * Creates sparse parallel graph from the mesh (using algorithm given by the key "graph_type" of the input record accessor @p in_
     */
    void make_element_connection_graph();
    /**
     * Creates sparse parallel graph from the mesh (using algorithm given by the key "graph_type" of the input record accessor @p in_)
     * calls partitioning tool given by the key "tool" of the input record accessor @p in_)
     * result is local part of the partitioning. Can be retrieved by @p get_loc_part().
     */
    void make_partition();


};


#endif /* PARTITIONING_HH_ */