ContinuousFieldLevel.hpp

//
// $Id: ContinuousFieldLevel.hpp,v 1.1 2008/01/14 19:20:43 werner Exp $
//
#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 */