EMM_DisplacementFVMOperator.h

Go to the documentation of this file.

#ifndef EMM_DisplacementFVMOperator_H
#define EMM_DisplacementFVMOperator_H

#include "EMM_DisplacementOperator.h"
#include "EMM_DisplacementFVM_Interpolator.h"


DEFINE_SPTR(EMM_DisplacementFVMOperator);
class EMM_DisplacementFVMOperator : public EMM_DisplacementOperator , public virtual EMM_DisplacementFVM_Interpolator {
    
    SP_OBJECT(EMM_DisplacementFVMOperator);
    // ATTRIBUTES
    
    


private:
    //segments number
    tUInteger mSegmentsNumber[3];

    //periodicity
    tBoolean mPeriodicDirections[3];

    //Boundary elements construction
    //===============================
    
    //mNeighborsIndices[e][f]=i
    // - e is a magnetized elements
    // - f : index of faces in [0,EMM_Grid3D::FACES_NUMBER_PER_ELEMENT[
    // - i :
    //    - index of the neighbor cell if i in [0,EMM_Grid3D::UNMAGNETIZED_ELEMENT[
    //    - i-UNMAGNETIZED_ELEMENT is the index of the boundary surface in [0,
    
    CORE_UIndexMorseArray mNeighborsIndices;

  
    //dirichlet boundary  values
    SP::EMM_RealField mU0;

    //for boundary faces 
    tBoolean mIsGhostCellOn;
  
   
    
protected: 
    
    // METHODS
    
    // CONSTRUCTORS 
    
    EMM_DisplacementFVMOperator(void);
    
    // DESTRUCTORS 
    
    virtual ~EMM_DisplacementFVMOperator(void);   
    

    virtual void toDoAfterThisSetting() {
        EMM_DisplacementOperator::toDoAfterThisSetting();
    }
public:
    
    //limit conditions input data
    //===========================
 
  
    public:
  
    virtual void buildDataOnBoundaryFaces(const EMM_Grid3D& mesh,
                                          const EMM_LimitConditionArray& limitConditionOnPoints,
                                          const EMM_RealField& U0,
                                          EMM_RealField& DnU0) {
        buildDataOnDirichletBoundaryFaces(limitConditionOnPoints,
                                          U0,
                                          *mU0.get());
        
        buildDataOnNeumannBoundaryFaces(limitConditionOnPoints,
                                        DnU0);
        
        //set the limit type for  all boundary faces.
        setBoundaryFaceTypes(mesh,limitConditionOnPoints,mNeighborsIndices);
        
    }

    inline const EMM_RealField& getDisplacementOnDirichletBoundary() const {
        return *mU0.get();
    }
    inline EMM_RealField& getDisplacementOnDirichletBoundary()  {
        return *mU0.get();
    }
private:
    void buildDataOnDirichletBoundaryFaces(const EMM_LimitConditionArray& limitConditionOnPoints,
                                           const EMM_RealField& Ut,//U0 on points
                                           EMM_RealField& U0) const;
    void buildDataOnNeumannBoundaryFaces(const EMM_LimitConditionArray& limitConditionOnPoints,
                                         EMM_RealField& C) const;
    
    void setBoundaryFaceTypes(const EMM_Grid3D& mesh,
                              const EMM_LimitConditionArray& limitConditionOnPoints,
                              CORE_UIndexMorseArray& neighborsIndices) const ;

    
    
protected:
    
   
  
   
    //discretization mehods
    //======================
public:
    
    virtual tBoolean discretize(const EMM_LandauLifschitzSystem& system);
    
    virtual tBoolean resetToInitialState(const EMM_LandauLifschitzSystem& system);
    
    virtual tULLInt getMemorySize() const;

    inline  const CORE_UIndexMorseArray & getNeighborsIndices() const {
        return mNeighborsIndices;
    }
    inline   CORE_UIndexMorseArray& getNeighborsIndices() {
        return mNeighborsIndices;
    }

    inline  const tUInteger* getSegmentsNumber() const {
        return mSegmentsNumber;
    }
    inline  const tBoolean* isDirectionPeriodic() const {
        return mPeriodicDirections;
    }
    inline void setIsGhostCellOn(const tBoolean& isOn) {
        mIsGhostCellOn=isOn;
    }
    
    inline const tBoolean& isGhostCellOn() const {
        return mIsGhostCellOn;
    }
    
   
    //Backup & restore
    //==================
     
public:
    virtual tBoolean backup(const tString& prefix,const tString& suffix,const tString& ext) const;
    
    virtual tBoolean restore(const EMM_LandauLifschitzSystem& system,
                             const tString& prefix,const tString& suffix,const tString& ext);
    
    //output data
    //=============

    
    virtual tBoolean getDataFieldSpace(const tUSInt& index,tString& dataName,tFlag& supportType,tString& dFieldType,tUIndex& n,tDimension& dim) const {
        supportType=EMM_Grid3D::ELEMENT;
        dFieldType=CORE_Object::getTypeName<tReal>();
        switch(index) {
        case 0:
            dim=getDisplacement().getDimension();
            dataName="U";
            n=getDisplacement().getSize();
            return true;
            break;
        case 1:
            dataName="dU_dt";
            dim=getVelocity().getDimension();
            n=getVelocity().getSize();
            return true;
            break;
        case 2:
            dataName="acc";
            dim=getAccelerator().getDimension();
            n=getAccelerator().getSize();
            return true;
            break;
        }
        return false;
    }
    
    //time evolutions of fields for unsteady state
    //=============================================
protected:
        
    virtual tBoolean solveAcceleratorSystem(EMM_RealField& V) {
        return true;
    }
    
    virtual void spaceProjection(EMM_RealField& V) const {
    }

    virtual void spaceProjection(const EMM_RealField& V0, EMM_RealField& V) const {
    }
    
public:
    virtual void spaceProjection(const tUIndex& nPoints, const tDimension& dim,const tReal* V0,tReal *V) const {
    }
    
    protected:
    virtual void spaceRelevant(EMM_RealField& V) const{
    };
    
    //steady state method
    //===================
    

    
public:
    
    virtual void setSolver(const tString& solverName);
    
    virtual  void computeEquilibriumMatrixDiagonalConditioner(MATH_Vector& D) const;
  
 
public:

    //GradU reconstruction methods
    //=============================
  
    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* Ni,
                                    const tDimension& dim,
                                    const tReal *Ucells,const tReal *Ui,
                                    const tLimitCondition* lc,const tBoolean& incU0, const tReal* U0,
                                    tReal gradU[9]) const=0;
    
    
    virtual void computeGradUAtFace(const tBoolean& withConstraints,
                                    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 * Ucells,
                                    const tReal* Ui,
                                    const tLimitCondition* lc,const tBoolean& incU0, const tReal* U0,
                                    tReal gradU[9]) const=0;

protected:
    virtual void computeGradAlmostNullUAtFace(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 tLimitCondition* lc,
                                              const tDimension& dim,
                                              const tReal* Ui,
                                              tReal gradU[9]) const=0;
    
    //elastic tensor methods
    //======================

public:
    virtual void computeElasticTensor(const EMM_RealField& U, EMM_2PackedSymmetricTensors& eTensor) {
        EMM_DisplacementOperator::computeElasticTensor(U,eTensor);
    }
    
    
protected:
    
    
    virtual void computeElasticTensor(const tUIndex& nData,
                                      const tDimension& dim,
                                      const tReal* U,
                                      EMM_2PackedSymmetricTensors& eTensor) const;


    
    //stress methods
    //==============
  
protected:
    virtual void computeElasticStress(const tBoolean& withConstraints,const tReal& beta,
                                      const tUIndex& nData,const tDimension& dim, const tReal* U,tReal* S) const;
    
    
    virtual void computeMagneticStress(const tReal& alpha,const tReal& beta,
                                       const tUIndex& nCells,const tDimension& dim, const EMM_RealArray& sigma,
                                       const tReal* M,
                                       const tUIndex& nData,
                                       tReal* D) const;



    //energy methods
    //==============
public:
    virtual tReal computeCineticEnergy(const EMM_RealField& V) const;
    
    /* ! \brief compute the  potential energy to the space variation of the displacement 
     * @param U: displacement field
     * @return potential energy value \f$ \int_\omega (\lambda^e:\varepsilon(u)):\varepsilon(u) d\omega \f$ 
     * 
     */
    virtual tReal computePotentialEnergy(const EMM_RealField& U) const;
    
    tReal  computeStressConstraintEnergy(const EMM_RealField& Uf) const {
        return 0;
    }
    
    
 
  
    //STRING representation
    //=======================
                                   
    virtual tString toString() const {
        tString ret=EMM_DisplacementOperator::toString()+"\n";
        return ret;
    }


   
};

#endif