EMM_RealField.h

Go to the documentation of this file.

#ifndef EMM_RealField_H
#define EMM_RealField_H


#include "EMM_Object.h"

#include "EMM_RealArray.h"

class EMM_VTK;
class EMM_Grid3D;

DEFINE_SPTR(EMM_RealField);
DEFINE_SVPTR(EMM_RealField);
class EMM_RealField : public EMM_Object   {
    
    SP_OBJECT(EMM_RealField);
    // ATTRIBUTES
    
public:
    
    
private:
  
    tDimension mDimension;
    
public:
    // METHODS
    
    //  CONSTRUCTORS 
    
    EMM_RealField();
    
  
    
    
    
    // DESTRUCTORS 
    
    
    virtual ~EMM_RealField(void);
   
private:

    

public:
  
    //copy operator
    //=============
    
    inline EMM_RealField& operator=(const tReal& f) {
        initField(f);
        return (*this);
    }
    
    inline EMM_RealField& operator=(const tReal f[4]) {
        initField(f[0],f[1],f[2]);
        return (*this);
    }
    
    
    inline EMM_RealField& operator=(const EMM_RealField& f) {
        copy(f);
        return (*this);
    }

    //Arithmetic operators
    //====================
    
    inline EMM_RealField& operator+=(const EMM_RealField& f) {
        add(f);
        return (*this);
    }
    inline EMM_RealField& operator-=(const EMM_RealField& f) {
        sub(f);
        return (*this);
    }

    inline EMM_RealField& operator/=(const tReal& f) {
        divideBy(f);
        return (*this);
    }
    inline EMM_RealField& operator*=(const tReal& f) {
        multiplyBy(f);
        return (*this);
    }
    inline EMM_RealField& operator*=(const EMM_RealArray& f) {
        multiplyBy(f);
        return (*this);
    }
    /*  \brief multiply a vector field by a scalar field to obtain a real field :
     * for all i in [0,N[ for all d in [0,3[, This[i][d]/=f[i] 
     * @param f : the divisor array
     * @return this
     */
    inline EMM_RealField& operator/=(const EMM_RealArray& f) {
        divideBy(f);
        return (*this);
    }
    

    virtual SP::EMM_RealField NewInstance() const=0;
    
    
    // SET methods


    virtual void copy(const EMM_RealField& f)=0;

    inline void setDimension(const tDimension& d) {
        mDimension=d;
    }
    virtual void setSize(const tUIndex& n)=0;
    virtual void fitToSize()=0;
   
    
    virtual void initField(const tReal& f)=0;

    inline void initField(const EMM_RealField& f) {
        copy(f);
    };

    virtual tBoolean initField(const tString& fileName)=0;

    virtual void initField(const tReal& v,const EMM_RealField& f)=0;
     
    virtual void initField(const EMM_RealArray& alpha,const EMM_RealField& f)=0;

    virtual void initField(const tReal& s,const EMM_RealArray& alpha,const tSInt& p,const EMM_RealField& f)=0;

    virtual void initField(const tUIndex& from,const tUIndex& to,const EMM_RealField& C)=0;

    inline void initField(const tReal &fx,const tReal& fy,const tReal& fz) {
        initField(0,getSize(),fx,fy,fz);
    }
    
   
    virtual void initField(const tUIndex& from,const tUIndex& to,const tReal &fx,const tReal& fy,const tReal& fz)=0;

  
    
    virtual void unmagnetized(const EMM_Grid3D& mesh)=0;
    
    inline void setValue(const tUIndex& i,const tDimension& k,const tReal& v) {
        setValue(getDimension()*i+k,v);
    }
    
    virtual void setValue(const tUIndex& i,const tReal& v)=0;
    
    virtual void setValue(const tUIndex& i,const tReal vs[])=0;

    virtual void setFieldByReference(const tUIndex& from,const tUIndex& to, EMM_RealField& X)=0;


    virtual void wedge(const EMM_RealField& X,
                       EMM_RealField& Y) const=0;
    
    virtual void wedge(const tReal& alpha,
                       const EMM_RealField& X,
                       EMM_RealField& Y) const=0;
 
    
    
  
    virtual tReal dot(const EMM_RealField& F) const{
        return dot(*this,F);
    }
    virtual tReal dot(const EMM_RealArray& sigma,const EMM_RealField& F) const{
        return dot(sigma,*this,F);
    }
    virtual tReal dot(const EMM_RealField& F,const EMM_RealField& G) const=0;
    virtual tReal dot(const EMM_RealArray& sigma, const EMM_RealField& F,const EMM_RealField& G) const=0;

    inline tReal dot(const tUInt& q,
                     const EMM_RealField& G) const {
        if (q==1) return dot(*this,G);
        if (q==0) return getSize();
        return dot(q,*this,G);
    }
    virtual tReal dot(const tUInt& q,
                      const EMM_RealField& F,const EMM_RealField& G) const=0;

    virtual tReal dot(const tUInt& q,
                      const EMM_RealArray& w,
                      const EMM_RealField& G) const {
        if (q==1) return dot(w,*this,G);
        return dot(q,w,*this,G);
    }
    
    virtual tReal dot( const tUInt& q,
                       const EMM_RealArray& w,
                       const EMM_RealField& F,const EMM_RealField& G) const=0;
    
    virtual void dotArray( const tUInt& q,
                           const EMM_RealArray& w,
                           const EMM_RealField& F,
                           const EMM_RealField& G,
                           EMM_RealArray& R) const=0;
    virtual void dotArray(const EMM_RealArray& w,
                          const EMM_RealField& F,const EMM_RealField& G,
                          EMM_RealArray& R) const=0;
    virtual void dotArray(const EMM_RealField& F,const EMM_RealField& G,
                          EMM_RealArray& R) const=0;

    virtual void dotArray( const tUInt& q,
                           const EMM_RealField& F,const EMM_RealField& G,
                           EMM_RealArray& R) const=0;
    
    inline void dotArray( const tUInt& q,
                          const EMM_RealArray& w,
                          const EMM_RealField& G,
                          EMM_RealArray& R) const {
        dotArray(q,w,*this,G,R);
    }
    inline void dotArray( const tUInt& q,
                          const EMM_RealField& G,
                          EMM_RealArray& R) const {
        dotArray(q,*this,G,R);
    }
    inline void dotArray( const EMM_RealArray& w,
                          const EMM_RealField& G,
                          EMM_RealArray& R) const {
        dotArray(w,*this,G,R);
    }
    inline void dotArray(const EMM_RealField& G,
                         EMM_RealArray& R) const {
        dotArray(*this,G,R);
    }
    
    
    virtual void add(const tReal& alpha,
                     const EMM_RealField& X)=0;
    virtual void add(const EMM_RealArray& alphas,
                     const EMM_RealField& X)=0;

    virtual void add(const tReal& s,
                     const EMM_RealArray& alphas,
                     const tSInt& p,
                     const EMM_RealField& X)=0;

    virtual void normalize()=0;

    virtual void mean(tReal* mean) const=0;

    virtual void mean(const EMM_RealArray& w,tReal* mean) const=0;

    static void mean(const tUIndex& nCells,
                     const tDimension& dim,
                     const tReal * vs, tReal* mean);
    
    static void mean(const tUIndex& nCells,const tDimension& dim,
                     const tReal* ws,const tReal * vs, tReal* mean);
    
    // GET methods
    virtual tULLInt getMemorySize() const=0;
    
       
    virtual tUIndex getSize() const=0;
    
    inline const tDimension& getDimension() const {
        return mDimension;
    }

    inline tReal getValue(const tUIndex& i,const tDimension& k) const {
        return getValue(getDimension()*i+k);
    }
    virtual void getValue(const tUIndex& i,tReal vs[]) const=0;
    
    virtual tReal getValue(const tUIndex& i) const=0;

    virtual tBoolean getValues(tUIndex& size,const float*& values) const {
        size=0;
        return false;
    }
    virtual tBoolean getValues(tUIndex& size,const double*& values) const {
        size=0;
        return false;
    }
    virtual tBoolean getValues(tUIndex& size,const long double*& values) const {
        size=0;
        return false;
    }
    virtual tBoolean getValues(tUIndex& size,float*& values) {
        size=0;
        return false;
    }
    virtual tBoolean getValues(tUIndex& size,double*& values)  {
        size=0;
        return false;
    }
    virtual tBoolean getValues(tUIndex& size,long double*& values) {
        size=0;
        return false;
    }

    virtual tString getTypeToString() const=0;
    
    
public:
    // OTHERS methods

    
    virtual void add(const EMM_RealField& f)=0;
    virtual void sub(const EMM_RealField& f)=0;
    
    virtual void divideBy(const tReal& f)=0;  
    virtual void multiplyBy(const tReal& f)=0;

    virtual void multiplyBy(const EMM_RealArray& f)=0;
    
    virtual void divideBy(const EMM_RealArray& f)=0;

    virtual tReal norm(const tUIndex& index) const=0;

    virtual void  norm(EMM_RealArray& module) const=0;

    virtual tReal normMax(tUIndex& index) const=0;
 

    virtual tReal distanceMax(const EMM_RealField& B,tUIndex& k) const=0;

    virtual tBoolean cellDataToPointData(const EMM_Grid3D& mesh)=0;
    
    virtual tBoolean pointDataToCellData(const EMM_Grid3D& mesh)=0;
    
      
    virtual tString toString(const tUIndex& n) const=0;

    virtual tString toString() const {
        return toString(10);
    }
    
    tBoolean loadFromFile(const tString& fileName);
    
    virtual tBoolean loadFromStream(ifstream& f,const tUSInt& dim)=0;

    virtual tBoolean loadFromStream(ifstream& f,vector<EMM_RealArray*>& indics) =0;
    
    tBoolean saveToFile(const tString& fileName) const;
    
    virtual tBoolean saveToStream(ofstream& stream) const =0;

    virtual tBoolean saveToStream(ofstream& f,const vector<const EMM_RealArray*>& indics) const =0;
 
    virtual tBoolean saveToVTKStream(ofstream& file,EMM_VTK& vtk,const EMM_RealArray& weight,const tString& name) const=0;
    virtual tBoolean saveToVTKStream(ofstream& file,EMM_VTK& vtk,const tString& name) const=0;
   

  
};

#endif