MPI_DirectionalGridEnvironment.h

#ifndef MPI_DirectionalGridEnvironment_H
#define MPI_DirectionalGridEnvironment_H
 
//inherited class object
#include "MPI_GridEnvironment.h"
 
 
template<tUCInt N,tUCInt D=1>
class MPI_DirectionalGridEnvironment  : public MPI_GridEnvironment<N> {
    
    //attributes
public:
   
    
private :
 
    //type of class & super class
    typedef MPI_GridEnvironment<N> SuperClass;
    typedef MPI_DirectionalGridEnvironment<N,D> SelfClass;
 
    
    //depth of neighbor (in template for future use (D=2 also ?)
    static constexpr tUCInt N_DIRECTIONS=2*D+1;
    
    //not null neighbors direction index <-> coreId
    std::map<tUCInt,tMPICoreId> mDirectionalNeighbors;
 
 
 
 
    
protected:
    // CONSTRUCTORS
    
    MPI_DirectionalGridEnvironment() {
        
    }
    MPI_DirectionalGridEnvironment(int& argc,char * argv[],const tBoolean& isOpenMPEnabled) : MPI_GridEnvironment<N>(argc,argv,isOpenMPEnabled) {
    
    }
    
 
    // DESTRUCTORS 
    virtual ~MPI_DirectionalGridEnvironment(void) {
        
        
    }
    
public:
    
    
    //memory management
    //=================
    virtual tMemSize getMemorySize() const override{
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=mDirectionalNeighbors.size()*(sizeof(tUCInt)+sizeof(tMPICoreId));
        return mem;
    }
 
public:
    
    inline static CORE_UniquePointer<SelfClass> New(const std::array<tMPICoreId,N>& nCoresPerDirection,
                                                    int& argc,char * argv[],const tBoolean& isOpenMPEnabled) {
        
        CORE_UniquePointer<SelfClass> p(new SelfClass(argc,argv,isOpenMPEnabled),
                                        SuperClass::Delete());
        
        //std::cout<<" world:"<<parent.getWorld()<<" N:"<<((int)N)<<" nCoresPerDirection:"<<core_arrays::toString(nCoresPerDirection)<<" Periodicity:"<<core_arrays::toString(isPeriodicPerDirection)<<"\n";
 
        //not periodic per default
        std::array<tMPIBoolean,N> isPeriodicPerDirection;
        for(auto& p: isPeriodicPerDirection) p=false;
 
        //set the periodicity per option
        tString gridP="";
        if (CORE_OptionsList::ReadOption(argc,argv,false,"cores-grid-periodicity",gridP)) {
            std::vector<tBoolean> Vs;
            functions_array::parse(gridP,Vs);
            for(int i=Vs.size();i<N;i++) {
                Vs.push_back(false);
            }
            auto iVs=Vs.cbegin();
            for(auto& p:isPeriodicPerDirection) {
                p=(*iVs);
                iVs++;
            }
        }
        
        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;
       
    };
protected :
  
        
    
    //accessor methods
    //================
 
 
public:
 
 
    //Grid number & grid indices
    //============================
    
 
    //neighbors data
    //===============
 
    //directional neighbors
    //---------------------
 
    inline constexpr  tUCInt GetNeighborsDepth() {
        return D;
    }
    
    inline static tUCInt GetMaximumDirectionalNeighborsNumber() {
        return functions_numeric::pow<tUCInt,N>(N_DIRECTIONS);
    } 
  
 
    inline static tUCInt GetFaceDirectionalIndex(const tUCInt& f,std::array<tCInt,N>& dir)  {
        functions_array::reset(dir);
        dir[f/2]=(f%2==0)?-1:1;
        return GetDirectionIndex(dir);
    }
    inline static tUCInt GetFaceDirectionalIndex(const tUCInt& f)  {
        std::array<tCInt,N> dir;
        return GetFaceDirectionalIndex(f,dir);
    }
 
    inline void getFaceNeighbors(std::array<tMPICoreId,2*N>& neighbors) const {
        std::array<tCInt,N> dir;//direction of neighbor for face
        functions_array::reset(dir);//dir=0
        tMPICoreId* iNeighbors=&neighbors[0];
        for (auto& dk:dir) {//loop on dierction
            dk=-1;//first face
            (*iNeighbors)=getDirectionalNeighbor(dir);
            iNeighbors++;
 
            dk=1;//second face
            (*iNeighbors)=getDirectionalNeighbor(dir);
            iNeighbors++;
 
            dk=0;//reset to 0
            
        }
        
    }
    inline tMPICoreId getDirectionalNeighbor(const std::array<tCInt,N>& dir) const {
        return getDirectionalNeighbor(GetLevelDirectionIndex<1>(dir.data()));
    }
 
    
    inline tMPICoreId getDirectionalNeighbor(const tUCInt& dirIndex) const {
        std::map<tUCInt,tMPICoreId>::const_iterator iNeighbors=mDirectionalNeighbors.find(dirIndex);
        if (iNeighbors==mDirectionalNeighbors.end()) return NULL_CORE;
        return iNeighbors->second;
        
    }
    inline const std::map<tUCInt,tMPICoreId>& getDirectionalNeighbors() const {
        return mDirectionalNeighbors;
        
    }
   
    inline void setDirectionalNeighbors(const std::map<tUCInt,tMPICoreId>& neighbors) {
        mDirectionalNeighbors=neighbors;
    }
 
public:
    
    inline static void  GetDirection(const tUCInt& index,std::array<tCInt,N>& dir) {
        GetLevelDirection<1>(index,dir.data());
    }
    inline static tUCInt  GetDirectionIndex(const std::array<tCInt,N>& dir) {
        return GetLevelDirectionIndex<1>(dir.data());
    }
  
  
 
public:
   
 
 
    
    virtual void initialize() {
        
        SuperClass::initialize();
        
 
        
    }
 
private:
    template<tUCInt i> requires (i==N)
        inline static tMPICoreId GetLevelDirectionIndex(const tCInt* dir) {
        return (*dir)+D;
    }
    template<tUCInt i> requires (i<N)
        inline static tMPICoreId GetLevelDirectionIndex(const tCInt* dir) {
        return (*dir)+D+N_DIRECTIONS*GetLevelDirectionIndex<i+1>(dir+1);
    }
    template<tUCInt i> requires (i==N)
        inline static void  GetLevelDirection(const tUCInt& index,tCInt* dir) {
        (*dir)=index;
        (*dir)-=D;
    }
    template<tUCInt i> requires (i<N)
        inline static void GetLevelDirection(const tUCInt& index,tCInt* dir) {
        (*dir)=index%N_DIRECTIONS;
        (*dir)-=D;
        GetLevelDirection<i+1>(index/N_DIRECTIONS,dir+1);
    }
    
  
    
};
 
 
#endif