MPI_CanonicalGridEnvironment.h

#ifndef MPI_CanonicalGridEnvironment_H
#define MPI_CanonicalGridEnvironment_H
 
//inherited class object
#include "MPI_GridEnvironment.h"
 
//numeric function headers
#include "core_numeric.h"
 
template<tUCInt N>
class MPI_CanonicalGridEnvironment  : public MPI_GridEnvironment<N> {
    
    //attributes
public:
   
    
private :
    typedef MPI_CanonicalGridEnvironment<N> SelfClass;
    typedef MPI_GridEnvironment<N> SuperClass;
 
    
    //face neighbor core
    std::array<tMPICoreId,2*N> mFaceNeighbors;
    
  
 
    
protected:
    // CONSTRUCTORS
    
    MPI_CanonicalGridEnvironment() {
        
    }
    MPI_CanonicalGridEnvironment(int& argc,char * argv[],const tBoolean& isOpenMPEnabled) : SuperClass(argc,argv,isOpenMPEnabled) {
        
    }
    
    
    // DESTRUCTORS 
    virtual ~MPI_CanonicalGridEnvironment(void) {
        
        
    }
    
public:
    
    
    //memory management
    //=================
    virtual tMemSize getMemorySize() const override{
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=sizeof(tMPICoreId)*mFaceNeighbors.size();
        return mem;
    }
    
   
    
protected :
  
        
    
    //accessor methods
    //================
public:
    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<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_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<SelfClass> New(const MPI_CanonicalGridEnvironment<N+1>& 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;
    }
 
public:
 
 
    //Grid number & grid indices
    //============================
 
    //neighbors data
    //===============
 
    //directional neighbors
    //---------------------
 
   
    virtual void initialize() {
        
        SuperClass::initialize();
 
        //set the neighbor only per face
        setFaceNeighbors(this->getGridSize(),this->getIndices(),this->getGridPeriodicity());
 
        
    }
 
protected:
 
    inline void setFaceNeighbors(const std::array<tMPICoreId,N>& nGrids,
                                 const std::array<tMPICoreId,N>& indices,
                                 const std::array<tBoolean,N>& isPeriodic) {
 
       
        
        //orientation of face i {-1,1}
        tCInt eps;
        
        
  
        //neighbor indices
        std::array<tMPICoreId,N> neighborIndices=indices;
        
        //iterator on face neighbors
        tMPICoreId *iFaceNeighbors=mFaceNeighbors.data();
 
        //indicates if the neighbor core is in the grid
        tBoolean isInsideBound;
 
        
        //if of the neigbor core
        tMPICoreId neighborCoreId;
 
        
        //iterator on the indices of core this
        const tMPICoreId* iIndices=indices.data();
        //iterator on index of neighbor cores
        tMPICoreId *iNeighborIndices=neighborIndices.data();
     
        //iterator on periodicity
        const tBoolean* iIsPeriodic=isPeriodic.data();
 
        for (const auto& Nk:nGrids) {//loop on number of core per dierction k in {0,1,2}
 
           
            //neighbor indices initialize to the index of this core
           
            for(eps=-1;eps<2;eps+=2) {//orientation of face es in {-1,1}
             
                
                //neighbor in direction -ek
                //Dk=-1,+1
                (*iNeighborIndices)=(*iIndices);
                (*iNeighborIndices)+=eps;
                
                if (*iIsPeriodic) {//periodic case
                    (*iNeighborIndices)+=Nk;
                    (*iNeighborIndices)%=Nk;
                }
                
                isInsideBound=((*iNeighborIndices)>=0) && ((*iNeighborIndices)<Nk);
 
                if (isInsideBound) {
                    MPI_Cart_rank(this->getWorld(),neighborIndices.data(),&neighborCoreId);
                   
                    //register the neighbor per face
                    (*iFaceNeighbors)=neighborCoreId;
                } else {
                    (*iFaceNeighbors)=NULL_CORE;
                }
 
                //ietartor at next orientation
                iFaceNeighbors++;
 
            }
            //reinitialize value before changing of dierction
            (*iNeighborIndices)=(*iIndices);
            
            //iterator at next dierction k
            iIndices++;
            iNeighborIndices++;
            iIsPeriodic++;
        }//end loop on dierction k
            
          
    }
    
   
public:
 
    //face neighbors
    //================
    inline const tMPICoreId& getFaceNeighbor(const tUCInt& f) const {
        return mFaceNeighbors[f];       
    }
    inline void  getFaceNeighbors(const tUCInt& k,tMPICoreId& previousNeighbor,tMPICoreId& nextNeighbor) const {
        const tMPICoreId *iNeighbors=&mFaceNeighbors[k+k];
        previousNeighbor=*iNeighbors;iNeighbors++;
        nextNeighbor=*iNeighbors;
    }
 
    inline const std::array<tMPICoreId,2*N>& getFaceNeighbors() const {
        return mFaceNeighbors;
            
    }
        
 
  
    
};
 
 
#endif