EMM_DisplacementFVM_Interpolator.h

Go to the documentation of this file.

#ifndef EMM_DisplacementFVM_Interpolator_H
#define EMM_DisplacementFVM_Interpolator_H

#include "EMM_Object.h"

#include "CORE_MorseArray.h"
#include "EMM_RealField.h"


DEFINE_SPTR(EMM_DisplacementFVM_Interpolator);
class EMM_DisplacementFVM_Interpolator : public virtual EMM_Object   {
    
    SP_OBJECT(EMM_DisplacementFVM_Interpolator);
    // ATTRIBUTES
    
    
private:
    
protected:
   
    static const tUIndex NEUMANN_FACE;
    static const tUIndex DIRICHLET_FACE;
    
public:
    
    
    // ASSOCIATION
    
private:

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

    //Get methods

    //neighbors
    //=========
    static tUSInt computeNeighborCellsNumber(const tUInteger& iP,const tUInteger& jP,const tUInteger& kP,
                                             const tUInteger& Nx,const tUInteger& Ny,const tUInteger& Nz,
                                             const tBoolean *periodicity,
                                             const CORE_UIndexMorseArray& neighbors);
    //Vertex interpolations
    //=====================
  
private:
    /* brief interpolate U at vertices when U at all cells is given
     * @param[in] xP: index if the point in the x-direction
     * @param[in] yP: index if the point in the y-direction
     * @param[in] zP: index if the point in the z-direction
     * @param[in] Nx: number of segments in the x-direction
     * @param[in] Ny: number of segments in the y-direction
     * @param[in] Nz: number of segments in the z-direction
     * @param[in] isPeriodic : the periodicity on each direction
     * @param[in] neighborIndices : to indicates if the cell has neighbors
     * @param[in] dim : dimension of each point of fields
     * @param[in] Ucells : the displacement field at the center of each cell
     * @param[in] iCell : index of cell in which U not null
     * @param[in] Ui : value of U at cell icell
     * @param[in] lc : limit condition on all points
     * @param[in] incU0 : 0 for constyant 1 for not constant field U0
     * @param[in] U0 : values of U at dirichlet points
     * @param[in] LCp : limite conditiopn on point P(xP,yP,zP)
     * @param[out] Up : the displacement field at each point of the mesh
     *
     * \f$ U(P) = \frac{1}{N} \sum_{w in \Omega | P \in w } U(w) \f$ with \f$ N=card(w \in  \Omega | P \in \Omega) \f$
     */
    static void interpolateUAtVertex(tUInteger xP,tUInteger yP,tUInteger zP,
                                     const tUInteger& Nx,const tUInteger& Ny,const tUInteger& Nz,
                                     const tBoolean isPeriodic[3],
                                     const CORE_UIndexMorseArray& neighborIndices,
                                     const tDimension& dim,
                                     const tReal* Ucells,
                                     const tUIndex& iCell,const tReal* Ui,
                                     const tLimitCondition* lc,
                                     const tBoolean& incU0,
                                     const tReal *U0,
                                     const tLimitCondition& LCp,
                                     tReal *Up);
public:
   
    
    /* brief interpolate U at vertices when U at all cells is given
     * @param[in] xP: index if the point in the x-direction
     * @param[in] yP: index if the point in the y-direction
     * @param[in] zP: index if the point in the z-direction
     * @param[in] Nx: number of segments in the x-direction
     * @param[in] Ny: number of segments in the y-direction
     * @param[in] Nz: number of segments in the z-direction
     * @param[in] isPeriodic : the periodicity on each direction
     * @param[in] neighborIndices : to indicates if the cell has neighbors
     * @param[in] dim : dimension of each point of fields
     * @param[in] Ucells : the displacement field at the center of each cell
     * @param[in] lc : limit condition on all points
     * @param[in] incU0 : 0 for constant 1 for not constant field U0
     * @param[in] U0 : values of U at dirichlet points
     * @param[in] LCp : limite condition on point P(xP,yP,zP)
     * @param[out] Up : the displacement field at each point of the mesh
     *
     * \f$ U(P) = \frac{1}{N} \sum_{w in \Omega | P \in w } U(w) \f$ with \f$ N=card(w \in  \Omega | P \in \Omega) \f$
     *
     */
    
    static inline void interpolateUAtVertex(tUInteger xP,tUInteger yP,tUInteger zP,
                                            const tUInteger& Nx,const tUInteger& Ny,const tUInteger& Nz,
                                            const tBoolean isPeriodic[3],
                                            const CORE_UIndexMorseArray& neighborIndices,
                                            const tDimension& dim,
                                            const tReal* Ucells,
                                            const tLimitCondition* lc,
                                            const tBoolean& incU0,
                                            const tReal *U0,
                                            const tLimitCondition& LCp,
                                            tReal *Up) {
        interpolateUAtVertex(xP,yP,zP,
                             Nx,Ny,Nz,
                             isPeriodic,
                             neighborIndices,
                             dim,Ucells,
                             0,null,
                             lc,incU0,U0,
                             LCp,
                             Up);
    }
    /* brief interpolate U at vertices when U is null at only one cell and null on dirichlet points
     * @param[in] xP: index if the point in the x-direction
     * @param[in] yP: index if the point in the y-direction
     * @param[in] zP: index if the point in the z-direction
     * @param[in] Nx: number of segments in the x-direction
     * @param[in] Ny: number of segments in the y-direction
     * @param[in] Nz: number of segments in the z-direction
     * @param[in] isPeriodic : the periodicity on each direction
     * @param[in] neighborIndices : to indicates if the cell has neighbors and if the cell is magnetized
     * @param[in] dim : dimension of each point of fields
     * @param[in] iCell: index o the cell where U is not null
     * @param[in] Ui: values of U at cell iCell
     * @param[in] LC : limit condition on all points
     * @param[in] LCp : limit condition on point P(xP,yP,zP)
     * @param[out] Up : the displacement field at each point of the mesh
     *
     * \f$ U(P) = U(w_i) \frac{1}{N} \f$ with \f$ N=card(w \in  \Omega | P \in \Omega) \f$
     */
    static void interpolateAlmostNullUAtVertex(const tUInteger& xP,const tUInteger& yP,const tUInteger& zP,
                                               const tUInteger& Nx,const tUInteger& Ny,const tUInteger& Nz,
                                               const tBoolean isPeriodic[3],
                                               const CORE_UIndexMorseArray& neighborIndices,
                                               const tDimension& dim,
                                               const tUIndex& iCell,const tReal *Ui,
                                               const tLimitCondition* lc,
                                               const tLimitCondition& LCp,
                                               tReal *Up) {
        interpolateUAtVertex(xP,yP,zP,
                             Nx,Ny,Nz,
                             isPeriodic,
                             neighborIndices,
                             dim,null,
                             iCell,Ui,
                             lc,
                             0,null,//null value for dirichlet points
                             LCp,
                             Up);
    }
    
    /* brief interpolate U at vertices
     * @param[in] withDirichlet Points : true to use the values on Dirichlet points (false, the values on dirichlet points is suppoed to be null)
     * @param[in] N :  the number of segments in each direction
     * @param[in] isPeriodic : the periodicity on each direction
     * @param[in] neighborIndices : to indicates if the cell has neighbors and if the cell is magnetized
     * @param[in] Ucells : the displacement field at the center of each cell
     * @param[in] limitConditionOnPoints : the limit condition at each point of mesh
     * @param[in] U0 : the value of the displacement on each dirichlet points
     * @param[out] Up : the displacement field at each point of the mesh
     *
     * \f$ U(P) = U(w_i) \frac{1}{N} \f$ with \f$ N=card(w \in  \Omega | P \in \Omega) \f$
     * \f$ U(P) = U^0(P) \f$ for dirichlet point P
     */
    inline static void interpolateUAtVertices(const tBoolean& withDirichletPoints,
                                              const tUInteger N[3],
                                              const tBoolean isPeriodic[3],
                                              const CORE_UIndexMorseArray& neighborIndices,
                                              const EMM_RealField& Ucells,
                                              const EMM_LimitConditionArray& limitConditionOnPoints,const EMM_RealField& U0,
                                              EMM_RealField& Up) {
        const tReal *vU;
        tUIndex nV;
        Ucells.getValues(nV,vU);
        interpolateUAtVertices(withDirichletPoints,
                               N,isPeriodic,neighborIndices,
                               Ucells.getSize(),Ucells.getDimension(),vU,
                               limitConditionOnPoints,U0,
                               Up);
    }

    /* brief interpolate U at vertices
     * @param withDirichlet Points : true to use the values on Dirichlet points (false, the values on dirichlet points is suppoed to be null)
     * @param N :  the number of segments in each direction
     * @param isPeriodic : the periodicity on each direction
     * @param neighborIndices : to indicates if the cell has neighbors
     * @param U : the displacement field at the center of each cell
     * @param limitConditionOnPoints : the limit condition at each point of mesh
     * @param U0 : the value of the displacement on each dirichlet points
     * @param[out] Up : the displacement field at each point of the mesh
     *
     * \f$ U(P) = U(w_i) \frac{1}{N} \f$ with \f$ N=card(w \in  \Omega | P \in \Omega) \f$
     * \f$ U(P) = U^0(P) \f$ for dirichlet point P
     */
   static  void interpolateUAtVertices(const tBoolean& withDirichletPoints,
                                       const tUInteger N[3],
                                       const tBoolean isPeriodic[3],
                                       const CORE_UIndexMorseArray& neighborIndices,
                                       const tUIndex& nCells,const tDimension& dim,const tReal *U,
                                       const EMM_LimitConditionArray& limitConditionOnPoints,const EMM_RealField& U0,
                                       EMM_RealField& Up);


    //edges interpolations
    //====================
public:


    void interpolateUAtEdge(const tBoolean& withConstraints,
                            const tUInteger& xCell,const tUInteger& yCell,const tUInteger& zCell,
                            const tUInteger& Px,const tUInteger& Py,const tUInteger& Pz,
                            const tBoolean* periodicity,
                            const tDimension& dim,
                            const tUCInt& l,const tUCInt& r,
                            const tReal *Ucells,const tReal* Uc,
                            const tLimitCondition* lc,
                            const tBoolean& incU0,const tReal* U0,
                            const tUIndex* Nc,const CORE_UIndexMorseArray& neighbors,
                            tReal *iUc,
                            const tReal* &iU) const;
    

    static tBoolean edgeMean(const tUInteger& xCell,
                             const tUInteger& yCell,
                             const tUInteger& zCell,
                             const tUCInt& f,
                             const tUCInt& g,
                             const tBoolean *isPeriodic,
                             const tUInteger& Px,
                             const tUInteger& Py,
                             const tUInteger& Pz,
                             const tDimension& dim,
                             const tLimitCondition* lc,
                             const tBoolean& incU,
                             const tReal* Upoints,
                             tReal *Um);
   
    //faces interpolations
    //====================
public:
       
    static inline void interpolateUAtFace(const tUInteger& xCell,const tUInteger& yCell,const tUInteger& zCell,
                                          const tUInteger& Px,const tUInteger& Py,const tUInteger& Pz,
                                          const tBoolean periodicity[3],
                                          const CORE_UIndexMorseArray& neighborsIndices,//neighbor indicesof cells
                                          const tUCInt& f,
                                          const tDimension& dim,//dimension of the point 
                                          const tReal* Ucells,//U at all the cells
                                          const tLimitCondition *lc,const tBoolean& incU0, const tReal* U0,
                                          tReal *Umean) {
        interpolateUAtFace(xCell,yCell,zCell,Px,Py,Pz,
                           periodicity,neighborsIndices,f,dim,
                           Ucells,
                           null,
                           lc,incU0,U0,
                           Umean);
    }
    
    static void interpolateAlmostNullUAtFace(const tUInteger& xCell,const tUInteger& yCell,const tUInteger& zCell,
                                             const tUInteger& Px,const tUInteger& Py,const tUInteger& Pz,
                                             const tBoolean periodicity[3],
                                             const CORE_UIndexMorseArray& neighborsIndices,//neighbor indicesof cells
                                             const tUCInt& f,
                                             const tDimension& dim,//dimension of the point 
                                             const tReal* Ui,//U at cell (xCell,yCell,zCell)
                                             const tLimitCondition *lc,const tBoolean& incU0, const tReal* U0,
                                             tReal *Umean)  {
        interpolateUAtFace(xCell,yCell,zCell,
                           Px,Py,Pz,
                           periodicity,
                           neighborsIndices,
                           f,
                           dim,
                           null,
                           Ui,
                           lc,incU0,U0,
                           Umean);
    }

private:
     
    static void interpolateUAtFace(const tUInteger& xCell,const tUInteger& yCell,const tUInteger& zCell,
                                   const tUInteger& Px,const tUInteger& Py,const tUInteger& Pz,
                                   const tBoolean periodicity[3],
                                   const CORE_UIndexMorseArray& neighborsIndices,//neighbor indicesof cells
                                   const tUCInt& f,
                                   const tDimension& dim,//dimension of the point
                                   const tReal *Ucells,//U at cells
                                   const tReal* Ui,//U at cell (xCell,yCell,zCell)
                                   const tLimitCondition *lc,const tBoolean& incU0, const tReal* U0,
                                   tReal *Umean) ;
    
public:
    static tBoolean faceMean(const tUInteger& xCell,
                             const tUInteger& yCell,
                             const tUInteger& zCell,
                             const tUCInt& f,
                             const tBoolean* isPeriodic,
                             const tUInteger& Px,
                             const tUInteger& Py,
                             const tUInteger& Pz,
                             const tDimension& dim,
                             const tLimitCondition* lc,
                             const tBoolean& incU,
                             const tReal* Upoints,
                             tReal *Um);
    
    
    

    //cell interpolations
    //====================
public:
    
    static tBoolean cellMean(const tUInteger& xCell,
                             const tUInteger& yCell,
                             const tUInteger& zCell,
                             const tBoolean* isPeriodic,
                             const tUInteger& Px,
                             const tUInteger& Py,
                             const tUInteger& Pz,
                             const tDimension& dim,
                             const tLimitCondition* lc,
                             const tBoolean& incU,
                             const tReal* Upoints,
                             tReal *Um);
    
    
   
};

#endif