UniGridMapper.hpp

#ifndef __UNIGRIDMAPPER_HPP
#define __UNIGRIDMAPPER_HPP

#include <aerie/BoundingBox.hpp>
#include <eagle/PhysicalSpace.hpp>
#include <eagle/QuadraticMatrix.hpp> 

#include <field/UniformCartesianArray.hpp>

#include <fish/fiber/vector/Interpolate.hpp>
#include <fish/fiber/vector/LinearIpol.hpp>

#include <memcore/RefPtr.hpp>

using namespace Fiber;
using namespace Eagle;
using namespace std;

using namespace Eagle::PhysicalSpace;


class UniGridMapper : public ReferenceBase<UniGridMapper>
{
        typedef MemArray<3, point> CoordsArray_t;
        typedef MemArray<3, tvector> TVectorArray_t;
        typedef std::list<MultiIndex<3> > IndexList_t; 
        typedef MemArray<3, IndexList_t > IndexListArray_t;

//      typedef LinearDirectProductMemArray<Eagle::point3>   ProcArray_t; 

        RefPtr<IndexListArray_t>        CurviIndexList;
        RefPtr<UniformCartesianArray>   UniGridCoords;
        RefPtr<CoordsArray_t>           CurviCoords;

        RefPtr<BoundingBox>        BBox;

        double                  prec;
        tvector                 cell_len;
        MultiIndex<3>           res, ix, iy, iz;

        int     MaxListSize;

        // used for the correction of 'bad' points by EpsilonPreventer
        struct DistPoint_t
        {
                double dist;
                point uvw;
                MultiIndex<3> self;
        };

public:
        UniGridMapper(const RefPtr<CoordsArray_t>&_CurviCoords, const double res_scale = 1.0, const double prec_scale = 1.0);

        int     MaximalCurvicellPerUnicell() const
        {
                return MaxListSize;
        }


static  inline double avg(const double a, const double b)
        {
                return (a+b)/2;
        }
        
static  inline void clampRange(point&p, const double min, const double max)
        {
                for(unsigned i = 0; i < 3; i++)
                {
                        p[i] = ( p[i] < min) ? min : p[i]; 
                        p[i] = ( p[i] > max) ? max : p[i]; 
                }
        } 
                
static  inline bool uvwInRange2( point& u, const MultiIndex<3>&it, const MultiIndex<3>&max, const double prec) 
        {
                if( u[0] >= it[0] && u[0] <= it[0]+1 &&
                    u[1] >= it[1] && u[1] <= it[1]+1 && 
                    u[2] >= it[2] && u[2] <= it[2]+1    )
                {
                        return true;
                }
                else
                {
                        return false;
                }
        } 
        
static  inline bool localPointToIndex(const point&p, MultiIndex<3>&cc)
        {
                if(p[0] >= 0.0 && p[1] >= 0.0 && p[2] >= 0.0)
                {
                        cc[0] = unsigned(floor(p[0])); 
                        cc[1] = unsigned(floor(p[1])); 
                        cc[2] = unsigned(floor(p[2])); 
                        return true;
                } 
                return false;
        }
        

        MultiIndex<3>  Size() const                            { return CurviIndexList->Size();}
        
        point          operator[](const MultiIndex<3>&m) const { return (*UniGridCoords)[m];   }
        
        IndexList_t&   operator()(const MultiIndex<3>&m) const { return (*CurviIndexList)[m];   }
        RefPtr<CoordsArray_t> getCurviCoords() const           { return  CurviCoords;           }
        RefPtr<UniformCartesianArray> getUniCoords() const      { return  UniGridCoords;        }
        
        point          getMin()                                { return BBox->mincoord();      }
        
        point          getMax()                                { return BBox->maxcoord();      }
        
        
        bool     add( MultiIndex<3>& curvi_i );
        
        bool     inUniCell(const point&p, MultiIndex<3>&index );
        
        bool     curviCells(const point&p, IndexList_t&list);
        
        unsigned localCellCoordinatesFromCurviGrid(const point&p, point&uvw, double grid_epsilon = 0.0);
                
        bool     localCellCoordinatesFromCell(point&uvw, const point&P, MultiIndex<3>&it,const CoordsArray_t&Data, const MultiIndex<3>&max,const double prec);
}; 



#endif // __UNIGRIDMAPPER_HPP