MPI_CartEnvironment.h

#ifndef MPI_CartEnvironment_H
#define MPI_CartEnvironment_H
 
//inherited class object
#include "MPI_DirectionalGridEnvironment.h"
 
template<tUCInt N,tUCInt D=1>
class MPI_CartEnvironment  : public MPI_DirectionalGridEnvironment<N,D> {
    
    //attributes
private :
 
    typedef MPI_CartEnvironment<N,D> SelfClass;
    typedef MPI_DirectionalGridEnvironment<N,D> SuperClass;
 
    
protected:
    // CONSTRUCTORS
 
    MPI_CartEnvironment() {
        this->getWorld()=MPI_COMM_NULL;
    }
    
    MPI_CartEnvironment(int& argc,char * argv[],const tBoolean& isOpenMPEnabled) : SuperClass(argc,argv,isOpenMPEnabled) {
      
    }
 
  
 
    // DESTRUCTORS 
    virtual ~MPI_CartEnvironment(void) {
        
        
    }
    
public:
    
    
    
    //New methods
    //===========
      
    inline static CORE_UniquePointer<SelfClass> New(const std::array<tMPICoreId,N>& nCoresPerDirection,
                                                    const std::array<tBoolean,N>& isPeriodicPerDirection,
                                                    int& argc,char * argv[],const tBoolean& isOpenMPEnabled) {
        
        CORE_UniquePointer<SelfClass> p(new SelfClass(argc,argv,isOpenMPEnabled),
                                        MPI_Environment::Delete());
        
        //std::cout<<" world:"<<parent.getWorld()<<" N:"<<((int)N)<<" nCoresPerDirection:"<<core_arrays::toString(nCoresPerDirection)<<" Periodicity:"<<core_arrays::toString(isPeriodicPerDirection)<<"\n";
        
        MPI_Cart_create(MPI_COMM_WORLD,
                        (int) N,nCoresPerDirection.data(),isPeriodicPerDirection.data(),
                        true,
                        &p->getWorld());
        
        if (p->getWorld()==MPI_COMM_NULL) {
            //process can not be added in the grid environement
            p.reset();
            return p;
        }
        p->initialize();
        return p;
       
    };
    inline static CORE_UniquePointer<SelfClass> New(const MPI_Environment& parent,
                                                    const std::array<tMPICoreId,N>& nCoresPerDirection) {
        //no periodicity
        std::array<tMPIBoolean,N> periodicity;
        for(auto& Vi:periodicity) Vi=0;
        
        return New(parent,nCoresPerDirection,periodicity,true);
       
    };
    inline static CORE_UniquePointer<SelfClass> New(const MPI_Environment& parent,
                                                    const std::array<tMPICoreId,N>& nCoresPerDirection,
                                                    const std::array<tBoolean,N>& isPeriodicPerDirection,
                                                    const int& canCoreIdBeChanged) {
        std::array<int,N> periods;
        int k=0;
        for(auto& Pk:periods) {
            Pk=isPeriodicPerDirection[k];
            k++;
        }
        return New(parent,nCoresPerDirection,periods,canCoreIdBeChanged);
    }
    inline static CORE_UniquePointer<MPI_CartEnvironment<N>> New(const MPI_Environment& parent,
                                                                 const std::array<tMPICoreId,N>& nCoresPerDirection,
                                                                 const std::array<tMPIBoolean,N>& isPeriodicPerDirection,
                                                                 const int& canCoreIdBeChanged) {
        CORE_UniquePointer<SelfClass> p(new SelfClass(),
                                        MPI_Environment::Delete());
        
        //std::cout<<" world:"<<parent.getWorld()<<" N:"<<((int)N)<<" nCoresPerDirection:"<<core_arrays::toString(nCoresPerDirection)<<" Periodicity:"<<core_arrays::toString(isPeriodicPerDirection)<<"\n";
       
        MPI_Cart_create(parent.getWorld(),
                        (int) N,nCoresPerDirection.data(),isPeriodicPerDirection.data(),
                        canCoreIdBeChanged,
                        &p->getWorld());
        
        if (p->getWorld()==MPI_COMM_NULL) {
            //process can not be added in the grid environement
            p.reset();
            return p;
        }
        p->initialize();
        return p;
    };
    
    inline static CORE_UniquePointer<SelfClass> New(const MPI_CartEnvironment<N+1,D>& parent,
                                                    const tUCInt& dir) {
        CORE_UniquePointer<SelfClass> p(new SelfClass(),
                                        MPI_Environment::Delete());
        //create the selected directions to keep
        std::array<int,N+1> dims;
        for(auto& Dk:dims) Dk=1;
        dims[dir]=0;
        MPI_Cart_sub(parent.getWorld(),&dims[0],&p->getWorld());
        if (p->getWorld()==MPI_COMM_NULL) {
            //process can not be added in the grid environement
            p.reset();
            return p;
        }
        p->initialize();
        return p;
    }
 
 
    //memory management
    //=================
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
    
 
   
    
protected :
    virtual void initialize() {
        
        SuperClass::initialize();
 
 
        //build the neighbor cores list
        buildNeighborCoresList(this->getGridSize(),this->getIndices(),this->getGridPeriodicity());
    }
 
 
    inline void buildNeighborCoresList(const std::array<tMPICoreId,N>& nGrids,const std::array<tMPICoreId,N>& indices,
                                       const std::array<tBoolean,N>& periodicity ) {
 
       
        
        //initialize the neighbor  grids per direction
        
        std::map<tUCInt,tMPICoreId> neighbors;
 
        //ietaror on periodc
        const tBoolean *iPeriod=null;
        
        //index of direction
        tUCInt index=0;
        
        //neighbor core id
        tMPICoreId nextCoreId;
        
        std::array<tCInt,N> dir;
        tCInt *iDir=null;//itertor on dir
        
        //neighbor is inside bounds
        tBoolean isInsideBounds;
        
        //neighbor indices
        std::array<tMPICoreId,N> neighborIndices;
        tMPICoreId *iNeighborIndices;//iterator on neighbor indices
        const tMPICoreId *iNk=nGrids.data();//iterator on grid size
        while (index<=this->GetMaximumDirectionalNeighborsNumber()) {
                
            //get the direction of the neighbor grid at index
            this->GetDirection(index,dir);
            
            //set the indices of the neighbor from current indices of this core
            iDir=dir.data();
            
            //periodicity
            iPeriod=periodicity.data();
            
            //size of grids
            iNk=nGrids.data();
            
            //neighbor in domain indicator
            isInsideBounds=true;
            
            iNeighborIndices=neighborIndices.data();
            for(const auto& i:indices) {
                //neighbor indices initialitze to indices of this
                (*iNeighborIndices)=i;
                //translation to direction
                (*iNeighborIndices)+=(*iDir);
                
                if (*iPeriod) {//periodic case
                    (*iNeighborIndices)+=(*iNk);
                    (*iNeighborIndices)%=(*iNk);
                }
                
                isInsideBounds=isInsideBounds && ((*iNeighborIndices)>=0) && ((*iNeighborIndices)<(*iNk));
                
                //iterator at next coordinate
                iDir++;
                iPeriod++;
                iNk++;
                iNeighborIndices++;
            }
            //get the core Id of the neighbor
            nextCoreId=NULL_CORE;
            if (isInsideBounds) {
 
                //get the index of the neighbor core at dierction neighborIndices 
                MPI_Cart_rank(this->getWorld(),neighborIndices.data(),&nextCoreId);
                //std::cout<<"MPI_Cart_rank(indices="<<core_functions::toString(indices)<<" dir="<<core_functions::toString<int,tCInt>(dir)<<" neighborIndices="<<core_functions::toString(neighborIndices)<<",size="<<core_functions::toString(nGrids)<<" ) nextCoreId="<<nextCoreId<<"\n";
            }
            
            //register the neighbor core id 
            if (nextCoreId!=NULL_CORE) neighbors[index]=nextCoreId;
            
            
            
            //index of next neighbor grid
            index++;
            
        }//end loop on directional
        
        //erase neighbor for null  displacement 
        memset(dir.data(),0,sizeof(tCInt)*N);
        std::map<tUCInt,tMPICoreId>::iterator iNeighbors=neighbors.find(this->GetDirectionIndex(dir));
        if (iNeighbors!=neighbors.end()) neighbors.erase(iNeighbors);
 
 
        //set the dierctional neighbors
        this->setDirectionalNeighbors(neighbors);
        
        //set to null core for the null directiopn
        
        //std::cout<<"coreId:"<<this->getCoreId()<<" neighbors:"<<core_functions::toString<tInt,tInt>(neighbors)<<"\n";
        
        
    }
    
 
    
    
    //accessor methods
    //================
 
    
 
 
 
    
    
 
 
};
 
 
#endif