SMOMPI_NoMasterMacroCellsDemagnetizedField.h

#ifndef SMOMPI_NoMasterMacroCellsDemagnetizedField_H
#define SMOMPI_NoMasterMacroCellsDemagnetizedField_H
 
//base classes
#include "SM_MacroCellsDemagnetizedField.h"
 
//mpi header
#include "MPI_Run.h"
#include "MPI_CoreToCoreIMessage.h"
 
//network header
#include "SMOMPI_NoMasterMacroCellsNetwork.h"
 
class SMOMPI_NoMasterMacroCellsDemagnetizedField : public SM_MacroCellsDemagnetizedField {
    
private :
 
    typedef SMOMPI_NoMasterMacroCellsDemagnetizedField SelfClass;
    typedef SM_MacroCellsDemagnetizedField SuperClass;
 
    //tag to send center of massof network
    static constexpr tMPITag TAG_P=99;
    //tag to send magnetization field
    static constexpr tMPITag TAG_M=98;
    
    //single associations
 
    //mpi-communication requests
    std::valarray<tMPIRequest> mReceiveRequests;
    std::valarray<tMPIRequest> mSendRequests;
 
    //MPI requests data
    tMPIInteger mIsAvaliable;//test message is available
    tMPICount mValuesNumber;//the number of values received
    tMPIStatus mStatus;//the status of the received request
    std::map<tMPICoreId,tBoolean>  mIsDataReceivedFromCore;//indicates if the data is received
 
    //numbe rof neighor cores
    tInteger mNeighborCoresNumber;
    
    //values of M at macro cells P
    std::valarray<tReal> mMp_values;
    
    //velues of center of mass of macro cells P
    std::valarray<tReal> mP_values;
    
protected:
    // CONSTRUCTORS 
    SMOMPI_NoMasterMacroCellsDemagnetizedField(void) {
        
        mNeighborCoresNumber=0;
    }
    
    // DESTRUCTORS 
    virtual ~SMOMPI_NoMasterMacroCellsDemagnetizedField(void) {
    }
   
    
public : 
 
    //Instance building
    //=================
 
    
    inline static CORE_UniquePointer<SelfClass> New() {
        return CORE_UniquePointer<SelfClass>(new SelfClass(),
                                             SelfClass::Delete());
    }
 
    virtual CORE_UniquePointer<SM_MacroCellsDemagnetizedField> newInstance() const override {
        CORE_UniquePointer<SelfClass> p=New();
        p->setStorage(getStorage());
        return std::move(p);
    }
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=mReceiveRequests.size()*sizeof(tMPIRequest);
        mem+=mSendRequests.size()*sizeof(tMPIRequest);
        mem+=mMp_values.size()*sizeof(tReal);
        mem+=mP_values.size()*sizeof(tReal);
        mem+=mIsDataReceivedFromCore.size()*(sizeof(tMPICoreId)+sizeof(tBoolean));
        return mem;
    }
public:
 
    virtual  void discretize(const SM_Material& material,const SM_MacroCellsNetwork& network) final {
        
        SuperClass::discretize(material,network);
        
        //MPI environment
        const MPI_Environment& mpiEnv=MPI_Run::GetEnvironment();
        
        //current id of the MPI core
        //const tMPICoreId& coreId=mpiEnv.getCoreId();
       
      
        //number of cores of the environemnt
        const tMPICoreId& coresNumber=mpiEnv.getCoresNumber();
 
        //number of neighboring cores : all except tteh core This
        mNeighborCoresNumber=coresNumber;
        mNeighborCoresNumber--;
        
        //requests for messages
        mSendRequests.resize(2*mNeighborCoresNumber);
        mReceiveRequests.resize(2);
    }
    
    virtual void computeMatrix(const SM_Material& material,
                               const SM_MacroCellsNetwork& network) final {
        
        
        throw CORE_Exception("stochmagnet/operators/fields/mpi",
                             "SMOMPI_NoMasterMacroCellsDemagnetizedField::computeMatrix()",
                             "method not valid for no master core ");
        
    }
    
public:
   
    
    virtual void computeField(const SM_MacroCellsNetwork& network,
                              const SM_MacroCellsMagnetizationField& M) final;
    
private:
    inline void sendDataToAllNeighborCores(const SM_RealField& P,const SM_RealField& M) {
        
        
        //number of values of P (= number of values of M_P)
        tMPICount N_P=P.getSize();
        
        const tReal *vP=null,*vM=null;
        if (N_P>0) {
            vP=&P[0];
            vM=&M[0];
        }
        
        //MPI environment
        const MPI_Environment& mpiEnv=MPI_Run::GetEnvironment();
        
        //current id of the MPI core
        const tMPICoreId& coreId=mpiEnv.getCoreId();
        
        //number of cores
        const tMPICoreId& coresNumber=mpiEnv.getCoresNumber();
        
        
        //sent the mass ceneter (P,M_P) to all neighbor cores
        tMPICoreId c;
        tMPIRequest *iSRequest=&mSendRequests[0];
        for (c=0;c<coreId;c++) {
            //send X  all neighbor cores
            MPI_CoreToCoreIMessage<tReal>::Send(mpiEnv,c,vP,N_P,TAG_P,*iSRequest);
            iSRequest++;
            //send S to all neighbor cores
            MPI_CoreToCoreIMessage<tReal>::Send(mpiEnv,c,vM,N_P,TAG_M,*iSRequest);
            iSRequest++;
            //std::cout<<"core "<<coreId<<" -> "<<N_P<<" (P,S) to "<<c<<"\n";
        }
        for (c=coreId+1;c<coresNumber;c++) {
            //send X  all neighbor cores
            MPI_CoreToCoreIMessage<tReal>::Send(mpiEnv,c,vP,N_P,TAG_P,*iSRequest);
            iSRequest++;
            //send S to all neighbor cores
            MPI_CoreToCoreIMessage<tReal>::Send(mpiEnv,c,vM,N_P,TAG_M,*iSRequest);
            iSRequest++;
            //std::cout<<"core "<<coreId<<" -> "<<N_P<<" (P,S) to "<<c<<"\n";
        }
        
        mIsDataReceivedFromCore.clear();
    }
    
    inline tBoolean waitForDataFromNeighborCores(tMPICoreId& c,tMPICount& nValues,std::valarray<tReal>& Pvalues,std::valarray<tReal>& Mvalues) {
 
        if (mIsDataReceivedFromCore.size()==mNeighborCoresNumber) return false;
        
        //MPI environment
        const MPI_Environment& mpiEnv=MPI_Run::GetEnvironment();
          
      
        //current id of the MPI core
        //const tMPICoreId& coreId=mpiEnv.getCoreId();
        nValues=0;//no data received
        if (MPI_Environment::IsTagMessageAvaliable(mpiEnv,TAG_P,c,mIsAvaliable,mStatus) &&
            MPI_Environment::IsMessageAvaliable(mpiEnv,TAG_M,c,mIsAvaliable) && 
            (mIsDataReceivedFromCore.find(c)==mIsDataReceivedFromCore.end())) {
            //received data from core
            
            //get the number of values sent
            MPI_Environment::GetCount<tReal>(mStatus,nValues);
            
            //resize (P,M) from core c if necessary
            if (((tMPICount)Pvalues.size())<nValues) {
                Pvalues.resize(nValues);
            }
            if (((tMPICount)Mvalues.size())<nValues) {
                Mvalues.resize(nValues);
            }
            
            //receive the messages in best order
            MPI_CoreToCoreIMessage<tReal>::Receive(mpiEnv,c,&Pvalues[0],nValues,TAG_P,mReceiveRequests[0]);
            MPI_CoreToCoreIMessage<tReal>::Receive(mpiEnv,c,&Mvalues[0],nValues,TAG_M,mReceiveRequests[1]);
            //wait for receiving the 2 messages
            MPI_Environment::WaitAll(mReceiveRequests);
            mIsDataReceivedFromCore[c]=true;
            //std::cout<<"core "<<coreId<<" receive "<<nValues<<" (P,S) from "<<c<<"\n";
            
        }
        
        return true;
    }
    
};
 
 
#endif