MPI_GraphGridEnvironment.h

#ifndef MPI_GraphGridEnvironment_H
#define MPI_GraphGridEnvironment_H
 
//inherited class object
#include "MPI_DirectionalGridEnvironment.h"
 
//MPI File IO Header
#include "MPI_IOFile.h"
 
//array function headers
#include "functions_array.h"
 
template<tUCInt N,tUCInt D=1>
class MPI_GraphGridEnvironment  : public MPI_DirectionalGridEnvironment<N,D> {
    
    //attributes
private :
 
    MPI_Group *mGroup,*mParentGroup;
 
    
    typedef MPI_GraphGridEnvironment<N,D> SelfClass;
    typedef MPI_DirectionalGridEnvironment<N,D> SuperClass;
protected:
    // CONSTRUCTORS
    
    MPI_GraphGridEnvironment() {
        mGroup=null;
        mParentGroup=null;
        this->getWorld()=MPI_COMM_NULL;
       
    }
    
    
 
    // DESTRUCTORS 
    virtual ~MPI_GraphGridEnvironment(void) {
        if (mGroup!=null) {
            MPI_Group_free(mGroup);
            delete mGroup;
        }
        if (mParentGroup!=null) {
            MPI_Group_free(mParentGroup);
            delete mParentGroup;
        }
        
        
    }
    
public:
    
    
    
    //New methods
    //===========
    
    inline static CORE_UniquePointer<MPI_GraphGridEnvironment<N>> New(const MPI_Environment& parent,
                                                                      const tString& fileDescriptor) {
        
       
        
        std::array<tInteger,N> gridsNumber;
        std::array<tInteger,N> coreIndices;
        std::map<tUCInt,tMPICoreId> dirNeighbors;
        
        tBoolean isInGraphGridEnv=false;
        tMPICoreId nCores;
        //std::cout<<"load the grid cart file for process "<<parent.getCoreId()<<"\n";
        MPI_GraphGridEnvironment<N>::LoadGridCartFile(fileDescriptor,parent,
                                                      nCores,
                                                      gridsNumber,coreIndices,dirNeighbors,
                                                      isInGraphGridEnv);
        //std::cout<<"return a Graph Grid environment if available of  "<<parent.getCoreId()<<"\n";
        return New(parent,nCores,gridsNumber,coreIndices,dirNeighbors);
    }
     
    inline static CORE_UniquePointer<MPI_GraphGridEnvironment<N>> New(const MPI_Environment& parent,
                                                                      const tMPICoreId& nCores,
                                                                      const std::array<tInteger,N>& gridsNumber,
                                                                      const std::array<tInteger,N>&  coreIndices,
                                                                      const std::map<tUCInt,tMPICoreId>& dirNeighbors) {
 
      
        
        CORE_UniquePointer<MPI_GraphGridEnvironment<N>> p(new MPI_GraphGridEnvironment<N>(),
                                                          MPI_Environment::Delete());
        
       
          
            
        //get the group under it parent
        //std::cout<<"create a group for process : "<<parent.getCoreId()<<"\n";
        p->mParentGroup=new MPI_Group();
        MPI_Comm_group(parent.getWorld(),p->mParentGroup);
            
        //create the grid group
        std::valarray<tMPICoreId> processRanks(nCores);
        tMPICoreId i=0;
        for(auto& Pk:processRanks) {Pk=i;i++;}
            
        p->mGroup=new MPI_Group();
        MPI_Group_incl(*p->mParentGroup,nCores,&processRanks[0],p->mGroup);
            
        //create the communicator of the group
        MPI_Comm_create(parent.getWorld(),*p->mGroup,&p->getWorld());
            
        //erify the group is well done
        if (p->getWorld()==MPI_COMM_NULL) {
            //process can not be added in the grid environement
            p.reset();
        } else {
                
            //iniitialize the communicator
            p->initialize();
            
            //initialize the data of the communicator
            p->setGridSize(gridsNumber);
            p->setIndices(coreIndices);
            p->setDirectionalNeighbors(dirNeighbors);
        }
        
        return p;
    }; 
   
    virtual void initialize() {
        
        SuperClass::initialize();
    }
 
 
        
    
    //accessor methods
    //================
 
 
public:
   
    
      
    static tBoolean LoadGridCartFile(const tString& fileName,
                                     const MPI_Environment& env,
                                     tMPICoreId& nCores,
                                     std::array<tInteger,N>& gridsNumber,
                                     std::array<tInteger,N>& coreIndices,
                                     std::map<tUCInt,tMPICoreId>& dirNeighbors,
                                     tBoolean& isCoreInGrid);
    
    template<typename Q>
    static tBoolean SaveGridCartFile(const MPI_DirectionalGridEnvironment<N,D>& env,
                                     const tInteger& nFullCores,
                                     const tInteger& fullId,
                                     const std::map<tUCInt,Q>& isDirNeighborFull,
                                     const tString& fileName);
    
    
 
 
};
 
#include "MPI_GraphGridEnvironment.hpp"
 
#endif