AnalyticCreator.hpp

#ifndef __ANALYTIC_CREATOR_HPP
#define __ANALYTIC_CREATOR_HPP

#include <grid/CartesianChart.hpp>
#include <field/DirectProductArray.hpp>
#include <bone/AsynchronCreator.hpp>
#include <bone/FishField.hpp>

#include <ocean/eagle/PhysicalSpace.hpp>
#include <bundle/FieldSelector.hpp>

using namespace MemCore;
using namespace Fiber;


template <class Formula>
struct  AnalyticCreator : Wizt::AsynchronCreator
{
        typedef typename Formula::value_type    value_type;
        enum { FieldDims = Formula::Dims };
        typedef typename Formula::point_type    point_type;

        typedef typename Formula::Parameters    Param_t;

        typedef Fiber::MemArray<FieldDims,  value_type> Array_t; 

        typedef Fiber::DirectProductMemArray<point_type>        ProcArray_t;


        double                          time;
        Param_t                         Params;

        RefPtr<Array_t>                 myArray;
        RefPtr<CreativeArrayBase>       myCoords;

        AnalyticCreator(double t, const RefPtr<CreativeArrayBase>&Coords, Wizt::VCotask*CoTask,
                        const Param_t&P)
        : AsynchronCreator(CoTask)
        , time(t)
        , Params(P)
        , myCoords(Coords)
        {
                assert( myCoords );

                addInterface( new MemArrayProperties(FieldDims, FiberType<value_type>::getFiberType() ) );
        }

        ~AnalyticCreator()
        {}

        override bool release()
        {
                myArray = NullPtr(); 
                return true;
        }

        override bool hasData() const
        {
                if (myArray)
                        return true;

                return false;
        }

        const type_info&getType()
        {
                return typeid(value_type);
        }

        override RefPtr<Fiber::MemBase> compute()
        {
                assert( myCoords );
        RefPtr<ProcArray_t> Coords = myCoords->create();
                assert(Coords);
        ProcArray_t&P = *Coords;

        RefPtr<Array_t> A = new Array_t( Coords->Size() );
        Array_t&MyField = *A; 

                Wizt::VActionNotifier::BusyInfo("Computing Analytic field..."); 
        MultiIndex<FieldDims> M = MIndex(0,0,0);
                do
                {
                const Eagle::point3&Pt = P[ M ]; 

                        Formula::eval( MyField[M], Pt, time, Params);
                }
                while( M.inc( Coords->Size() ) ); 

                return A;
        }

static  void    setFieldType(Fiber::FieldSelector&FS)
        {
                FS.accept<value_type>();
        }


static  bool    set(Wizt::VCotask*where,
                    double time, const Param_t&P, 
                    Grid&G, const string&fieldname)
        {
        RefPtr<Field>&myField = G[ fieldname ];
                if (!myField)
                        myField = new Field(); 

        RefPtr<AnalyticCreator<Formula> > AC = myField->getCreator(); 
                if (AC)
                {
                        if (AC->Params == P)
                        {
                                if (AC->isRunning() )
                                        return false;
                                return true;
                        }
                } 
                myField->setCreator( new AnalyticCreator<Formula>(time, G.CartesianPositions()->getCreator(), where, P ) );
                if (AC)
                {
                        if (AC->isRunning() )
                                return false;
                }
                return true;
        }
};

#endif