EMM_DisplacementFVM_VTEGROperator.h

Go to the documentation of this file.

#ifndef EMM_DisplacementFVM_VTEGROperator_H
#define EMM_DisplacementFVM_VTEGROperator_H

#include "EMM_DisplacementFVM_VGROperator.h"

DEFINE_SPTR(EMM_DisplacementFVM_VTEGROperator);
class EMM_DisplacementFVM_VTEGROperator : public EMM_DisplacementFVM_VGROperator  {
    
    SP_OBJECT(EMM_DisplacementFVM_VTEGROperator);
    // ATTRIBUTES
    
    
private:
    
    
    
public:
    
    
    // ASSOCIATION
    
private:

  
   
   
    
protected: 
    
    // METHODS
    
    // CONSTRUCTORS 
    
    EMM_DisplacementFVM_VTEGROperator(void);
    
    // DESTRUCTORS 
    
    virtual ~EMM_DisplacementFVM_VTEGROperator(void);   
    
    
public:
    
    
    //SET Methods
    //============


  
    
public:
   
   
    
     //Grad U at cell reconstruction
    //=============================
 
    virtual void computeGradUAtCell(const tBoolean& withConstraints,const tReal *h,
                                    const tUInteger& xCell, const tUInteger& yCell,const tUInteger& zCell,
                                    const tUInteger& Px, const tUInteger& Py,const tUInteger& Pz,
                                    const tBoolean *periodicity,
                                    const tUIndex* neighbors,
                                    const tDimension& dim,
                                    const tReal *Ucells,const tReal *Ui,
                                    const tLimitCondition* lc,const tBoolean& incU0, const tReal* U0,
                                    tReal gradU[9]) const {
        
        computeGradUAtCellByTaylorExpansionWithNeumannInterpolation(withConstraints,
                                                                    h,xCell,yCell,zCell,
                                                                    Px,Py,Pz,
                                                                    periodicity,
                                                                    neighbors,
                                                                    dim,
                                                                    Ucells,Ui,
                                                                    lc,incU0,U0,
                                                                    gradU);
    }

protected:

    virtual void computeGradAlmostNullUAtCell(const tReal *h,
                                              const tUInteger& xCell,
                                              const tUInteger& yCell,
                                              const tUInteger& zCell,
                                              const tUInteger& Px,
                                              const tUInteger& Py,
                                              const tUInteger& Pz,
                                              const tBoolean *periodicity,
                                              const CORE_UIndexMorseArray& neighborsIndices,
                                              const tDimension& dim,
                                              const tReal *Ui,
                                              tReal gradU[9]) const{
        
        computeGradAlmostNullUAtCellByTaylorExpansionWithNeumannInterpolation(h,
                                                                              xCell,yCell,zCell,
                                                                              Px,Py,Pz,
                                                                              neighborsIndices[xCell+(Px-1)*(yCell+(Py-1)*zCell)],
                                                                              dim,Ui,
                                                                              gradU);
    }

    virtual void computeGradAlmostNullUAtNextCell(const tReal *h,
                                                  const tUInteger& xCell,
                                                  const tUInteger& yCell,
                                                  const tUInteger& zCell,
                                                  const tUCInt& f,
                                                  const tUIndex& nextCell,
                                                  const tUInteger& Px,
                                                  const tUInteger& Py,
                                                  const tUInteger& Pz,
                                                  const tBoolean *periodicity,
                                                  const CORE_UIndexMorseArray& neighborsIndices,
                                                  const tDimension& dim,
                                                  const tReal *Ui,
                                                  tReal gradU[9]) const {
        
        computeGradAlmostNullUAtNextCellByTaylorExpansionWithNeumannInterpolation(h,
                                                                                  xCell,yCell,zCell,
                                                                                  f,
                                                                                  Px,Py,Pz,
                                                                                  neighborsIndices[nextCell],
                                                                                  dim,Ui,
                                                                                  gradU);
    }
    
  
    
private:
    
    
    void computeGradUAtCellByTaylorExpansionWithNeumannInterpolation(const tBoolean& withConstraints,
                                                                     const tReal *h,
                                                                     const tUInteger& xCell, const tUInteger& yCell,const tUInteger& zCell,
                                                                     const tUInteger& Px, const tUInteger& Py,const tUInteger& Pz,
                                                                     const tBoolean *periodicity,
                                                                     const tUIndex* neighbors,
                                                                     const tDimension& dim,
                                                                     const tReal *U,const tReal *Ui,
                                                                     const tLimitCondition* lc,const tBoolean& incU0, const tReal* U0,
                                                                     tReal gradU[9]) const;


    void computeGradAlmostNullUAtCellByTaylorExpansionWithNeumannInterpolation(const tReal *h,
                                                                               const tUInteger& xCell,
                                                                               const tUInteger& yCell,
                                                                               const tUInteger& zCell,
                                                                               const tUInteger& Px,
                                                                               const tUInteger& Py,
                                                                               const tUInteger& Pz,
                                                                               const tUIndex* neighbors,
                                                                               const tDimension& dim,
                                                                               const tReal* Ucell,
                                                                               tReal gradU[9]) const;
    void computeGradAlmostNullUAtNextCellByTaylorExpansionWithNeumannInterpolation(const tReal *h,
                                                                                   const tUInteger& xCell,
                                                                                   const tUInteger& yCell,
                                                                                   const tUInteger& zCell,
                                                                                   const tUSInt& f,
                                                                                   const tUInteger& Px,
                                                                                   const tUInteger& Py,
                                                                                   const tUInteger& Pz,
                                                                                   const tUIndex* neighbors,
                                                                                   const tDimension& dim,
                                                                                   const tReal* Ucell,
                                                                                   tReal gradU[9]) const;
    
 
    
    //STRING representation
    //=======================
                                   
    virtual tString toString() const {
        tString ret=EMM_DisplacementFVMOperator::toString()+"\n";
        return ret;
    }


   
};

#endif