SMOMPI_OneMasterMacroCellsDemagnetizedField.h

#ifndef SMOMPI_OneMasterMacroCellsDemagnetizedField_H
#define SMOMPI_OneMasterMacroCellsDemagnetizedField_H
 
//base classes
#include "SM_MacroCellsDemagnetizedField.h"
 
//mpi header
#include "MPI_Run.h"
 
//network header
#include "SMOMPI_OneMasterMacroCellsNetwork.h"
 
class SMOMPI_OneMasterMacroCellsDemagnetizedField : public SM_MacroCellsDemagnetizedField {
    
private :
 
    typedef SMOMPI_OneMasterMacroCellsDemagnetizedField SelfClass;
    typedef SM_MacroCellsDemagnetizedField SuperClass;
 
    SM_RealField mDomainH;
    //work array
    std::valarray<tInteger> mCoreBBMacroCellIndices;
    std::valarray<tReal> mCorePHdem;
protected:
    // CONSTRUCTORS 
    SMOMPI_OneMasterMacroCellsDemagnetizedField(void) {
    }
    
    // DESTRUCTORS 
    virtual ~SMOMPI_OneMasterMacroCellsDemagnetizedField(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+=mDomainH.getSize()*sizeof(tReal);
        //work array
        mem+=sizeof(tInteger)*mCoreBBMacroCellIndices.size();
        mem+=sizeof(tReal)*mCorePHdem.size();
        return mem;
    }
public:
  
  
    inline const SM_RealField& getBoundingBoxMacroCellsDemagnetizedField() const {
        return mDomainH;
    }
    inline SM_RealField& getBoundingBoxMacroCellsDemagnetizedField()  {
        return mDomainH;
    }
    
    virtual  void discretize(const SM_Material& material,const SM_MacroCellsNetwork& network) final;
    
    
    virtual void computeMatrix(const SM_Material& material,
                               const SM_MacroCellsNetwork& network) override;
 
public:
   
    
    virtual void computeField(const SM_MacroCellsNetwork& network,
                              const SM_MacroCellsMagnetizationField& M) override;
    
 
    
};
 
 
#endif