CurveOperators.hpp

#ifndef __FIBER_GRID_TYPES_CURVEOPERATORS_HPP
#define __FIBER_GRID_TYPES_CURVEOPERATORS_HPP
 
#define USE_DEPRECATED_LINESET_FUNCTIONS
 
#include "LineSet.hpp"
#include <field/OnDemandCreator.hpp>
 
 
namespace Fiber
{
        namespace Curve
        {
 
 
                struct CurveOperatorData
                {
                        WeakPtr<Grid>            theGrid;
                        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 (! CD.fragV ) {}
 
                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