SMOMPI_OneMasterMacroCellsNetwork.h

#ifndef SMOMPI_OneMasterMacroCellsNetwork_H
#define SMOMPI_OneMasterMacroCellsNetwork_H
 
//base classes
#include "SM_MacroCellsNetwork.h"
 
//MPI header
#include "MPI_Run.h"
#include "MPI_WorldToWorldMessage.h"
 
class SMOMPI_OneMasterMacroCellsNetwork : public virtual SM_MacroCellsNetwork  {
    
 
public:
private :
  
    //type class
    typedef SM_MacroCellsNetwork SuperClass;
    typedef SMOMPI_OneMasterMacroCellsNetwork SelfClass;
    
    //master core id
    tMPICoreId mMasterCoreId;
    
    // indices converter from   index of macro cell in the not empty macro cells list of this core
    //                   to index of macro cell in not empty maco cells list of the bounding box grid 
    std::valarray<tInteger> mBoundingBoxMacroCellsIndex;
 
    //C defined on not empty macro cell of the whole domain only for the master core id
    SM_RealField mDomainC;
    //volume of macro cells  defined on not empty macro cell of the whole domain only for the master core id
    std::valarray<tReal> mDomainVolumes;
 
    //work array for mpi communication
    std::valarray<tInteger> mCoreBBMacroCellsIndex;
    std::valarray<tReal> mCorePC;
    std::valarray<tInteger> mCorePW;
  
    //MPI tags
    static const tMPITag TAG_IS;
    static const tMPITag TAG_IB;
    static const tMPITag TAG_IR;
 
    static const tMPITag TAG_CREDUCE;
    static const tMPITag TAG_CSCATTER;
 
    
    
protected:
    // CONSTRUCTORS 
    SMOMPI_OneMasterMacroCellsNetwork(void) {
        mMasterCoreId=0;
    }
    
    // DESTRUCTORS 
    virtual ~SMOMPI_OneMasterMacroCellsNetwork(void) {
    }
   
    
public : 
 
    //Instance building
    //=================
 
    inline static CORE_UniquePointer<SelfClass> New() {
        return CORE_UniquePointer<SelfClass>(new SelfClass(),SelfClass::Delete());
    }
    
    virtual CORE_UniquePointer<SM_MacroCellsNetwork> newInstance() const override {
        return New();
    }
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=mDomainC.getSize()*sizeof(tReal);
        mem+=mDomainVolumes.size()*sizeof(tReal);
        mem+=mBoundingBoxMacroCellsIndex.size()*sizeof(tInteger);
        //work array
        mem+=sizeof(tInteger)*mCoreBBMacroCellsIndex.size();
        mem+=sizeof(tReal)*mCorePC.size();
        mem+=sizeof(tInteger)*mCorePW.size();
        return mem;
    }
public:
   
  
public:
 
  
 
 
    
    //Macro cells methods
    //======================
public:
 
    inline const tMPICoreId& getMasterCoreId() const {
        return mMasterCoreId;
    }
    inline void  setMasterCoreId(const tMPICoreId& coreId)  {
        mMasterCoreId=coreId;
    }
    
    inline const std::valarray<tInteger>& getBoundingBoxMacroCellsIndex() const {
        return mBoundingBoxMacroCellsIndex;
    }
    
    inline tInteger getBoundingBoxMacroCellsNumber() const {
        return mDomainC.getElementsNumber();
    }
 
    inline const SM_RealField& getBoundingBoxMacroCellsMassCenter() const {
        return mDomainC;
    }
 
    inline const std::valarray<tReal>& getBoundingBoxMacroCellsVolume() const {
        return mDomainVolumes;
    }
    //discretize the network
    //======================
public:
  
public:
    virtual  void computeMacroCells(const SM_Material& material,
                                    const SM_Network& network) override;
 
    virtual void computeMacroCellsMassCenter(const SM_Material& material,
                                             const SM_Network& network) override;
 
protected:
    virtual void computeBoundingBoxMacroCells(const SM_Material& material,
                                              const SM_Network& network,
                                              const std::array<tReal,SM_Constants::DIM>& P,
                                              const std::array<tReal,SM_Constants::DIM>& Q) override;
 
public:
 
    static tBoolean WaitForBoundingBoxMacroCellsIndexFromNeighborCore(const MPI_Environment& mpiEnv,tMPICoreId& c,
                                                                       const tMPITag& tag,tMPICount& nValues,
                                                                       std::valarray<tInteger>& boundingBoxMacroCellsIndex,
                                                                       tMPIBoolean& isAvaliable,tMPIStatus& status,
                                                                       std::map<tMPICoreId,tBoolean>& isDataReceivedFromCore) ;
    
    
    static tBoolean WaitForWeightFieldFromNeighborCore(const MPI_Environment& mpiEnv,tMPICoreId& c,
                                                       const tMPITag& tagIndices,tMPICount& nIndices,
                                                       std::valarray<tInteger>& boundingBoxMacroCellsIndex,
                                                       const tMPITag& tagX,tMPICount& sX, std::valarray<tReal>& X,
                                                       const tMPITag& tagW,tMPICount& nW, std::valarray<tInteger>& W,
                                                       tMPIBoolean& isAvaliable,tMPIStatus& status,std::array<tMPIRequest,3>& requests,
                                                       std::map<tMPICoreId,tBoolean>& isDataReceivedFromCore);
    static tBoolean WaitForFieldFromNeighborCore(const MPI_Environment& mpiEnv,tMPICoreId& c,
                                                 const tMPITag& tagIndices,tMPICount& nIndices,
                                                 std::valarray<tInteger>& boundingBoxMacroCellsIndex,
                                                 const tMPITag& tagX,tMPICount& sX, std::valarray<tReal>& X,
                                                 tMPIBoolean& isAvaliable,tMPIStatus& status,std::array<tMPIRequest,2>& requests,
                                                 std::map<tMPICoreId,tBoolean>& isDataReceivedFromCore);
    static void SumReduceField(const MPI_Environment& mpiEnv,const tMPICoreId& masterCoreId,const tMPITag& tagX,
                               const std::valarray<tInteger>& BBMacroCellsIndexMap,const SM_RealField& Xc,const std::valarray<tInteger>& Wc,
                               SM_RealField& X,std::valarray<tInteger>& W,
                               std::valarray<tInteger>& coreBBMacroCellsIndex,std::valarray<tReal>& corePX,std::valarray<tInteger>& corePW);
    
    static void SumReduceField(const MPI_Environment& mpiEnv,const tMPICoreId& masterCoreId,const tMPITag& tagX,
                               const std::valarray<tInteger>& BBMacroCellsIndexMap,const SM_RealField& Xc,
                               SM_RealField& X,
                               std::valarray<tInteger>& coreBBMacroCellsIndex,std::valarray<tReal>& corePX);
    
    static void ScatterField(const MPI_Environment& mpiEnv,const tMPICoreId& masterCoreId,
                             const tMPITag& tagX,const SM_RealField& X,
                             const std::valarray<tInteger>& BBMacroCellsIndexMap,SM_RealField& Xc,
                             std::valarray<tInteger>& coreBBMacroCellsIndex,
                             std::valarray<tReal>& coreX);
 
    static void ISendFieldToCore(const MPI_Environment& mpiEnv,const tMPICoreId& c,
                                 const tMPICount& nMCs,
                                 const tInteger* BBMacroCellsIndexMap,
                                 const SM_RealField& X,
                                 const tMPITag& tagX,tMPIRequest& request,
                                 tReal *vXc);
 
    static void SelectFieldValues(const tMPICount& nMCs,
                                  const tInteger* BBMacroCellsIndexMap,
                                  const SM_RealField& X,
                                  tReal *Xs);
    // String representation
    // =======================
public:
 
      
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SuperClass::toString()<<"\n";
        return ret.str();
    }
 
  
};
 
 
#endif