EMMG_SLDemagnetizedOperator.h

Go to the documentation of this file.

#ifndef EMMG_SLDemagnetizedOperator_H
#define EMMG_SLDemagnetizedOperator_H


#include "EMM_DemagnetizedOperator.h"

#include "MATSGN_FFT.h"
#include "MATSGN_ComplexArray.h"

#include "EMMG_RealField.h"

#include "EMMG_SLPeriodicMultiScale.h"

DEFINE_SPTR(EMMG_SLDemagnetizedOperator);
class EMMG_SLDemagnetizedOperator : public virtual EMM_DemagnetizedOperator {
    
    SP_OBJECT(EMMG_SLDemagnetizedOperator);
    // ATTRIBUTES
    
    
private:

    //fftw method
    SP::MATSGN_FFT mFFT;
    tFlag mFFTmethod;
    
    //size of symmetric matrix at each cell 
    tUSInt mLD;
    MATSGN_ComplexArray mMatrix;

    tUIndex mNx;
    tUIndex mNy;
    tUIndex mNz;
    
    mutable EMMG_RealField mWM;
    mutable MATSGN_ComplexArray mFFTarray;
    mutable MATSGN_ComplexArray mHwork;

    
    SP::EMMG_SLPeriodicMultiScale mMultiScaleGrid;
  
    
public:
   

    // ASSOCIATION
 
    
protected: 

    // METHODS
  
    // CONSTRUCTORS 
  
    EMMG_SLDemagnetizedOperator(void);
  
    // DESTRUCTORS 
    
    virtual ~EMMG_SLDemagnetizedOperator(void);   
  
  
public:
   
    inline static SP::EMMG_SLDemagnetizedOperator New() {
        SP::EMMG_SLDemagnetizedOperator p(new EMMG_SLDemagnetizedOperator(),
                                          EMMG_SLDemagnetizedOperator::Delete());
        p->setThis(p);
        return p;
    };
    
    // SET methods
    // ===========
    
    // GET methods
    // ===========
    virtual tULLInt getMemorySize() const {
        return EMM_MagneticExcitationLinearOperator::getMemorySize()+mWM.getMemorySize()+(mMatrix.getSize()+mFFTarray.getSize()+mHwork.getSize())*sizeof(fftw_complex);
    }
    virtual SP::MATSGN_FFT NewFFTInstance() const {
        return MATSGN_FFT::New();
    }

   
    virtual  tUSInt getDataFieldsNumber() const {
        return 0;
    }
   
    virtual tBoolean getDataFieldSpace(const tUSInt& index,tString& dataName,tFlag& supportType,tString& dFieldType,tUIndex& n,tUSInt& dim) const {
        return false;
    }
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tUSInt& dim,const float *& values) const {
        return false;
    }
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tUSInt& dim,const double *& values) const {
        return false;
    }
    virtual tBoolean getDataField(const tUSInt& index,tString& dataName,tUIndex& n,tUSInt& dim,const long double *& values) const {
        return false;
        
    }

    virtual tBoolean discretize(const EMM_LandauLifschitzSystem& system);

private:
    tBoolean projectionOnSpectralSpace(const tUIndex& Nx,
                                   const tUIndex& Ny,
                                   const tUIndex& Nz,
                                   MATSGN_ComplexArray& C);
    void localAssembly(const EMM_IndexArray& iTab,
                       const EMM_IndexArray& jTab,
                       const EMM_IndexArray& kTab,
                       MATSGN_ComplexArray& C_loc2);

public:
    virtual void computeMagneticExcitationField(const EMM_RealArray& sigma,
                                                const EMM_RealField& M,
                                                EMM_RealField& H) const {
        const tDimension& dim=M.getDimension();
        H.setDimension(dim);
        H.setSize(M.getSize());
        //verify the type of H
        const EMMG_RealField *gM=dynamic_cast<const EMMG_RealField *>(&M);
        if (gM==null) throw EMM_Exception("generic","EMMG_SLDemagnetizedOperator:: computeMagneticExcitationField(..)",
                                          "M is an incompatible real field");
        
        //verify the type of H
        EMMG_RealField *gH=dynamic_cast<EMMG_RealField *>(&H);
        if (gH==null) throw EMM_Exception("generic","EMMG_SLDemagnetizedOperator:: computeMagneticExcitationField(..)",
                                          "H is an incompatible real field");
        
        if (mMultiScaleGrid.get()==null) {
            if (sigma.getSize()>1) {
                computeWeightM(sigma,M,mWM);
                product(mNx,mNy,mNz,dim,&mWM[0],mFFTmethod,mFFTarray,mHwork,&(*gH)[0]);
            } else {
                product(mNx,mNy,mNz,dim,&(*gM)[0],mFFTmethod,mFFTarray,mHwork,&(*gH)[0]);
            }
        } else {
            

            mMultiScaleGrid->computeMultiGridExcitationField(M.getSize(),dim,&(*gM)[0],&(*gH)[0]);
        }
    }

    inline void dot(const tUSInt& dim,const tReal *M,tReal *H) {
        product(mNx,mNy,mNz,dim,M,mFFTmethod,mFFTarray,mHwork,H);
    }
    
    virtual tString toString() const;
    
private:
    
    void product(const tUInteger& nx,const tUInteger& ny,const tUInteger& nz,
                 const tUSInt& dim,
                 const tReal *M,
                 const tFlag& fftMethod,
                 MATSGN_ComplexArray& fftArray,
                 MATSGN_ComplexArray& Hwork,
                 tReal* H) const;

    void computeWeightM(const EMM_RealArray& sigma,
                        const EMM_RealField& M,
                        EMM_RealField& weightM) const;
        
};

#endif