AnalyticCreator.hpp

#ifndef __ANALYTIC_CREATOR_HPP
#define __ANALYTIC_CREATOR_HPP
 
#include <grid/CartesianChart.hpp>
#include <field/DirectProductArray.hpp>
 
#include <field/AsynchronCreator.hpp>
#include <bone/FishField.hpp>
 
#include <eagle/PhysicalSpace.hpp>
#include <bundle/FieldSelector.hpp>
 
using namespace MemCore;
using namespace Fiber;
 
template <class Formula>
struct  AnalyticCreator : 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()
        {}
 
#if     0
        bool    hasData() const override
        {
                if (result)
                        return true;
 
                return false;
        }
#endif
 
        const type_info&getType()
        {
                return typeid(value_type);
        }
 
        RefPtr<Fiber::MemBase> compute(const std::atomic<bool>&Stop) const
        {
                assert( myCoords );
        RefPtr<ProcArray_t> Coords = myCoords->create();
                assert(Coords);
        ProcArray_t&P = *Coords;
 
        RefPtr<Array_t> A = new Array_t( Coords->Size(), self() );
//              A->setCreator( self() );
                A->CacheInfoString = "AnalyticCreator for T=" +String( time );
 
        Array_t&MyField = *A;
 
        Wizt::VActionNotifier::Progress vProgress("Computing Analytic field...",1);
                for(MultiIndex<FieldDims> M : Coords->Size() )
                {
                const Eagle::point3&Pt = P[ M ];
 
                        Formula::eval( MyField[M], Pt, time, Params);
                }
 
                return A;
        }
 
        AnalyticCreator(double t, const RefPtr<CreativeArrayBase>&Coords, const Param_t&P)
        : AsynchronCreator( [this](const std::atomic<bool>&Stop)
                            {
                                    return this->compute(Stop);
                            }
                          )
        , time(t)
        , Params(P)
        , myCoords(Coords)
        {
                Assert( myCoords );
 
                addInterface( new MemArrayProperties(FieldDims, FiberType<value_type>::getFiberType() ) );
        }
 
 
static  void    setFieldType(Fiber::FieldSelector&FS)
        {
                FS.accept<value_type>();
        }
 
 
static  bool    set(double time, const Param_t&P,
                    Grid&G, const string&fieldname)
        {
                Assert( G.CartesianPositions() );               // need coordinates!
                Assert( G.CartesianPositions()->getCreator() ); // need coordinates!
                if (!G.CartesianPositions())               return false;
                if (!G.CartesianPositions()->getCreator()) return false;
 
        RefPtr<Field> myField = G[ fieldname ];
//              if (!myField)
//                      myField = new Field(); //ugh! Need to get FragmentCollection from grid here
 
        RefPtr<AnalyticCreator> AC = myField->getCreator();
                if (AC)
                {
                        if (AC->Params == P)
                        {
                                if (AC->isUnderCreation() )
                                        return false;
 
                                return true;
                        }
                }
 
                {
                Ref<AnalyticCreator> theAC(time, G.CartesianPositions()->getCreator(), P);
                        myField->setCreator( theAC );
                }
                return true;
        }
 
};
 
#endif