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 <fiber/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;
 
        int  CoordRank() const override
        {
                return N;
        }
 
        bool getInterpolatedValue(double result[], int nElements, const double coords[], int nCoords) const override
        {
                if (nCoords != N)
                        return false;
 
                return getValue( result, nElements, *static_cast<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()
                {}
 
                int  FieldRank() const  override
                {
                typedef FiberInfo<T> FiberInfo_t;
                        return FiberInfo_t::MULTIPLICITY;
//                      return myMemArray->getFiberType()->multiplicity();
                }
 
                bool getValue(double result[], int nElements, const IpolPoint_t&P) const override
                {
                        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 */