CurveOperators.hpp

#ifndef __FIBER_GRID_TYPES_CURVEOPERATORS_HPP
#define __FIBER_GRID_TYPES_CURVEOPERATORS_HPP

#include "LineSet.hpp"
#include <field/OnDemandCreator.hpp>



namespace Fiber
{
        namespace Curve
        {


                struct CurveOperatorData
                {
                        WeakPtr<Grid>             theGrid;
                        const RefPtr<FragmentID>& fragV;
                        
                        CurveOperatorData(WeakPtr<Grid> theGridP, const RefPtr<FragmentID>& fragVP )
                        : theGrid( theGridP )
                        , fragV( fragVP )
                                {}
                };

struct gridtypes_API ArcLength 
{
        typedef MemArray<1, double>     ResultArray_t; 
//      typedef WeakPtr<Grid>           Constructor_t; 
        typedef CurveOperatorData       Constructor_t;

        RefPtr<MemArray<1, double> > Data; 

//      ArcLength(const LineSet&LS, double InitialMaxArcLen = 0.0, const MemBase::Creator_t&C = MemCore::NullPtr() ) 
        ArcLength(const CurveOperatorData& CurveData, const MemBase::Creator_t&C = MemCore::NullPtr() ) 
        {
#ifdef VERBOSE
                puts("ArcLength::ArcLength() >>>>>>>> Computing Arclength, NOW !!!!");
#endif
        const LineSet& LS = CurveData.theGrid;

                if (!LS)
                        return; 

                if (!LS.getCoords( CurveData.fragV  ) ) 
                {
                        puts("ArcLength::ArcLength() Arclength, has no coords found !!!!");
                        return; 
                }
                Data = new ResultArray_t( LS.getCoords( CurveData.fragV )->nElements(), C); 

                LS.ApplyOnVertexFragment( *this, CurveData.fragV  ); // vertexiterator
        } 

        ~ArcLength();

        RefPtr<ResultArray_t> result() const 
        { 
                return Data;
        }

        void    apply(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                      const std::vector<LineSet::LineIndex_t>&Line);

};


struct gridtypes_API StepSize
{
        typedef MemArray<1, double>     ResultArray_t;
        typedef CurveOperatorData       Constructor_t;

        RefPtr<MemArray<1, double> > Data;

        StepSize(const CurveOperatorData& CurveData, const MemBase::Creator_t&C = MemCore::NullPtr() )
        {
        const LineSet& LS = CurveData.theGrid;

                if (!LS)
                        return;

                if (!LS.getCoords( CurveData.fragV ) )
                        return; 

                Data = new ResultArray_t( LS.getCoords( CurveData.fragV )->nElements(), C); 

                LS.ApplyOnVertexFragment( *this, CurveData.fragV );
        } 

        ~StepSize();

        RefPtr<ResultArray_t> result() const 
        { 
                return Data;
        }

        void    apply(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                      const std::vector<LineSet::LineIndex_t>&Line);

};



struct gridtypes_API Velocity
{
        RefPtr<MemArray<1, Eagle::PhysicalSpace::tvector> >     VelocityData; 

//      typedef WeakPtr<Grid>           Constructor_t; 
        typedef CurveOperatorData       Constructor_t; 

        Velocity( const CurveOperatorData& CD );

        ~Velocity();
};



template <class FieldType> 
struct gridtypes_API CurveQuantity : Velocity
{
        typedef CurveQuantity CurveQuantity_t;

        typedef MemArray<1, FieldType>  ResultArray_t; 
//      typedef WeakPtr<Grid>           Constructor_t; 
        typedef CurveOperatorData       Constructor_t;

        RefPtr<ResultArray_t>           Data;

        CurveQuantity(const CurveOperatorData&CD, const MemBase::Creator_t&C = MemCore::NullPtr() )
                : Velocity( CD )
        {
        const LineSet& LS = CD.theGrid;

                if (!LS)
                        return;

                if (!LS.getCoords( CD.fragV ) )
                        return; 

                if (!VelocityData)
                        return;

                Data = new ResultArray_t( LS.getCoords( CD.fragV )->nElements(), C);
        }

        RefPtr<ResultArray_t> result() const 
        {
                return Data;
        } 

//      void    apply(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices, 
//                    const std::vector<LineSet::LineIndex_t>&Line);

};








struct gridtypes_API Energy : CurveQuantity<double>
{
        Energy(const CurveOperatorData&CD, const MemBase::Creator_t&Crec = NullPtr() )
                : CurveQuantity_t(CD, Crec)
        {
        const LineSet& LS = CD.theGrid; 

                if (!LS)
                        return;

                if (!Data)
                        return; 

                LS.ApplyOnVertexFragment( *this, CD.fragV );
        }

        ~Energy();


        void    apply(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                      const LineSet::LineIndices_t&Line);
};



struct gridtypes_API ProperTime : CurveQuantity<double>
{
        ProperTime(const CurveOperatorData&CD, const MemBase::Creator_t&C = MemCore::NullPtr() )
                : CurveQuantity_t(CD, C)
        {
        const LineSet& LS = CD.theGrid; 

                if (!LS)
                        return;

                if (!Data)
                        return; 

                LS.ApplyOnVertexFragment( *this, CD.fragV );
        } 

        ~ProperTime();

        void    apply(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                      const std::vector<LineSet::LineIndex_t>&Line);

};



struct gridtypes_API Acceleration : CurveQuantity<Eagle::PhysicalSpace::tvector>
{

        Acceleration(const CurveOperatorData&CD, const MemBase::Creator_t&C = MemCore::NullPtr() )
                : CurveQuantity_t(CD, C)
        {
        const LineSet& LS = CD.theGrid; 

                if (!LS)
                        return;

                if (!Data)
                        return; 

                LS.ApplyOnVertexFragment( *this, CD.fragV );
        } 

        ~Acceleration();

        void    apply(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                      const std::vector<LineSet::LineIndex_t>&Line);

};


struct gridtypes_API Curvature : CurveQuantity<double>
{
        Curvature(const CurveOperatorData&CD, const MemBase::Creator_t&C = MemCore::NullPtr() )
                : CurveQuantity_t(CD, C)
        {
        const LineSet& LS = CD.theGrid; 

                if (!LS)
                        return;

                if (!Data)
                        return; 

                LS.ApplyOnVertexFragment( *this, CD.fragV );
        } 

        ~Curvature();


        void    apply(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                      const std::vector<LineSet::LineIndex_t>&Line);

};


struct gridtypes_API    Torsion : CurveQuantity<double>
{
        Torsion(const CurveOperatorData&CD, const MemBase::Creator_t&C = MemCore::NullPtr() )
                : CurveQuantity_t(CD, C)
        {
        const LineSet& LS = CD.theGrid; 

                if(!LS)
                        return;

                if (!Data)
                        return;

                LS.ApplyOnVertexFragment( *this );
        } 

        ~Torsion();

        void    apply(const CreativeIterator<Eagle::PhysicalSpace::point>&Vertices,
                      const std::vector<LineSet::LineIndex_t>&Line);

};


        } // Curve

} // Fiber

#endif // __FIBER_GRID_TYPES_CURVEOPERATORS_HPP