ComputationalField.hpp

#ifndef __FIBER_FIELD_COMPUTATIONAL_FIELD_HPP
#define __FIBER_FIELD_COMPUTATIONAL_FIELD_HPP
 
#include "Field.hpp"
#include "OnDemandCreator.hpp"
 
namespace Fiber
{
 
template <class FieldOperator>
class   ComputationalField : public Field, public FieldOperator //, public FragmentIterator
{
public:
        MemCore::RefPtr<MemCore::Cache> myCache;
 
        ComputationalField(const FieldOperator&FO, const RefPtr<Field>&InputField,
                           const MemCore::RefPtr<MemCore::Cache>&theCache = MemCore::Cache::MemCache() )
        : Field( InputField->getFragmentIDCollection() )
        , FieldOperator(FO)
        , myCache(theCache)
        {
                if (InputField)
                {
                        this->createFieldFragments(*InputField);
                }
        }
 
        ComputationalField(const FieldOperator&FO, const Field&InputField,
                           const MemCore::RefPtr<MemCore::Cache>&theCache = MemCore::Cache::MemCache() )
        : Field( InputField.getFragmentIDCollection() )
        , FieldOperator(FO)
        , myCache(theCache)
        {
                this->createFieldFragments(InputField);
        }
 
        using   primary_value_type = typename FieldOperator::primary_value_type;
        using   result_type        = typename FieldOperator::result_type;
 
        struct  FragmentComputationParameters
        {
                WeakPtr<ComputationalField>     myComputationalField;
                RefPtr<FragmentID>              myFragmentID;
                RefPtr<CreativeArrayBase>       myInputFieldFragment;
 
                FragmentComputationParameters(
                        const WeakPtr<ComputationalField>&theComputationalField,
                        const RefPtr<FragmentID>         &theFragmentID,
                        const RefPtr<CreativeArrayBase>  &theInputFieldFragment)
                : myComputationalField( theComputationalField )
                , myFragmentID ( theFragmentID )
                , myInputFieldFragment( theInputFieldFragment )
                {}
        };
 
 
        template <Dims_t Dims>
        struct  FragmentComputer
        {
                typedef MemArray<Dims, result_type>     ResultArray_t;
                typedef FragmentComputationParameters   Constructor_t;
 
                RefPtr<ResultArray_t>        result_storage;
 
                FragmentComputer(const Constructor_t&Params, const MemBase::Creator_t&C)
                {
                        assert( Params.myComputationalField );
                        assert( Params.myInputFieldFragment );
 
                        // HERE iterate over procedural arrays
                typedef MemArray<Dims, primary_value_type>      PrimaryArray_t;
                        if (RefPtr<PrimaryArray_t> InputData = Params.myInputFieldFragment->create() )
                        {
                        RefPtr<ResultArray_t> OutputData = new ResultArray_t( InputData->Size(), C );
 
                                if (Params.myComputationalField->computeFragment( *OutputData, *InputData, Params.myFragmentID) )
                                {
                                        result_storage = OutputData;
                                }
                        }
                }
 
                RefPtr<ResultArray_t> result() const
                {
                                return result_storage;
                }
        };
 
 
        bool    apply(const RefPtr<FragmentID>&fid, const RefPtr<CreativeArrayBase>&CAB)
        {
                if (!CAB) return true; // or false? stop iteration?
 
                if (fid)
                {
                        if ( getFragmentIDCollection() and getFragmentIDCollection() != fid->getFragmentIDCollection() )
                                Verbose(0) << " ComputationalField::setCreator() - MISMATCH in fragment ID collection! ";
 
                        Assert( getFragmentIDCollection() == fid->getFragmentIDCollection() );
                }
 
 
                if (RefPtr<MemArrayProperties> pMAP = interface_cast<MemArrayProperties>(CAB) )
                {
                const MemArrayProperties&MAP = *pMAP;
                        if (MAP.myElementType() != typeid(primary_value_type) )
                        {
                                // input field does not have appropriate type
                                // thus not even setting up creator
                                return false;
                        }
 
                        if (pMAP->rank==3)
                        {
                                this->setCreator( new OnDemandCreator<FragmentComputer<3> >(
                                                          FragmentComputationParameters(self(), fid, CAB), myCache), fid);
 
                                return true;
                        }
                        else if (pMAP->rank==2)
                        {
                                this->setCreator( new OnDemandCreator<FragmentComputer<2> >(
                                                          FragmentComputationParameters(self(), fid, CAB), myCache), fid);
 
                                return true;
                        }
                        else if (pMAP->rank==1)
                        {
                                this->setCreator( new OnDemandCreator<FragmentComputer<1> >(
                                                          FragmentComputationParameters(self(), fid, CAB), myCache), fid);
 
                                return true;
                        }
                        else
                        {
                                Assert(0 && "Computational Field attempted on field with unsupported mem array rank on its creators");
                                return false;
                        }
                }
 
                Assert(0 && "Computational Field attempted on field without mem array properties on its creators");
                return false;
        }
 
        int     createFieldFragments(const Field&SourceData)
//                                   const MemCore::WeakPtr<FragmentSelector>&FS = NullPtr() )
        {
                Assert( getFragmentIDCollection() == SourceData.getFragmentIDCollection() );
 
                return  SourceData.iterate( [this](const RefPtr<FragmentID>&FragID, const RefPtr<CreativeArrayBase>&CAB)
                {
                        return apply(FragID, CAB);
                }
                );
 
//              return SourceData.iterate(*this, FS);
        }
};
 
 
template <class FieldOperator>
inline ComputationalField<FieldOperator>*newComputationalField(const FieldOperator&FO,
                                                               const RefPtr<Field>&InputField,
                                                               const MemCore::RefPtr<MemCore::Cache>&theCache = MemCore::Cache::MemCache() )
{
        return new ComputationalField<FieldOperator>(FO, InputField, theCache);
}
 
 
template <class FieldOperator>
inline ComputationalField<FieldOperator>*newComputationalField(const FieldOperator&FO,
                                                               const Field&InputField,
                                                               const MemCore::RefPtr<MemCore::Cache>&theCache = MemCore::Cache::MemCache() )
{
        return new ComputationalField<FieldOperator>(FO, InputField, theCache);
}
 
} // namespace Fiber
 
 
#endif // __FIBER_FIELD_COMPUTATIONAL_FIELD_HPP