SMOMPI_DipolarOperator.h

#ifndef SMOMPI_DipolarOperator_H
#define SMOMPI_DipolarOperator_H
 
//base classes
#include "SM_DipolarOperator.h"
 
//MPI environment
#include "MPI_Run.h"
#include "MPI_Environment.h"
//#include "MPI_WorldToWorldMessage.h"
#include "MPI_CoreToCoreIMessage.h"
 
class SMOMPI_DipolarOperator : public SM_DipolarOperator {
    
  
private :
    
    //type class
    typedef SMOMPI_DipolarOperator SelfClass;
    typedef SM_DipolarOperator SuperClass;
 
    //attributes
 
    static constexpr tMPITag TAG_P=0;
    static constexpr tMPITag TAG_S=1;
    static constexpr tMPITag TAG_H=2;
 
    mutable std::valarray<tReal> mPc;//particles points P of network at core c
    mutable std::valarray<tReal> mSc;//S at  points P of network at core c 
    
protected:
    // CONSTRUCTORS 
    SMOMPI_DipolarOperator(void) {
        
    }
    
    // DESTRUCTORS 
    virtual ~SMOMPI_DipolarOperator(void) {
    }
   
    
public : 
 
    //Instance building
    //=================
 
    inline static CORE_UniquePointer<SelfClass> New() {
        return CORE_UniquePointer<SelfClass>(new SelfClass(),
                                             SelfClass::Delete());
    }
   
    virtual CORE_UniquePointer<SM_SliceOperator> NewInstance() const override {
        return New();
    }
 
   
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        return mem;
    }
public:
 
    
    //discretize the operator
    //=======================
   
    
protected:
 
    
    //Fields computation
    //==================
public:
 
    
    
    virtual void computeMagneticFieldSlice(const tIndex& timeIndex,
                                           const SM_Network& network,
                                           const SM_Material& material,
                                           const tIndex& startIndex,
                                           const tIndex& endIndex,
                                           const tReal *S,
                                           const tBoolean& alpha,
                                           const tIndex& nH,
                                           tReal *H) const final {
        computeMagneticFieldAtNetwork(material,network,S,network,alpha,nH,H);
    }
 
    void computeMagneticFieldAtNetwork(const SM_Material& material,
                                       const SM_Network& networkP,
                                       const tReal *S_P,
                                       const SM_Network& networkX,
                                       const tBoolean& alpha,
                                       const tInteger& nH,
                                       tReal *H) const ;
    
    //Spin energy computation
    //=======================
  
    virtual tReal computeSpinEnergy(const tIndex& i,
                                    const tIndex& timeIndex,
                                    const SM_Network& network,
                                    const SM_Material& material,
                                    const SM_RealField& S) const final;
    
  
    //Total energy computation
    //========================
public:
 
  
    virtual  tReal computeEnergySlice(const tIndex& timeIndex,
                                      const SM_Network& network,
                                      const SM_Material& material,
                                      const tIndex& startIndex,
                                      const tIndex& endIndex,
                                      const tReal *S) const final;
    
};
 
 
#endif