ContinuousFieldLevel.hpp

#if     0
 
#ifndef __GRIDOP_CONTINUOUSFIELDLEVEL_HPP
#define __GRIDOP_CONTINUOUSFIELDLEVEL_HPP
 
#include "gridopDllApi.h"
 
#include <field/MemArray.hpp>
#include <field/DirectProductArray.hpp>
 
#include <vector/CubicIpol.hpp>
#include <vector/LinearIpol.hpp>
#include <vector/Interpolate.hpp>
 
#include <ocean/eagle/PhysicalSpace.hpp>
 
namespace Fiber
{
 
template <int Dims, typename real=double>
struct  ContinuousFieldLevel
{
        enum { N = Dims };
 
        typedef FixedArray<real, N>                     Point_t;
        typedef DirectProductMemArray<Eagle::point3>    ProcArray_t; 
 
        typedef std::pair<Point_t, ContinuousFieldLevel*> Location_t;
 
        RefPtr<LinearArray<double> > Coordinates[N];
 
        ContinuousFieldLevel*Neighbours[N][2];
 
        ContinuousFieldLevel(const ProcArray_t&Crds)
        {
                for(int k=0; k<N; k++)
                {
                        Coordinates[k] = Crds.Components[k]; 
                        if (!Coordinates[k] )
                                throw "ContinuousFieldLevel(): Nonlinear coordinates found, not good.";
                }
        }
 
        Location_t locate(const Point_t&P)
        {
        Point_t point;
 
                // Compute 
                for(int k=0; k<N; k++)
                {
                        point[k] = (Coordinates[k])->reverse( P[k] ); 
 
                        if (point[k] < 0.0)
                        {
                                if (!Neighbours[k][0])
                                        throw P; 
 
                                return Neighbours[k][0]->locate(P);
                        }
 
                        if (point[k] > Coordinates[k]->Length() )
                        {
                                if (!Neighbours[k][1])
                                        throw P; 
 
                                return Neighbours[k][1]->locate(P);
                        }
 
                } 
 
                return Location_t(point, this);
        }
 
/*
                {
        const MultiArray_t&M;
 
        Interpolate_t Ipol(M, point); 
 
                return Ipol.eval();
        }
*/
};
 
template <int Dims, typename real=double>
struct  ContinuousField
{
        typedef ContinuousFieldLevel<Dims, real> ContinuousFieldLevel_t;
 
        typedef typename ContinuousFieldLevel_t::Location_t     Location_t;
        typedef typename ContinuousFieldLevel_t::Point_t        Point_t;
 
        typedef set< ContinuousFieldLevel_t*>   FragmentsPerLevel_t;
 
        typedef map<int, FragmentsPerLevel_t>   AllLevels_t;
 
        AllLevels_t AllLevels;
 
        Location_t locate(const Point_t&P, ContinuousFieldLevel_t*hint)
        {
                
        }
};
 
 
} /* namespace Fiber */ 
 
#endif /* __GRIDOP_CONTINUOUSFIELDLEVEL_HPP */
 
#endif