ArrayInterpolator.hpp

//
// $Id: ArrayInterpolator.hpp,v 1.1 2007/08/28 22:54:18 werner Exp $
//
#ifndef __FIBER_ARRAYINTERPOLATOR_HPP
#define __FIBER_ARRAYINTERPOLATOR_HPP

#include "FieldAPI.h"
#include <memcore/RefPtr.hpp>
#include <memcore/Interface.hpp>

#include <vector/MultiArray.hpp>

#include <typeinfo>

namespace Fiber
{
        using std::type_info;

        using MemCore::RefPtr;
        using MemCore::ReferenceBase;

class FIELD_API ArrayInterpolator : public MemCore::Interface<ArrayInterpolator>
{
public:
        virtual ~ArrayInterpolator();

        virtual int  CoordRank() const = 0;

        virtual int  FieldRank() const = 0;

        virtual bool getInterpolatedValue(double result[], int nElements, const double coords[], int nCoords) const = 0;
};

template <int N>
class FIELD_API DimensionalInterpolator : public ArrayInterpolator
{
public:
        typedef FixedArray<double, N> IpolPoint_t;

        virtual bool getValue(double result[], int nElements, const IpolPoint_t&P) const = 0; 
        
        override int  CoordRank() const
        {
                return N;
        }

        override bool getInterpolatedValue(double result[], int nElements, const double coords[], int nCoords) const 
        {
                if (nCoords != N) 
                        return false; 

                return getValue( result, nElements, *(IpolPoint_t*)coords );
        }
};

#if 0
template <int N, class T>
        class CubicInterpolator : public DimensionalInterpolator
        {
        public:
                MemCore::WeakPtr<MemArray> myMemArray;

                typedef Interpolate<N, T, CubicIpol<T>, double> CubicIpol_t;

                StorageInterpolator(const MemCore::WeakPtr<MemArrayStorage>&MA)
                : myMemArray(MA)
                {}

                ~StorageInterpolator()
                {}

                override int  FieldRank() const 
                {
                typedef FiberInfo<T> FiberInfo_t; 
                        return FiberInfo_t::MULTIPLICITY;
//                      return myMemArray->getFiberType()->multiplicity();
                }

                override bool getValue(double result[], int nElements, const IpolPoint_t&P) const
                {
                        if (!myMemArray) 
                                return false;

                CubicIpol_t ccip(myMemArray->myMultiArray, P); 
                const T&t = ccip.eval(); 
                int     i = 0; 
                typedef FiberInfo<T> FiberInfo_t; 

                        for(; i<FiberInfo_t::MULTIPLICITY; i++)
                        {
                                result[i] = FiberInfo_t::getComponent(t, i);
                        }
                        return true;
                }
        };
#endif


} /* namespace Fiber */ 

#endif /*  __FIBER_ARRAYINTERPOLATOR_HPP */