Edges.hpp

#ifndef __FIBER_GRID_TYPES_EDGES_HPP
#define __FIBER_GRID_TYPES_EDGES_HPP
 
#include "gridtypesDllApi.h"
 
#include <string>
#include <vector>
 
namespace Fiber
{
 
}
 
#include <grid/Grid.hpp>
#include <eagle/PhysicalSpace.hpp>
#include <field/Cell.hpp>
 
 
namespace Fiber
{
 
class   gridtypes_API   Edges
{
public:
        typedef EdgeCell32      EdgeCell_t;
        typedef TriangleCell32  TriangleCell_t;
 
        typedef TypedArray<Eagle::PhysicalSpace::point>         CoordsArray_t;
 
        typedef MemArray<1, Eagle::PhysicalSpace::point>        CoordsMemArray_t;
        typedef MultiArray<1,Eagle::PhysicalSpace::point>       CoordsMultiArray_m_t;
 
        typedef MemArray<1, EdgeCell_t>                         EdgesArray_t;
        typedef MemArray<1, TriangleCell_t>                     TriArray_t;
        typedef MemArray<1, std::vector<index_t> >              IndexSetArray_t;
 
        typedef MemArray<1, Eagle::tvector3>                    TangentialVector_t;
 
        typedef std::vector<index_t>                            EdgesPerVertex_t;
 
        typedef MemArray<1,EdgesPerVertex_t>                    EdgesPerVertexMemArray_t;
 
 
static  SkeletonID EdgeSkeletonID()
        {
                return SkeletonID(1,1);
        }
 
static  SkeletonID ID()
        {
                return EdgeSkeletonID();
        }
 
static  RefPtr<Skeleton>        getEdgeSkeleton(const RefPtr<Grid>&G, bool CreateIfNotFound);
 
static  RefPtr<Representation>  getVerticesPerEdge(const RefPtr<Grid>&G, bool CreateIfNotFound);
 
static  RefPtr<Field>           getVerticesPerEdgeField(const RefPtr<Grid>&G);
 
static  RefPtr<EdgesArray_t>    getVerticesPerEdgeArray(const RefPtr<Grid>&G);
 
static  bool addVerticesPerEdgeField(const RefPtr<Grid>&G, const RefPtr<Field>&theField);
 
static  bool addVerticesPerEdgeArray(const RefPtr<Grid>&G, const RefPtr<EdgesArray_t>&Data);
 
static  bool addVerticesPerEdgeArray(const RefPtr<Grid>&G, const RefPtr<MemCore::TypedChunk<EdgeCell_t>>&EdgeData)
        {
                return addVerticesPerEdgeArray(G, makeMemArray1D(EdgeData) );
        }
 
 
static  RefPtr<Representation>  getEdgesPerVertex(const RefPtr<Grid>&G, bool CreateIfNotFound);
 
static  RefPtr<Field>   getEdgesPerVertexField(const RefPtr<Grid>&G, bool CreateIfNotFound);
static  RefPtr<EdgesArray_t> getEdgesPerVertexArray(const RefPtr<Grid>&G);
 
static  bool    addEdgesPerVertex(const RefPtr<Grid>&G, const RefPtr<Field>&theField);
 
        RefPtr<Skeleton>        EdgeSkeleton;
        RefPtr<Representation>  VerticesPerEdge;
        RefPtr<Field>           VerticesPerEdgeField;
        RefPtr<EdgesArray_t>    VerticesPerEdgeArray;
 
 
static RefPtr<EdgesPerVertexMemArray_t >
        createEdgesPerVertex(const RefPtr<Grid>&G, bool storeThem);
 
 
        Edges(const RefPtr<Grid>&G);
 
        ~Edges();
};
 
 
} // namespace Fiber
 
 
#endif // __FIBER_GRID_TYPES_EDGES_HPP