FieldInterpolator.hpp

#ifndef _FieldInterpolator_HPP
#define _FieldInterpolator_HPP

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

namespace Fiber
{

class FieldInterpolatorBase
{
protected:
        RefPtr<Field> TheField;

public:
        // supported interpolation types, used as template parameter in the FielInterpolator class
        enum InterpolType{LINEAR, CUBIC, ANALYTIC};

        FieldInterpolatorBase( RefPtr<Field>& TheFieldP )
        :TheField(TheFieldP)
        {}

        // convinience function
        RefPtr< MemBase > getArray( const pair<Eagle::PhysicalSpace::point, string>& localPoint, const double time )
        {
        const string&FragName = localPoint.second; 
                //const Eagle::PhysicalSpace::point &float_index = localPoint.first; 

        RefPtr<FragmentID> FragID; 

                if(FragName.compare("") != 0 )
                        FragID = new FragmentID( FragName ); 
                
                return TheField->getCreator( FragID )->create();
        }
};

template<typename FieldType,  typename CoordType, int InterpolType>
class FieldInterpolator : public FieldInterpolatorBase
{
public:
        FieldInterpolator( RefPtr<Field>& TheFieldP )
        :FieldInterpolatorBase(TheFieldP)
        {}

        FieldType doIt( const pair<Eagle::PhysicalSpace::point, string>& localPoint, const CoordType& worldlocation, const double time )
        {
                puts("template<FieldType>::Interpolator::doIt() no valid Interpolation type specialization"); 

        FieldType data; 
                return data;
        }  
};

template<typename FieldType, typename CoordType>
class FieldInterpolator<FieldType, CoordType, FieldInterpolatorBase::LINEAR> : public FieldInterpolatorBase
{
        typedef Interpolate<CoordType::Dims, FieldType, LinearIpol< FieldType> > LinearInterpolator_t;
public:
        FieldInterpolator( RefPtr<Field>& TheFieldP )
        :FieldInterpolatorBase(TheFieldP) {}

        FieldType doIt( const pair<Eagle::PhysicalSpace::point, string>& localPoint, const CoordType& worldlocation, const double time )
        {
        RefPtr<MemArray<CoordType::Dims, FieldType> > ToIntArr = getArray(localPoint, time); 
        assert( ToIntArr );

        FieldType data; 
        LinearInterpolator_t MyInterpolator(*ToIntArr, localPoint.first); 

                data = MyInterpolator.eval(); 

                return data;
        }
};


template<typename FieldType, typename CoordType>
class FieldInterpolator<FieldType, CoordType, FieldInterpolatorBase::CUBIC> : public FieldInterpolatorBase
{
        typedef Interpolate<CoordType::Dims, FieldType, CubicIpol< FieldType> > CubicInterpolator_t;
public:
        FieldInterpolator( RefPtr<Field>& TheFieldP )
        :FieldInterpolatorBase(TheFieldP) {}

        FieldType doIt( const pair<Eagle::PhysicalSpace::point, string>& localPoint, const CoordType& worldlocation, const double time )
        {
        RefPtr<MemArray<CoordType::Dims, FieldType> > ToIntArr =getArray(localPoint, time); 
        assert( ToIntArr ); 

        FieldType data; 

        CubicInterpolator_t MyInterpolator(*ToIntArr, localPoint.first); 
                data = MyInterpolator.eval(); 

                return data;
        }       
};

template<typename FieldType, typename CoordType>
class FieldInterpolator<FieldType, CoordType, FieldInterpolatorBase::ANALYTIC> : public FieldInterpolatorBase
{
typedef Eagle::PhysicalSpace::AnalyticFunction<FieldType> Eqn_t;

public:
        FieldInterpolator( RefPtr<Field>& TheFieldP )
        :FieldInterpolatorBase(TheFieldP) {}

        FieldType doIt( const pair<Eagle::PhysicalSpace::point, string>& localPoint, const CoordType& worldlocation, const double time )
        {
        FieldType data; 

                if ( MemCore::InterfacePtr<Eqn_t> AnalyticField = *TheField )
                {
                Eqn_t&AF = *AnalyticField; 
                        data = AF(time, worldlocation);
                } 
                else
                {
                        puts("Interpolator<FieldType, Dims, InterpolatorBase::ANALYTIC>::doIt() ERROR: No analytic equation!");
                } 

                return data;
        }
};

} // namespace Fiber

#endif //_FieldInterpolator_HPP