EMM_DistanceFunction.h

Go to the documentation of this file.

#ifndef EMM_DistanceFunction_H
#define EMM_DistanceFunction_H

#include "MATH_IntegrandFunction.h"


DEFINE_SPTR(EMM_DistanceFunction);

class EMM_DistanceFunction: public MATH_IntegrandFunction {
    
  
    SP_OBJECT(EMM_DistanceFunction);
  
    // ATTRIBUTES
  
private:

  
    //distance
    tReal *mH;
    tIndex *mDistance;
    tBoolean mIsPrivateDistanceAllocated;
    tBoolean mIsPrivateHAllocated;
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
    
    EMM_DistanceFunction(void) {

        mDistance=null;
        mIsPrivateDistanceAllocated=false;
        
        mH=null;
        mIsPrivateHAllocated=false;
    }
   
    
    
    // DESTRUCTORS 
    
    
    virtual ~EMM_DistanceFunction(void) {
        desallocateDistance();
        desallocateMeshSize();
    }
    
   
private:

    // CONSTRUCTORS

private:
    void allocateDistance() {
        if (!mIsPrivateDistanceAllocated) {
            //the distance is by reference
            //dereference it and create a new array of size 4
            //allocate the new distnace
            mDistance=new tIndex[3];
            mIsPrivateDistanceAllocated=true;
        }
    }
    void desallocateDistance() {
        if (mIsPrivateDistanceAllocated) {
            delete[] mDistance;
        }
        mDistance=null;
        mIsPrivateDistanceAllocated=false;
    }
    void allocateMeshSize() {
        if (!mIsPrivateHAllocated) {
            //the distance is by reference
            //dereference it and create a new array of size 4
            //allocate the new distnace
            mH=new tReal[3];
            mIsPrivateHAllocated=true;
        }
    }
    void desallocateMeshSize() {
        if (mIsPrivateHAllocated) {
            delete[] mH;
        }
        mH=null;
        mIsPrivateHAllocated=false;
    }
  
public:
   
    
    inline void setDistance(const tIndex d[]) {
        setDistance(d[0],d[1],d[2]);
    }
    virtual void setDistance(const tIndex& dx,const tIndex& dy,const tIndex& dz) {
        allocateDistance();
        mDistance[0]=dx;
        mDistance[1]=dy;
        mDistance[2]=dz;
    }
    
    inline void setDistanceByReference(tIndex d[]) {
        desallocateDistance();
        mDistance=d;
        mIsPrivateDistanceAllocated=false;
    }
    
    
    inline const tIndex* getDistance() const {
        return mDistance;
    }
    inline  tIndex* getDistance()  {
        return mDistance;
    }
    inline void setMeshSize(const tReal h[]) {
        setMeshSize(h[0],h[1],h[2]);
    }
    virtual void setMeshSize(const tReal& hx,const tReal& hy,const tReal& hz) {
        allocateMeshSize();
        mH[0]=hx;
        mH[1]=hy;
        mH[2]=hz;
    }
    
    inline void setMeshSizeByReference(tReal h[]) {
        desallocateMeshSize();
        mH=h;
        mIsPrivateHAllocated=false;
    }
 
  
    
    inline void getMeshSize(tReal& hx,tReal& hy,tReal& hz) const {
        hx=mH[0];
        hy=mH[1];
        hz=mH[2];
    }
    inline const tReal* getMeshSize() const {
        return mH;
    }
    
    

};

#endif