EMM_MultiScaleSDGrid.h

Go to the documentation of this file.

#ifndef EMM_MultiScaleSDGrid_H
#define EMM_MultiScaleSDGrid_H

#include "EMM_MultiScaleCDGrid.h"


DEFINE_SPTR(EMM_MultiScaleSDGrid);
class EMM_MultiScaleSDGrid : public virtual EMM_MultiScaleCDGrid {
    
    SP_OBJECT(EMM_MultiScaleSDGrid);
    // ATTRIBUTES
    
    tUInteger mTwoPowerZonalLevelsNumber;

    //H at level l for debug
    SP::CORE_RealArray mHl;
    
    //ASSOCIATIONS
    
    
public: 
    // METHODS
  
    // CONSTRUCTORS 
    
    EMM_MultiScaleSDGrid(void);
    
    // DESTRUCTORS 
    
    virtual ~EMM_MultiScaleSDGrid(void);   
    
    
public:
    inline static SP::EMM_MultiScaleSDGrid New() {
        SP::EMM_MultiScaleSDGrid ret(new EMM_MultiScaleSDGrid(),
                                     EMM_MultiScaleSDGrid::Delete()); 
        ret->setThis(ret);
        return ret;
    }; 
    
    
    virtual void initialize(const tDimension& dim,
                            const tUInteger& Nx,
                            const tUInteger& Ny,
                            const tUInteger& Nz,
                            const tBoolean& Px,
                            const tBoolean& Py,
                            const tBoolean& Pz,
                            const tUInteger& l);
    
    inline void setZonalLevelsNumber(const tUInteger& nLevels) {
        mTwoPowerZonalLevelsNumber=pow(2,nLevels);
        
    }
    

    
    
    
public:
    
    //OTHER methods
    inline static tUCInt getShiftZone(const tUInteger& Nx,const tUInteger& Ny,const tUInteger& Nz,
                                      const tUCInt& z) {
        tUCInt sz=7-z;
        if (isZoneEmpty(Nx,Ny,Nz,sz)) sz=(sz<4)?sz+4:sz-4;
        return sz;
    }
    inline  tUCInt getShiftZone(const tUCInt& z) const {
        const tUInteger *N=getSegmentsNumber();
        return getShiftZone(N[0],N[1],N[2],z);
    }
    inline static tBoolean isZoneEmpty(const tUInteger& Nx,const tUInteger& Ny,const tUInteger& Nz,
                                       const tUCInt& z) {
        
        return ! ( ( ( ((z) & 1) ==1 ) || (Nx/2!=0)) &&
                   ( ( ((z) & 2) ==2 ) || (Ny/2!=0)) &&
                   ( ( ((z) & 4) ==4 ) || (Nz/2!=0)) );
        
        
    }
    inline static tBoolean isZoneEmpty(const tUInteger N[],
                                       const tUCInt& z) {
        
        return ! ( ( ( ((z) & 1) ==1 ) || (N[0]/2!=0)) &&
                   ( ( ((z) & 2) ==2 ) || (N[1]/2!=0)) &&
                   ( ( ((z) & 4) ==4 ) || (N[2]/2!=0)) );
        
        
    }

    
    
    tBoolean computeValuesOnShiftFineGrid(const tUIndex& nCells,const tDimension& dim,const tReal *M,
                                          const tUCInt& z,tReal *Mz) const;
    
    void  meanValuesFromShiftFineGridToCoarseGrid(const tUIndex& nCells,const tDimension& dim,
                                                  const tUCInt& z,const tReal *Mz,
                                                  tReal *M) const;

    /* \brief reset the the value of the field M at shift zone
     * @param[in] nCells : number of cells of the mesh
     * @param[in] dim: dimension of each point of the mesh
     * @param[in] z: zone of the grid 
     * @param[out] Mz: magnetization values of size nCells x dim at zone z of the grid to set to 0
     * @return false if the volume of the zone z is null
     *
     * Set to 0 the values of M at zone z
     
     * the algorithm is as follow:
     * - the segment indices of zone z is in \f$ [i_{min},i_{max}[ \times  [j_{min},j_{max}[ \times  [k_{min},k_{max}[ \f$
     *      - for zone 0 \f$ [i_{min},i_{max}[=[0,N_x/2[\f$
     *      - for zone 1 \f$ [i_{min},i_{max}[=[N_x/2,N_x[\f$
     * - the zone is considered as a sequence of N blocks of size S.
     * - Each block are set to 0. the first element of block is at index \f$(i_s,j_s,k_s) \f$ where
     *    - \f$ \forall s, i_s=i_{min} \f$ and \f$ \forall s,j_{s+1}=j_s+1 ,k_{s+1}=k_s+1 \f$ if the blocks are oriented in the x-direction (\f$N_x \neq 1\f$)
     *    - \f$ \forall s, j_s=j_{min} \f$ and \f$ \forall s,i_{s+1}=i_s+1 ,k_{s+1}=k_s+1 \f$ if the blocks are oriented in the y-direction (\f$N_x \eq 1 \f$ and\f$N_y \neq 1 \f$ )
     *    - \f$ \forall s, k_s=k_{min} \f$ and \f$ \forall s, i_{s+1}=i_s+1 ,j_{s+1}=j_s+1 \f$ if the blocks are oriented in the z-direction (\f$N_x \eq 1 \f$ and\f$N_y \eq 1 \f$ and \f$ $N_z \neq 1 \f$)
     *    - if \f$ i_{s+1}>=i_{max} \f$ then \f$ i_{s+1}=i_{min} \f$
     *    - if \f$ j_{s+1}>=j_{max} \f$ then \f$ j_{s+1}=j_{min} \f$
     *    - if \f$ k_{s+1}>=j_{max} \f$ then \f$ k_{s+1}=k_{min} \f$
     */
    tBoolean resetValuesWithinShiftZone(const tUIndex& nCells,const tDimension& dim,
                                        const tUCInt& z,tReal *Mz) const;
 


    tBoolean addValuesFromGridToZoneFinestGrid(const tUInteger& twoPowerLp1,
                                               const tDimension& dim,
                                               const tUInteger& Nx,
                                               const tUInteger& Ny,
                                               const tUInteger& Nz,
                                               const tUCInt& z,
                                               tInteger& Sx,
                                               tInteger& Sy,
                                               tInteger& Sz,
                                               const tReal *Hz,
                                               tReal *H) const;
    
    tBoolean addValuesFromShiftFineGridToFinestGrid(const tUIndex& nCells,const tDimension& dim,const tUInteger& twoPowerL,
                                                    const tUCInt& z,const tReal *Hz,tReal *H) const;

    tBoolean addValuesFromCoarseGridToFinestGrid(const tUIndex& nCells,const tDimension& dim,
                                                 const tUInteger& twoPowerL,
                                                 const tUCInt& z,const tReal *Hz,tReal *H) const;

protected:
    virtual void computeZonalDemagnetizedFieldAndNextLevelMagnetizationField(const tUInteger& twoPowerL,
                                                                             const tUIndex& nCells,
                                                                             const tDimension& dim,
                                                                             const tReal* Ml,
                                                                             tReal *Mz,
                                                                             tReal *Mlp1,
                                                                             tReal *H0) const;


    virtual void computeZonalCenteredDemagnetizedFieldFromLevel(const tUInteger& twoPowerL,
                                                                const tUIndex& nCells,
                                                                const tDimension& dim,
                                                                tReal* Ml,
                                                                tReal *Mz,
                                                                tReal *H0) const;

    //old version to be removed
    // virtual void computeMultiGridExcitationField(const tUIndex& nCells,
    //                                              const tDimension& dim,
    //                                              const tReal* sigmaM,
    //                                              tReal * H);
    
};

#endif