SM_MacroCellsMagnetizationField.h

#ifndef SM_MacroCellsMagnetizationField_H
#define SM_MacroCellsMagnetizationField_H
 
//base classes
#include "SM_Object.h"
 
//macro cells network header
#include "SM_MacroCellsNetwork.h"
 
//storage matrix header
#include "SM_PackedBlockSymmetricMatrix.h"
 
 
class SM_MacroCellsMagnetizationField : public virtual SM_Object  {
    
 
public:
  
private :
 
    //type class
    typedef SM_Object SuperClass;
    typedef SM_MacroCellsMagnetizationField SelfClass;
    
    //single attributes
    //-----------------
 
    
    //index of the step when M is last computed
    tIndex mMStepIndex;
 
 
    
    
    //magnetisation field M  at each macro cell at local index m of its SM_MacroCellsNetwork
    SM_RealField mM;
  
 
 
    //multiple associations
    //---------------------
 
    
   
protected:
    // CONSTRUCTORS 
    SM_MacroCellsMagnetizationField(void) {
        mMStepIndex=functions_numeric::getMax<tIndex>();
        
    }
    
    // DESTRUCTORS 
    virtual ~SM_MacroCellsMagnetizationField(void) {
    }
   
    
public : 
 
    //Instance building
    //=================
 
   
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=mM.getContentsMemorySize();
        return mem;
    }
public:
  
    
    virtual CORE_UniquePointer<SM_MacroCellsMagnetizationField> newInstance() const=0;
    
public:
  
    
     //discretize the field
    //======================
public:
    virtual void discretize(const SM_Material& material,const SM_MacroCellsNetwork& network) {
        mM.setElementsNumber(network.getMacroCellsNumber());
        mM=0;
    }
    
 
public:
   
 
 
 
    //MAGNETIZATION Field
    //===================
    
    inline const SM_RealField& getField() const {
        return mM;
    }
  
   
    inline SM_RealField& getField()  {
        return mM;
    }
 
 
    inline const tIndex& getStepIndex() const {
        return mMStepIndex;
    }
protected:
    inline void  setStepIndex(const tIndex& index)   {
        mMStepIndex=index;
    }
 
public:
      
    inline void computeField(const tIndex& stepIndex,
                             const SM_Material& material,
                             const SM_MacroCellsNetwork& network,
                             const SM_RealField& S)  {
        setStepIndex(stepIndex);
        computeField(material,network,S,mM);
    }
 
    
    virtual void computeField(const SM_Material& material,
                              const SM_MacroCellsNetwork& network,
                              const SM_RealField& S,
                              SM_RealField& M);
  
protected:
    void computeFieldSlice(const tReal& mu_s,
                           const tIndex& n,
                           const tInteger* iMacroCellsList,
                           const tReal *iS,
                           tReal* vM) const;
    void computeFieldSlice(const tReal& mu_s,
                           const tInteger& n,
                           const tInteger* iParticlesMCList,
                           const tInteger *iParticlesMCListOffset,
                           const tReal *iS,
                           tReal* vM) const; 
public:
 
    // String representation
    // =======================
public:
 
      
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SuperClass::toString()<<"\n";
        ret<<"M:";
        tIndex s=mM.getElementsNumber()/10;
        s=(s==0)?1:s;
        for(tIndex i=0;i<mM.getElementsNumber();i+=s) {
            ret<<"\t ["<<i<<"]="<<functions_array::toString(SM_Constants::DIM,mM(i))<<"\n";
        }
        return ret.str();
    }
 
public:
    
   
  
};
 
 
#endif