shells/parallel/PointSetPartitioner.h

Go to the documentation of this file.

// -*- C++ -*- 
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//                                   Fehmi Cirak
//                        California Institute of Technology
//                           (C) 2004 All Rights Reserved
//
// <LicenseText>
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//

#ifndef POINTSETPARTITIONER_H
#define POINTSETPARTITIONER_H

#include "ZoltanIface.h"
#include <mpi.h>

#include <vector>
#include <set>
#include <cassert>
#include <cstdlib>


namespace parallel {
    class PointSetPartitioner;
}

struct Zoltan_Struct;



class parallel::PointSetPartitioner {
public:
    template <typename InIter>
    PointSetPartitioner(const MPI_Comm& comm, const InIter& itb, const InIter& ite);
    ~PointSetPartitioner();
    
    template<typename OutPointIter>
    void partitionPointIDs(OutPointIter mypoints) const;

//  template<typename OutPointIter, typename OutMapIter>
//  void partitionPointSet(OutPointIter mypoints, OutMapIter localGlobalNode); 
 
private:        
//    template<typename OutMapIter>
//  localGlobaPointID(OutIter _localGlobalNode);

private:    
    PointSetPartitioner(const PointSetPartitioner &);
    const PointSetPartitioner & operator=(const PointSetPartitioner &);

private: 
    PointSetCont      *_pointSet;        // necessary for RCB
    Zoltan_Struct     *_zoltan;          // necessary 
                                         // for repartitioning
};



// templated methods
template <typename InIter>
parallel::PointSetPartitioner::PointSetPartitioner(const MPI_Comm& comm, 
                                                   const InIter& itb, 
                                                   const InIter& ite)    
{    
    // initialize zoltan 
    _zoltan = parallel::zoltanIfaceInit(comm);
    assert(_zoltan != NULL);
        
    // assign all elements points to processor 0
    _pointSet = new parallel::PointSetCont;
    assert(_pointSet != NULL);

    int myrank;
    MPI_Comm_rank(comm, &myrank);

    assert(_pointSet->_coordinate.size()==0);
    assert(ite-itb>0);
            
    if (!myrank) {
        _pointSet->_coordinate.reserve(ite-itb);
        std::copy(itb, ite, std::back_inserter(_pointSet->_coordinate));
        _pointSet->_globalID.reserve(ite-itb);
        int numElements = (ite-itb)/3;   // 3 coordinates
        for(int i=0; i<numElements; ++i) _pointSet->_globalID.push_back(i);
    }
}



template<typename OutPointIter>
void parallel::PointSetPartitioner::partitionPointIDs(OutPointIter myPoints) const
{
    // partition mesh with zoltan and return elements assigned to my processor
    // TODO: In the case of dynamic repartitioning it is necessary to update 
    // _pointSet->_coordinate[]

    std::set<int> newPointSet;
    std::insert_iterator< std::set<int> > 
        insElements(newPointSet, newPointSet.begin());
    zoltanIfacePartition(_zoltan, _pointSet, insElements);

    // global point ID's on this processor
    std::copy(newPointSet.begin(), newPointSet.end(), myPoints);

    return;
}

#endif

---