EMM_StaticMagneticTensorOperator.h

Go to the documentation of this file.

#ifndef EMM_StaticMagneticTensorOperator_H
#define EMM_StaticMagneticTensorOperator_H


#include "EMM_MagneticExcitationOperator.h"

#include "EMM_4SymmetricTensors.h"

DEFINE_SPTR(EMM_StaticMagneticTensorOperator);
class EMM_StaticMagneticTensorOperator : public virtual EMM_MagneticExcitationOperator {
    
    SP_OBJECT(EMM_StaticMagneticTensorOperator);
    // ATTRIBUTES
    
    
private:

public:
   

    // ASSOCIATION
 
private:
    
   

    //constraint
    SP::EMM_4SymmetricTensors mLmem;

    
protected: 

    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_StaticMagneticTensorOperator(void);
  
    // DESTRUCTORS 
    
    virtual ~EMM_StaticMagneticTensorOperator(void);
  
   
public:

    
    virtual tBoolean discretize(const EMM_LandauLifschitzSystem& system);
    
    virtual tBoolean isAffine() const {
        return false;
    }
    virtual tBoolean isGradientComputationable() const {
        return true;
    };

    virtual tULLInt getMemorySize() const {
        return EMM_MagneticExcitationOperator::getMemorySize()+mLmem->getMemorySize();
        
    }

    //OPERATOR FIELDS Methods
    //=========================
    virtual tBoolean resetToInitialState(const EMM_LandauLifschitzSystem& system) {
        return true;
    }
    
    virtual tBoolean computeFieldsAtTime(const tReal& t,
                                         const tFlag& order,
                                         const EMM_RealArray& sigma,
                                         const EMM_RealField& dM_dt0,
                                         const EMM_RealField& M0) {
        return true;
    }
    
  
    virtual tBoolean updateAtNextTimeStep(const tReal& dt,
                                         const EMM_RealArray& sigma,
                                         const EMM_RealField& Mt) {
        return true;
    }
     //Magnetic field methods
    //======================

    virtual void computeMagneticExcitationField(const tUIndex & nCells,
                                                const tDimension& dim,
                                                const EMM_RealArray& sigma,
                                                const tReal  *M,
                                                tReal *H) const;
    
    virtual tBoolean computeMagneticExcitationFieldGradient(const tUIndex& nCells,
                                                            const tDimension& dim,
                                                            const EMM_RealArray& sigma,
                                                            const tReal *M,
                                                            const tReal *D,
                                                            tReal  *gradH) const;


    //ENERGY Methods
    //==============
  
    
    virtual tReal computeEnergy(const tReal& t,
                                const tUIndex& nCells,const tDimension& dim,
                                const EMM_RealArray& sigma,
                                const tReal* Mt) const;
    
   
       
};
#endif