SMOMPI_Network.h

#ifndef SMOMPI_Network_H
#define SMOMPI_Network_H
 
//define a real field
#include "SM_Network.h"
 
 
//mpi header
#include "MPI_Run.h"
 
 
class SMOMPI_Network : public SM_Network {
    
   
private :
    
    //class names
    typedef SMOMPI_Network SelfClass;
    typedef SM_Network SuperClass;
    
    //attributes
    //C0:(0,1,2) -> (0,1,2) local
    //C1:(3,4,5) -> (0,1,2) 
    //C2:(6,7,8) -> (0,1,2)
    //halo connections: (0,3) (1,5) (2,8) (5,6)
 
    //C0:nParticles=3
    //C1:nParticles=3
    //C2:nParticles=3
     
    //index of the core connected core
    //C0:mConnectedCores={1,2}
    //C1:mConnectedCores={0,2}
    //C2:mConnectedCores={1,0}
    std::valarray<tMPICoreId> mConnectedCores;
    
    //halo particles of the core packed by connected cores
    //-------------------------------------------------------
    //mHaloParticles={{local halo particles in Co},...,{local halo particles in C_{nc-1}}
    //C0: mHaloParticles={{3,5},8}  -> {{0,2},{2}} haloParticleIndex={3,4,5}
    //C1: mHaloParticles={{1},{6}}  -> {{1},{0}}   haloParticleIndex=[3,4}
    //C2: mHaloParticles={{5},{2}}  -> {{2},{2}}   haloParticleIndex={3,4}
    //std::valarray<tIndex> mHaloParticles;
  
 
    //index in mHaloParticles of first halo particle of the core c_i of size nc
    //C0:mHaloParticlesOffset={0,2,3}
    //C1:mHaloParticlesOffset={0,1,2}
    //C2:mHaloParticlesOffset={0,1,2}
    std::valarray<tMPIInteger> mHaloParticlesOffset;
    
    //bound particles of this core which are bounds of  the connected core 
    //--------------------------------------------------------------------
    //mBoundParticles={{local bound particles needed by Co},...,{local bound particles needed by C_{nc-1}}
    //C0:mBoundParticles={{1},{2}}   -> {{1},{2}}
    //C1:mBoundParticles={{3,5},{5}} -> {{0,2},{2}}
    //C2:mBoundParticles={{6},{8}}   -> {{0},{2}}
    std::valarray<tIndex> mBoundParticles;
 
 
    //index in mBoundParticles of first bound particle of the core c_i of size nc
    //C0:mBoundParticlesOffset={0,1,2}
    //C1:mBoundParticlesOffset={0,2,3}
    //C2:mBoundParticlesOffset={0,1,2}
    std::valarray<tMPIInteger> mBoundParticlesOffset;
 
    //halo connection id
    std::vector<tMPITag>  mHaloConnectionsTag;
 
    //echange field
    //C0:
    // - receive from C1 to C0  into  {F[3],F[4]}
    // - send    from C0 to C1  {F[1]}
    // - receive from C2 to C0 in {F[5]}
    // - send    from C0 to C2 {F[2]}
    //C1:
    // - receive from C0 to C1  into  {F[3]}
    // - send    from C1 to C0  {F[0],F[2]}
    // - receive from C2 to C1 in {F[4]}
    // - send    from C1 to C2 {F[2]}
    //C2:
    // - receive from C1 to C2  into  {F[3]}
    // - send    from C2 to C1  {F[0]}
    // - receive from C0 to C2 in {F[4]}
    // - send    from C2 to C0 {F[2]}
    
    std::valarray<tReal> mBoundFieldValues;
    std::valarray<tMPIRequest> mRequests;
 
   
    
protected:
    // CONSTRUCTORS 
    SMOMPI_Network(void) {
 
     
 
    }
    
    // DESTRUCTORS 
    virtual ~SMOMPI_Network(void) {
    }
    
public : 
 
    //Instance building
    //=================
    
   
 
 
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=sizeof(tMPIInteger)*mConnectedCores.size();
        //mem+=sizeof(tIndex)*mHaloParticles.size();
        mem+=sizeof(tMPIInteger)*mHaloParticlesOffset.size();
        mem+=sizeof(tIndex)*mBoundParticles.size();
        mem+=sizeof(tMPIInteger)*mBoundParticlesOffset.size();
        mem+=sizeof(tMPITag)*mHaloConnectionsTag.capacity();
        mem+=sizeof(tReal)*mBoundFieldValues.size();
        mem+=sizeof(tMPIRequest)*mRequests.size();
        
        return mem;
    }
 
 
    //NEW
     
    inline static CORE_UniquePointer<SelfClass> New() {
        return CORE_UniquePointer<SelfClass>(new SelfClass(),
                                             SelfClass::Delete());
    }
   
    //SET & GET methods
 
 
    inline void setConnectedCoresNumber(const tMPIInteger& nConnectedCores) {
 
        mConnectedCores.resize(nConnectedCores);
        mHaloParticlesOffset.resize(nConnectedCores+1);
        mBoundParticlesOffset.resize(nConnectedCores+1);
        mRequests.resize(2*nConnectedCores);
        
        functions_array::reset(mHaloParticlesOffset);
        functions_array::reset(mBoundParticlesOffset);
    }
    inline const std::valarray<tMPICoreId>& getConnectedCores() const {
        return mConnectedCores;
    }
    inline std::valarray<tMPICoreId>& getConnectedCores()  {
        return mConnectedCores;
    }
 
    inline void setBoundParticlesNumber(const tIndex& n) {
        mBoundParticles.resize(n);
        mBoundFieldValues.resize(SM_Constants::DIM*n);
    }
 
    inline const std::valarray<tIndex>& getBoundParticles() const {
        return mBoundParticles;
    }
    inline std::valarray<tIndex>& getBoundParticles()  {
        return mBoundParticles;
    }
    
    inline const std::valarray<tMPIInteger>& getBoundParticlesOffset() const {
        return mBoundParticlesOffset;
    }
    inline std::valarray<tMPIInteger>& getBoundParticlesOffset() {
        return mBoundParticlesOffset;
    }
    inline const std::valarray<tMPIInteger>& getHaloParticlesOffset() const {
        return mHaloParticlesOffset;
    }
    inline std::valarray<tMPIInteger>& getHaloParticlesOffset()  {
        return mHaloParticlesOffset;
    }
    inline const std::vector<tMPIInteger>& getHaloConnectionsTag() const {
        return mHaloConnectionsTag;
    }
    inline std::vector<tMPIInteger>& getHaloConnectionsTag()  {
        return mHaloConnectionsTag;
    }
   
    
protected:
    
    
    virtual void computeBoundingBox(std::array<tReal,SM_Constants::DIM>& bbMinPoint,
                                    std::array<tReal,SM_Constants::DIM>& bbSize) const final;
   
  
 
 
    //exchange data field on network
    //--------------------------------
public:
    tBoolean mpiExchangeFieldValues(SM_RealField& F);
 
   
 
    //IO methods
    //=========
protected:
    virtual void saveStatesToFile(std::ofstream& file) const override ;
 
    virtual void loadStatesFromFile(std::ifstream& file,tInteger& version,tDimension& d) override;
    
    virtual void updateState() override;
 
 
    virtual void updateConnectionValues(const tReal& noiseRate,
                                        SM_StochasticFunctionsInterface& randomF,
                                        const tReal& J,
                                        const std::function<void(const tReal&,const tReal& ,const tReal&,tReal& )>& F)  final;
public:
    static inline void ComputeConnectionTag(const tIndex& p,const tIndex& q,tMPITag& tag) {
        if (p<q) {
            tag=q;
            tag--;
            tag*=q;
            tag/=2;
            tag+=p;
        } else {
            ComputeConnectionTag(q,p,tag);
        }
    }
public:
    
    virtual tString toString() const override;
 
};
 
#endif