EMMG_RealField.h

Go to the documentation of this file.

#ifndef EMMG_RealField_H
#define EMMG_RealField_H

#include "EMM_RealField.h"

#include "EMM_RealArray.h"

DEFINE_SPTR(EMMG_RealField);
DEFINE_SVPTR(EMMG_RealField);
class EMMG_RealField : public EMM_RealField {
    
    SP_OBJECT(EMMG_RealField);
    // ATTRIBUTES
    
public:
    
    
    
private:
  
    EMM_RealArray mArray;
    
    
public:
    // METHODS
    
    //  CONSTRUCTORS 
    
    EMMG_RealField();
    
    
    
    // DESTRUCTORS 
    
    
    virtual ~EMMG_RealField(void);

    static inline SP::EMMG_RealField New() {
        SP::EMMG_RealField p(new EMMG_RealField(),
                                  EMMG_RealField::Delete());
        p->setThis(p);
        return p;
    }
    
    virtual SP::EMM_RealField NewInstance() const {
        SP::EMMG_RealField p=New();
        p->setDimension(getDimension());
        p->setSize(getSize());
        return p;
    }
private:

    

public:
  
    inline tReal& operator()(const tUIndex& i,const tDimension& d) {
        return mArray[getDimension()*i+d];
    }
    inline const tReal& operator()(const tUIndex& i,const tDimension& d) const {
        return mArray[getDimension()*i+d];
    }
    inline tReal& operator[](const tUIndex& i) {
        return mArray[i];
    }
    inline const tReal& operator[](const tUIndex& i) const {
        return mArray[i];
    }
 
    
    // SET methods
    virtual void setSize(const tUIndex& s) {
        mArray.setSize(s*getDimension());
    }
    virtual void copy(const EMM_RealField& f);
    
    virtual void initField(const tReal& alpha,const EMM_RealField& f);
    
    virtual void initField(const EMM_RealArray& alpha,const EMM_RealField& f);
   
    
    virtual void initField(const tUIndex& from,const tUIndex& to,const tReal& fx,const tReal& fy,const tReal& fz);
    
    virtual void initField(const tUIndex& from,const tUIndex& to,const EMM_RealField& C);
    virtual void initField(const tReal& f);
    
    virtual tBoolean initField(const tString& fileName) {
        return loadFromFile(fileName);
    }
    virtual void initField(const tReal& s,const EMM_RealArray& alpha,const tSInt& p,const EMM_RealField& f);

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

    virtual void fitToSize() {
        mArray.fitToSize();
    }
    virtual void setFieldByReference(const tUIndex& from,const tUIndex& to, EMM_RealField& X);
   
    virtual void wedge(const EMM_RealField& X,
                       EMM_RealField& Y) const;

    virtual void wedge(const tReal& alpha,
                       const EMM_RealField& X,
                       EMM_RealField& Y) const;
    
   
    

    virtual tReal dot(const EMM_RealField& F,const EMM_RealField& G) const;
    
    virtual tReal dot(const EMM_RealArray& sigma, const EMM_RealField& F,const EMM_RealField& G) const;
    virtual tReal dot(const tUInt& q,
                      const EMM_RealField& F,const EMM_RealField& G) const;
    virtual tReal dot( const tUInt& q,
                       const EMM_RealArray& w,
                       const EMM_RealField& F,const EMM_RealField& G) const;
    
    virtual void dotArray( const EMM_RealArray& w,
                           const EMM_RealField& F,const EMM_RealField& G,
                           EMM_RealArray& R) const;
    virtual void dotArray( const tUInt& q,
                           const EMM_RealField& F,const EMM_RealField& G,
                           EMM_RealArray& R) const;

    virtual void dotArray(const EMM_RealField& F,const EMM_RealField& G,
                          EMM_RealArray& R) const;
    
    virtual void dotArray( const tUInt& q,
                           const EMM_RealArray& w,
                           const EMM_RealField& F,const EMM_RealField& G,
                           EMM_RealArray& R) const;
    
  
    
private:
   

public:
    
  

    virtual void normalize();

    virtual void mean(tReal* mean) const;

    virtual void mean(const EMM_RealArray& w,tReal* mean) const;
    
    // GET methods
public:
    virtual tULLInt getMemorySize() const {
        return mArray.getMemorySize();
    }
    inline const EMM_RealArray& getArray() const {
        return mArray;
    }
    inline EMM_RealArray& getArray() {
        return mArray;
    }
    
public:
 
    virtual tUIndex getSize() const {
        return mArray.getSize()/getDimension();
    }
    virtual tReal getValue(const tUIndex& i) const {
        return (*this)[i];
    }
    virtual void getValue(const tUIndex& i,tReal vs[]) const {
        const tDimension& dim=getDimension();
        const tReal *v=&(*this)[i*dim];
        tReal *vi=vs;
        for (tDimension i=0;i<dim;i++)  {
            *vi=*v;
            v++;
            vi++;
        }
    }
    virtual tString getTypeToString() const {
        return mArray.getTypeToString();
    }
    virtual tBoolean getValues(tUIndex& size,const float*& values) const {
        if (getTypeToString().compare(CORE_Object::getTypeName<float>())==0) {
            size=getSize();
            
            if (size>0) values=(const float*) &mArray[0];
            else values=null;
            
            size*=getDimension();
            return true;
        }
        return false;
    }
    virtual tBoolean getValues(tUIndex& size,const double*& values) const {
        if (getTypeToString().compare(CORE_Object::getTypeName<double>())==0) {
            size=getSize();
            if (size>0) values=(const double*) &mArray[0];
            else values=null;
            size*=getDimension();
            return true;
        }
        return false;
    }
    virtual tBoolean getValues(tUIndex& size,const long double*& values) const {
        if (getTypeToString().compare(CORE_Object::getTypeName<long double>())==0) {
            size=getSize();
            if (size>0) values=(const long double*) &mArray[0];
            else values=null;
            size*=getDimension();
            return true;
        }
        return false;
    }
    virtual tBoolean getValues(tUIndex& size,float*& values) {
        if (getTypeToString().compare(CORE_Object::getTypeName<float>())==0) {
            size=getSize();
            if (size>0) values=( float*) &mArray[0];
            else values=null;
            size*=getDimension();
            return true;
        }
        return false;
    }
    virtual tBoolean getValues(tUIndex& size,double*& values)  {
        if (getTypeToString().compare(CORE_Object::getTypeName<double>())==0) {
            size=getSize();
            if (size>0) values=( double*) &mArray[0];
            else values=null;
            size*=getDimension();
            return true;
        }
        return false;
    }
    virtual tBoolean getValues(tUIndex& size,long double*& values)  {
        if (getTypeToString().compare(CORE_Object::getTypeName<long double>())==0) {
            size=getSize();
            if (size>0) values=(long double*) &mArray[0];
            else values=null;
            size*=getDimension();
            return true;
        }
        return false;
        
    }
    //OTHERS method
    virtual void add(const tReal& alpha,const EMM_RealField& X);

    virtual void add(const EMM_RealArray& alpha,const EMM_RealField& X);
    virtual void add(const EMM_RealField& f);
   
    
    virtual void add(const tReal& s,
                     const EMM_RealArray& alphas,
                     const tSInt& p,
                     const EMM_RealField& X);
    
    virtual void sub(const EMM_RealField& f);
    virtual void divideBy(const tReal& f);  
    virtual void divideBy(const EMM_RealArray& f);
    virtual void multiplyBy(const tReal& f);
    virtual void multiplyBy(const EMM_RealArray& f);

    
    
    virtual tReal norm(const tUIndex& index) const;
    
    virtual void norm(EMM_RealArray& mod) const;
    
    virtual tReal normMax(tUIndex& k) const;

    virtual tReal distanceMax(const EMM_RealField& B,tUIndex& k) const;
 
    virtual tBoolean cellDataToPointData(const EMM_Grid3D& mesh);
    
    virtual tBoolean pointDataToCellData(const EMM_Grid3D& mesh);
    
    virtual tBoolean loadFromStream(ifstream& f,const tUSInt& d) {
        return mArray.loadFromStream(f,d);
    }
    virtual tBoolean loadFromStream(ifstream& f,vector<EMM_RealArray*>& indics);
    
    virtual tBoolean saveToStream(ofstream& f) const {
        return mArray.saveToStream(f,getDimension());
    }
    virtual tBoolean saveToStream(ofstream& f,const vector<const EMM_RealArray*>& indics) const;
    
    virtual tBoolean saveToVTKStream(ofstream& file,EMM_VTK& vtk,const tString& name) const;
    virtual tBoolean saveToVTKStream(ofstream& file,EMM_VTK& vtk,const EMM_RealArray& weight,const tString& name) const;
    
    virtual tString toString(const tUIndex& n) const;
    
        
    
private:
   
    
  
};

#endif