EMM_MultiScaleCDGrid.h

Go to the documentation of this file.

#ifndef EMM_MultiScaleCDGrid_H
#define EMM_MultiScaleCDGrid_H

#include "EMM_MultiScaleGrid.h"


DEFINE_SPTR(EMM_MultiScaleCDGrid);
class EMM_MultiScaleCDGrid : public virtual EMM_MultiScaleGrid {
  
    SP_OBJECT(EMM_MultiScaleCDGrid);
    // ATTRIBUTES
  
  
    
public: 
    // METHODS
  
    // CONSTRUCTORS 
  
    EMM_MultiScaleCDGrid(void);
  
    // DESTRUCTORS 
    
    virtual ~EMM_MultiScaleCDGrid(void);   
  
  
public:
    inline static SP::EMM_MultiScaleCDGrid New() {
        SP::EMM_MultiScaleCDGrid ret(new EMM_MultiScaleCDGrid(),
                                     EMM_MultiScaleCDGrid::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);
    
public:
    
    void meanValuesFromFineToCoarseGrid(const tUIndex& nCells,
                                        const tDimension& dim,
                                        const tReal* Mf,
                                        tReal *Ml) const;
    
    
   
    inline void completeValuesOutsideFineGridByPeriodicity(const tUIndex& nCells,
                                                           const tDimension& dim,
                                                           tReal *Ml) const {
        completeValuesOutsideFineGridByPeriodicityByExclusion(nCells,dim,Ml);
    }

private:
    void completeValuesOutsideFineGridByPeriodicityByExclusion(const tUIndex& nCells,
                                                               const tDimension& dim,
                                                               tReal *Ml) const;
    
public:
    
   
   
    /* \brief reset the the value of the field M at the fine grid
     * @param[in] nCells : number of cells of the mesh
     * @param[in] dim: dimension of each point of the mesh
     * @param[out] M: magnetization values of size nCells x dim of the coarse grid
     * @return false if the centered zone is empty
     *
     * Set to 0 the values of M at the fine grid
     *
     * 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 resetValuesWithinCenteredZone(const tUIndex& nCells,const tDimension& dim,tReal *Mz) const;

    void addValuesFromCoarseGridToFinestGrid(const tUIndex& nCells,
                                             const tDimension& dim,
                                             const tUInteger& twoPowerL,
                                             const tReal* Ml,
                                             tReal* Mf) const;

    
protected:

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

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

private:
     
    void computeMagnetizationFieldAtNextLevel(const tUIndex& nCells,
                                              const tDimension& dim,
                                              const tReal* Ml,
                                              tReal *Mlp1) const;
    
    void computeDemagnetizedExcitationFieldFromLevel(const tUInteger& twoPowerL,
                                                     const tUIndex& nCells,
                                                     const tDimension& dim,
                                                     tReal *Ml,
                                                     tReal *H0) const;
   
    
    
public:
  
    //OTHER methods
 
   
};

#endif