GridEvaluator.hpp

#ifndef __FIBER_BASEOPERATIONS_GRIDEVALUATOR_HPP
#define __FIBER_BASEOPERATIONS_GRIDEVALUATOR_HPP
 
#include <field/Field.hpp>
 
#include <grid/Grid.hpp>
#include <bundle/Slice.hpp>
 
#include "gridopDllApi.h"
 
namespace Fiber
{
 
struct  gridop_API GridEvaluator
{
        RefPtr<MemBase> FragmentIDs;
 
        enum    FragmentSearchResult
        {
                Nope,                           
                Possibly,                       
                Certainly,                      
                YesWithLocationAlreadyFound     
        };
 
        RefPtr<MemBase> SearchStatus;
 
        RefPtr<MemBase> PointLocation; 
 
 
        struct  Context
        {
                Slice           &mySlice;
                RefPtr<Grid>    mySourceGrid;
                string          Gridname;
                double          Res_scale;
                double          Prec_scale;
 
                Context(Slice&theSlice)
                : mySlice(theSlice)
                , Res_scale( 1.0 )
                , Prec_scale( 0.1 )
                {}
        };
 
 
        GridEvaluator();
        ~GridEvaluator(); 
 
        bool    find(const RefPtr<MemBase>&DestinationCoords, const Field&SourcePositions, 
                     GridEvaluator::Context&theEvaluationContext); 
 
        GridEvaluator(const RefPtr<MemBase>&DestinationCoords, const Field&SourcePositions, 
                      GridEvaluator::Context&theEvaluationContext)
        {
                find(DestinationCoords, SourcePositions, theEvaluationContext);
        }
 
 
template <class PositionsFieldType>
        void    findForSpecificDestinationPositions(const PositionsFieldType&DestinationPositions, 
                                                    const Field&SourcePositions, 
                                                    GridEvaluator::Context&theEvaluationContext);
 
 
        template <int SourceDims, class ValueType>
        bool    evalFloatIndices(std::vector<ValueType>&ResultData,
                                 const CreativeIterator< FixedArray<double, SourceDims> >&InterpolationWeightsPerDestPoint,
                                 const Field&SourceField) const;
 
 
        template <class ValueType>
        bool    evalType(std::vector<ValueType>&ResultData, const Field&SourceField) const;
 
 
        template <int DestDims, class ValueType>
        RefPtr<MemBase> evalDimensionalDestType(const MultiIndex<DestDims>&DestSize, const Field&SourceField) const
        {
        MemCore::Ref<MemArray<DestDims, ValueType> > DestinationValues( DestSize );
 
                assert( DestinationValues );
                assert( DestinationValues->myChunk() );
 
        std::vector<ValueType>&ResultData = DestinationValues->myChunk()->get_vector(); 
 
        bool    ok = evalType(ResultData, SourceField);
                if (ok)
                        return DestinationValues; 
 
                return NullPtr();
        }
 
 
        template <class ValueType>
        RefPtr<MemBase> evalFromCompatibleData(const RefPtr<MemBase>&DestinationCompatibleData,
                                               const Field&SourceField) const
        {
                if (RefPtr<MemArrayBase<3> > DataIs3D = DestinationCompatibleData)
                {
                        return evalDimensionalDestType<3, ValueType>(DataIs3D->Size(), SourceField);
                }
                if (RefPtr<MemArrayBase<2> > DataIs2D = DestinationCompatibleData)
                {
                        return evalDimensionalDestType<2, ValueType>(DataIs2D->Size(), SourceField);
                }
                if (RefPtr<MemArrayBase<1> > DataIs1D = DestinationCompatibleData)
                {
                        return evalDimensionalDestType<1, ValueType>(DataIs1D->Size(), SourceField);
                }
                return NullPtr();
        }
 
        RefPtr<MemBase> evalKnownDataTypes(const RefPtr<MemBase>&DestinationCompatibleData,
                                           const Field&SourceField) const;
 
};
 
 
} // namespace Fiber
 
 
#endif // __FIBER_BASEOPERATIONS_GRIDEVALUATOR_HPP