MPI_GridEnvironment.h

#ifndef MPI_GridEnvironment_H
#define MPI_GridEnvironment_H
 
//inherited class object
#include "MPI_Environment.h"
 
//options list header
#include "CORE_OptionsList.h"
 
//numeric function headers
#include "functions_array.h"
#include "functions_grid.h"
 
template<tUCInt N>
class MPI_GridEnvironment  : public MPI_Environment {
    
    //attributes
public:
   
    
private :
 
    //type of class & super class
    typedef MPI_Environment SuperClass;
    typedef MPI_GridEnvironment<N> SelfClass;
 
    
 
    //number of grids per direction
    std::array<tMPICoreId,N> mGridSize;
    
    //periodicity of grid per direction
    std::array<tBoolean,N> mGridPeriodicity;
 
    //current grid indices
    std::array<tMPICoreId,N> mIndices;
 
 
    
protected:
    // CONSTRUCTORS
    
    MPI_GridEnvironment() {
        
    }
    MPI_GridEnvironment(int& argc,char * argv[],const tBoolean& isOpenMPEnabled) : MPI_Environment(argc,argv,isOpenMPEnabled) {
        setIsRootEnvironment(true);
        this->getWorld()=MPI_COMM_NULL;
    }
    
 
    // DESTRUCTORS 
    virtual ~MPI_GridEnvironment(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)*mGridSize.size();
        mem+=sizeof(tBoolean)*mGridPeriodicity.size();
        mem+=sizeof(tMPICoreId)*mIndices.size();
        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
    //============================
    
    template<typename Q>
    inline void  setGridSize(const std::array<Q,N>& Ns)  {
        const Q* iNs=Ns.data();
        for(auto& Nk:mGridSize) {
            Nk=(*iNs);
            iNs++;
        }
    }
    
  
    inline const std::array<tMPICoreId,N>& getGridSize() const {
        return mGridSize;
    }
 
    template<typename Q>
    inline  void setIndices(const std::array<Q,N>& indices)  {
        const Q* iIs=indices.data();
        for(auto& Ik:mIndices) {
            Ik=(*iIs);
            iIs++;
        }
    }
    
    inline const std::array<tMPICoreId,N>& getIndices() const {
        return mIndices;
    }
 
    //neighbors data
    //===============
 
   
public:
   
  
  
 
public:
    inline static tMPIError ComputeGridSize(const MPI_Environment& parent,std::array<tMPICoreId,N>& coresNumber) {
        int nAvailableCores=parent.getCoresNumber();
        return ComputeGridSize(nAvailableCores,coresNumber);
    }
    inline static tMPIError ComputeGridSize(const tMPICoreId& nAvailableCores,std::array<tMPICoreId,N>& coresNumber) {
      
        //number o f needed grids
        int nGrids=1;
        for(const auto& Ck:coresNumber) nGrids*=Ck;
        
        if (nGrids==0) {
            //one dimension is free
            return MPI_Dims_create(nAvailableCores,N,coresNumber.data());
        } else {
            //reduce the number of avalaible core
            return MPI_Dims_create(nGrids,N,coresNumber.data());
        }
    }
    
        
 
    inline static tBoolean  ComputeGridSize(const std::array<tReal,N>& Hs,const std::array<tInteger,N>& Ns,
                                            const tMPICoreId& nCores,std::array<tMPICoreId,N>&  Gs){
        
        tUCInt k;
        // set local constants
        std::array<tReal,N> invLs;
        for(k=0;k<N;k++) invLs[k]=1./(Hs[k]*Ns[k]);
        
        //divisor of nCores : i such that nCores%i=0
        std::valarray<tMPICoreId> divisors(nCores); 
       
        
        // find all the divisors of nCores
        tMPICoreId *iDivisors=&divisors[0];
        for (tMPICoreId i=1;i<=nCores;i++){
            if ((nCores%i)==0){//i divides nCores
                (*iDivisors)=i;
                iDivisors++;
            }
        }
        //number of divisors of nCores
        tMPICoreId nDivisors=(iDivisors-&divisors[0]);
        
        
        tReal surfaceVolume=0.0;
        tReal minSurfaceVolume=functions_numeric::getInfinity<tReal>();
 
        //Gsample : sample for divisor combination of size N
        std::array<tMPICoreId,N> GSample;
        tMPICoreId *iGSample=GSample.data();
        const tMPICoreId *eGSample=iGSample;eGSample+=N;
        
        //number of combinaisons per direction
        std::array<tInteger,N> GNSamples;//=nDivisors
        for(auto& GNS:GNSamples) GNS=nDivisors;
        
        //GIndices
        std::array<tInteger,N> GIndices;//index of divisor
        const tInteger *iGIndices=GIndices.data();;
        //GIndices=0
        memset(GIndices.data(),0,N*sizeof(tInteger));
        
        do {//loop on samples
            
            //Gsample[i]=divisor[GIndices[i]]
            iGIndices=GIndices.data();
            iGSample=GSample.data();
            while (iGSample!=eGSample) {
                (*iGSample)=divisors[(*iGIndices)];
                //iterators at next direction
                iGIndices++;
                iGSample++;
            }
            //test the GSample: 1. prod_k Gsample[k]=nCores
            if (functions_array::product(GSample)==nCores) {
                //2. minimize: S/V
                surfaceVolume=2.0*functions_array::scalarProduct(invLs,GSample);
                
                if (surfaceVolume <minSurfaceVolume) {
                    //minimize the surface/volume value
                    minSurfaceVolume=surfaceVolume;
                    Gs=GSample;
                    //std::cout<<"Grid("<<functions_array::toString(GSample)<<")="<<surfaceVolume<<"\n";
                }
            }
          
            //next indices of sample
        } while (functions_grid::hasNextElement(GNSamples,GIndices));
        return true;
    }
 
 
 
    //periodic data
    //=============
public:
 
    inline const std::array<tBoolean,N>& getGridPeriodicity() const {
        return mGridPeriodicity;
    }
    
    inline const tBoolean& isPeriodic(const tUCInt& k) const {
        return mGridPeriodicity[k];
    }
    
    template<typename Q>
    inline  void setGridPeriodicity(const std::array<Q,N>& Ts) {
        const Q* iTs=Ts.data();
        for(auto& Tk:mGridPeriodicity) {
            Tk=(tBoolean) (*iTs);
            iTs++;
        }
    }
 
 
    
    virtual void initialize() {
        
        SuperClass::initialize();
        
        //initialize the grids number, grids periodicity & grid indices
        std::array<tMPICoreId,N> nGrids;
        std::array<tMPIBoolean,N> periodicity;
        std::array<tMPICoreId,N> indices;
 
        // get:
        // - the grid number per direction
        // - the periodicity per direction
        // - teh indices of the current grid per diercton
        MPI_Cart_get(this->getWorld(),N,nGrids.data(),periodicity.data(),indices.data());
        
        //set the number of grid
        this->setGridSize(nGrids);
        //set the indices of the current grid
        this->setIndices(indices);
        //set if the common grid are periodical
        this->setGridPeriodicity(periodicity);
 
        
    }
 
    
    inline tMPIError  getCoreIdAtIndices(const std::array<tMPICoreId,N>& indices,tMPICoreId& coreId) const {
        return MPI_Cart_rank(this->getWorld(),indices.data(),&coreId);
    }
    
    inline tMPIError  getCoreIndices(const tMPICoreId& coreId,std::array<tMPICoreId,N>& indices) const {
        return MPI_Cart_coords(this->getWorld(),coreId,N,indices.data());
    } 
   
  
    
};
 
 
#endif