SM_MacroCellsExternalDemagnetizedOperator.h

#ifndef SM_MacroCellsExternalDemagnetizedOperator_H
#define SM_MacroCellsExternalDemagnetizedOperator_H
 
//base classes
#include "SM_MacroCellsDemagnetizedOperator.h"
 
 
class SM_MacroCellsExternalDemagnetizedOperator : public SM_MacroCellsDemagnetizedOperator {
    
 
public:
   
private :
 
    //type class
    typedef SM_MacroCellsDemagnetizedOperator SuperClass;
    typedef SM_MacroCellsExternalDemagnetizedOperator SelfClass;
    
    //single attributes
    //-----------------
  
     
    //number of steps to update demagnetized field
    tInteger mUpdateDemagnetizedSteps;
    
    //multiple attributes
    //------------------
 
    //single associations
    //-------------------
 
 
    
    //multiple associations
    //---------------------
 
    
   
protected:
    // CONSTRUCTORS 
    SM_MacroCellsExternalDemagnetizedOperator(const CORE_OptionsList& arguments);
    
    // DESTRUCTORS 
    virtual ~SM_MacroCellsExternalDemagnetizedOperator(void);
    
public : 
 
    //Instance building
    //=================
 
   
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        return mem;
    }
public:
 
    //New Instance
 
    inline static CORE_UniquePointer<SelfClass> New(const CORE_OptionsList& arguments) {
        return CORE_UniquePointer<SelfClass>(new SelfClass(arguments),
                                             SelfClass::Delete());
    }
    inline static CORE_UniquePointer<SelfClass> New() {
        CORE_OptionsList arguments;
        return New(arguments);
    }
     
   
 
    virtual CORE_UniquePointer<SM_SliceOperator> NewInstance() const override {
        CORE_UniquePointer<SelfClass> op=New();
        op->setMacroCellsNetwork(getMacroCellsNetwork().newInstance());
        op->setMacroCellsMagnetizationField(getMacroCellsMagnetizationField().newInstance());
        op->setMacroCellsDemagnetizedField(getMacroCellsDemagnetizedField().newInstance());
        return std::move(op);
    }
    
  
    
    inline void setDemagnetizedUpdatingStepsNumber(const tInteger& n) {
        mUpdateDemagnetizedSteps=n;
    }
    inline const tInteger& getDemagnetizedUpdatingStepsNumber() const {
        return mUpdateDemagnetizedSteps;
    }
 
public:
 
    //discretize the operator
    //======================
    
    virtual void discretize(const SM_Network& network,
                            const SM_Material& material) final  {
 
        SuperClass::discretize(network,material);
 
    
    }
public:
    //Fields computation
    //==================
    virtual void updateState(const tIndex& timeIndex,
                             const SM_Network& network,
                             const SM_Material& material,
                             const SM_RealField& S) final {
 
        if (timeIndex%mUpdateDemagnetizedSteps==0)  {
            SuperClass::updateState(timeIndex,network,material,S);
        }
        
    }
    
    
 
    virtual tReal computeSpinEnergy(const tIndex& i,
                                    const tIndex& timeIndex,
                                    const SM_Network& network,
                                    const SM_Material& material,
                                    const SM_RealField& S) const final;
    
    
    virtual tReal computeEnergySlice(const tIndex& stepIndex,
                                     const SM_Network& network,
                                     const SM_Material& material,
                                     const tIndex& startIndex,
                                     const tIndex& endIndex,
                                     const tReal *S) const final;
    
   
    virtual tString toString() const final {
        std::stringstream ret;
        ret<<SuperClass::toString()<<"\n";
        ret<<"Hdem update steps:"<< mUpdateDemagnetizedSteps<<"\n";
        return ret.str();
    }
};
 
 
#endif