SM_MacroCellsDemagnetizedOperator.h

#ifndef SM_MacroCellDemagnetizedOperator_H
#define SM_MacroCellDemagnetizedOperator_H
 
//base classes
#include "SM_SliceOperator.h"
 
//macro cell demagnetized field header
#include "SM_MacroCellsNetwork.h"
#include "SM_MacroCellsMagnetizationField.h"
#include "SM_MacroCellsDemagnetizedField.h"
 
 
class SM_MacroCellsDemagnetizedOperator : public SM_SliceOperator {
    
 
public:
   
private :
 
    //type class
    typedef SM_SliceOperator SuperClass;
    typedef SM_MacroCellsDemagnetizedOperator SelfClass;
    
    //single attributes
    //-----------------
    
    //multiple attributes
    //------------------
 
    //single associations
    //-------------------
 
    CORE_UniquePointer<SM_MacroCellsNetwork> mMC_Network;
    CORE_UniquePointer<SM_MacroCellsMagnetizationField> mMC_M;
    CORE_UniquePointer<SM_MacroCellsDemagnetizedField> mMC_Hdem;
    
    //multiple associations
    //---------------------
 
    
   
protected:
    // CONSTRUCTORS 
    SM_MacroCellsDemagnetizedOperator(const CORE_OptionsList& arguments);
    
    // DESTRUCTORS 
    virtual ~SM_MacroCellsDemagnetizedOperator(void);
    
public : 
 
    //Instance building
    //=================
 
   
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=(mMC_Hdem.get()==null)?0:mMC_Hdem->getContentsMemorySize();
        mem+=(mMC_M.get()==null)?0:mMC_M->getContentsMemorySize();
        mem+=(mMC_Network.get()==null)?0:mMC_Network->getContentsMemorySize();
        return mem;
    }
 
    //New instance
    //===========
 
    
    
public:
    inline  void setMacroCellsNetwork(CORE_UniquePointer<SM_MacroCellsNetwork> network) {
        mMC_Network=std::move(network);
    }
    inline SM_MacroCellsNetwork& getMacroCellsNetwork() {
        return *mMC_Network.get();
    }
    inline const SM_MacroCellsNetwork& getMacroCellsNetwork() const {
        return *mMC_Network.get();
    }
 
    
    inline  void setMacroCellsMagnetizationField(CORE_UniquePointer<SM_MacroCellsMagnetizationField> f) {
        mMC_M=std::move(f);
    }
    inline SM_MacroCellsMagnetizationField& getMacroCellsMagnetizationField() {
        return *mMC_M.get();
    }
    inline const SM_MacroCellsMagnetizationField& getMacroCellsMagnetizationField() const {
        return *mMC_M.get();
    }
 
    
    inline  void setMacroCellsDemagnetizedField(CORE_UniquePointer<SM_MacroCellsDemagnetizedField> f) {
        mMC_Hdem=std::move(f);
    }
    inline SM_MacroCellsDemagnetizedField& getMacroCellsDemagnetizedField() {
        return *mMC_Hdem.get();
    }
    inline const SM_MacroCellsDemagnetizedField& getMacroCellsDemagnetizedField() const {
        return *mMC_Hdem.get();
    }
    
  
  
    
public:
 
    //discretize the operator
    //======================
    
    virtual void discretize(const SM_Network& network,
                            const SM_Material& material) override;
public:
    //Fields computation
    //==================
    virtual void updateState(const tIndex& timeIndex,
                             const SM_Network& network,
                             const SM_Material& material,
                             const SM_RealField& S) override;
     
    
    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 ;
 
    virtual tReal computeSpinEnergy(const tIndex& i,
                                    const tIndex& timeIndex,
                                    const SM_Network& network,
                                    const SM_Material& material,
                                    const SM_RealField& S) const override;
    
    
    virtual tReal computeEnergySlice(const tIndex& stepIndex,
                                     const SM_Network& network,
                                     const SM_Material& material,
                                     const tIndex& startIndex,
                                     const tIndex& endIndex,
                                     const tReal *S) const override;
    
    
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SuperClass::toString()<<"\n";
        ret<<"MCs network:"<<mMC_Network->toString()<<"\n";
        ret<<"MCs M:"<<mMC_M->toString()<<"\n";
        ret<<"MCs Hdem:"<<mMC_Hdem->toString()<<"\n";
        return ret.str();
    }
  
};
 
 
#endif