MPI_GraphGridEnvironment.hpp

#ifndef MPI_GraphGridEnvironment_HPP
#define MPI_GraphGridEnvironment_HPP
 
template<tUCInt N,tUCInt D>
tBoolean  MPI_GraphGridEnvironment<N,D>::LoadGridCartFile(const tString& cartFile,
                                                        const MPI_Environment& env,
                                                        tMPICoreId& nCores,
                                                        std::array<tInteger,N>& gridsNumber,
                                                        std::array<tInteger,N>& coreIndices,
                                                        std::map<tUCInt,tMPICoreId>& dirNeighborCores,
                                                        tBoolean& isCoreInGrid) {
    
    
 
    //initialize the output data
    memset(gridsNumber.data(),0,N*sizeof(tInteger));//nGrids=0
    memset(coreIndices.data(),0,N*sizeof(tInteger));//nGrids=0
 
 
    isCoreInGrid=false;
    nCores=0;
    
    //raeding status
    tMPIStatus status;
 
    //MPI IO File
    MPI_IOFile file;
    
    //set the file name to load
    file.setFileName(cartFile);
    
    //open the file for all cores of environment
    tBoolean ok=file.open(env,file.READ_ONLY );
    if (!ok) {
        //file does not exists
        std::cout<<"file "<<cartFile<<" does not exists\n";
        return false;
    }
    
    //max number of elements to read
    tMPIIOIndex s=0;
    file.getSize(s);
 
    //mpi size of tRelativeInteger
    int mpiRIntSize;
    MPI_Type::GetSize<tRelativeInteger>(mpiRIntSize);
    s/=mpiRIntSize;
    
    //read the values
    std::valarray<tRelativeInteger> gridValues(s);
    ok=ok && file.allRead(gridValues,status);
    ok=ok && file.close();
    if (!ok) {
        std::cout<<" error in reading "<<cartFile<<"\n";
        return false;
    }
    
   
 
    //number of values with directional neighbors
    tUCInt P=MPI_GraphGridEnvironment<N,D>::GetMaximumDirectionalNeighborsNumber();
    tUCInt index;//iterator on P
    
    tIndex nThValues=3+gridsNumber.size()+coreIndices.size()+P;
    nThValues*=functions_array::product<tRelativeInteger,tRelativeInteger,N>(&gridValues[3]);//number of cores
 
    //test if only the neighbors is theface neighbor
    if (nThValues!=gridValues.size()) {
        std::cout<<" bad number of values in  "<<cartFile<<" : "<<gridValues.size()<<" !="<<nThValues<<" gridValues:"<<functions_array::toString(gridValues)<<"\n";
        return false;
    }
    
    //std::cout<<"read from "<<cartFile<<" coreId="<<env.getCoreId()<<" values:"<<functions_functions::toString(gridValues)<<" nFaceValues:"<<nFaceValues<<" , nValues:"<<gridValues.size()<<" isFaceValues:"<<isFaceValues<<" \n";
    
    //iterator on grid cart values
    const tRelativeInteger *iValues=&gridValues[0];
 
    //end iterator on grid cart values
    const tRelativeInteger *eValues=iValues+gridValues.size();
 
    //id of core
    tMPICoreId coreId;
    
    //index of not empty core
    tMPICoreId iCore=0;
    //full indicator
    tRelativeInteger fullIndicator;
 
    //number of grids
    std::array<tInteger,N> nGrids;
 
    //indices of grid
    std::array<tInteger,N> indices;
    
    //neighbor per direction
    std::map<tUCInt,tMPICoreId> dirNeighbors;
    
    //map coreId of the env -> graph grid coreId 
    std::map<tMPICoreId,tMPICoreId> coresMap;
    do {
        //original core id
        coreId=(*iValues);iValues++;
        //number of cores with not empty indicators
        nCores=(*iValues);iValues++;
        //fullIndicator 
        fullIndicator=(*iValues);iValues++;
        //original number of grid
        for(auto& Nd:nGrids) {
            Nd=(*iValues);iValues++;
        }
        //indices of core
        for(auto& Id:indices) {
            Id=(*iValues);iValues++;
        }
       
        //neighbor per direction of cores
        dirNeighbors.clear();
        for(index=0;index<P;index++) {
            if ((*iValues)!=NULL_CORE) dirNeighbors[index]=(*iValues);
            iValues++;
        }
 
        //core is unneeded : ignore
        if (env.getCoreId()>=nCores) {
            isCoreInGrid=false;
            return true;
        }
        //core is needed
        if (fullIndicator>0)  {
            //the core is in the graph cart 
            if (iCore==env.getCoreId()) {
                //the current process is the core
                //register its corresponing data
                gridsNumber=nGrids;
                coreIndices=indices;
                dirNeighborCores=dirNeighbors;
            } 
            //register the core 
            coresMap[coreId]=iCore;
            iCore++;
        }
    } while ((iValues!=eValues)&&(iCore<nCores));
 
    
    //reorder the neihgbor grids indices
   std::map<tMPICoreId,tMPICoreId>::const_iterator iGridCoreId;
   std::map<tUCInt,tMPICoreId>::iterator iDirNeighbor=dirNeighborCores.begin();
   while (iDirNeighbor!=dirNeighborCores.end()) {
       iGridCoreId=coresMap.find(iDirNeighbor->second);
       if (iGridCoreId!=coresMap.end()) {
           iDirNeighbor->second=iGridCoreId->second;
           iDirNeighbor++;
       }else {
           dirNeighborCores.erase(iDirNeighbor);
           iDirNeighbor=dirNeighborCores.begin();
       }
       
   }
   
    isCoreInGrid=true;
 
 
    return true;
}
 
 
 
template<tUCInt N,tUCInt D>
template<typename Q>
tBoolean MPI_GraphGridEnvironment<N,D>::SaveGridCartFile(const MPI_DirectionalGridEnvironment<N,D>& env,
                                                         const tInteger& nFullCores,
                                                         const tInteger& fullId,
                                                         const std::map<tUCInt,Q>& fullDirNeighbor,
                                                         const tString& fileName) {
    
    //grids number
    const std::array<tMPICoreId,N>& nGrids=env.getGridSize();
    //grid indices
    const std::array<tMPICoreId,N>& indices=env.getIndices();
    //dir neighbors
    const std::map<tUCInt,tMPICoreId>& dirNeighbors=env.getDirectionalNeighbors();
 
    //max number of directional neighbors
    tUCInt P=MPI_DirectionalGridEnvironment<N,D>::GetMaximumDirectionalNeighborsNumber();
    
    tUCInt index;//iterator on [0,P[
    
    //number of values to save
    tInteger nGridValues=3+nGrids.size()+indices.size()+P;
    
    //grid values to save
    std::valarray<tRelativeInteger> gridValues(nGridValues);
    
    //set the cart grid values
    tRelativeInteger *iGridValues=&gridValues[0];
    
    //line to write on file
    *iGridValues=env.getCoreId();iGridValues++;//coreId
    *iGridValues=nFullCores;iGridValues++;//number of not empty cores
    *iGridValues=fullId;iGridValues++;//full indicator
    for(const auto& i:nGrids) {*iGridValues=i;iGridValues++;}//number of cores per direction
    for(const auto& i:indices) {*iGridValues=i;iGridValues++;}//indices of the grid per direction
    
    //set neighbor to NULL if neighbor core is empty or this is empty
    typename std::map<tUCInt,Q>::const_iterator iFullDirNeighbor;
    std::map<tUCInt,tMPICoreId>::const_iterator iDirNeighbors;
    for(index=0;index<P;index++) {
        iFullDirNeighbor=fullDirNeighbor.find(index);
        iDirNeighbors=dirNeighbors.find(index);
 
        (*iGridValues)=(
            (fullId==0) ||//enpty core -> no neighbor
            (iDirNeighbors==dirNeighbors.end()) ||//no neighbor
            ((iFullDirNeighbor!=fullDirNeighbor.end())&&//full neigbor indicator with empty data
             (iFullDirNeighbor->second==(Q)false)) ||
            (iFullDirNeighbor==fullDirNeighbor.end())//no in full neighbor : empty by default
            )?NULL_CORE:iDirNeighbors->second;
        
        //iterators at next neighbor grid
        iGridValues++;
    }//dir neighbor grid loop
    
    
    //std::cout<<"write "<<env.getCoreId()<<" values:"<<functions_string::toString(gridValues)<<"\n";
    MPI_IOFile file;
    file.setFileName(fileName);
    tBoolean ok=file.open(env,file.WRITE_ONLY | file.CREATE);
    ok=ok && file.writeOrdered(gridValues);
    ok=ok && file.close();
    //std::cout<<"end of saving "<<env.getCoreId()<<"\n";
    return ok;
}
 
 
 
#endif