CellCluster.hpp

#ifndef __FIBER_GRID_TYPES_CELLCLUSTER_HPP
#define __FIBER_GRID_TYPES_CELLCLUSTER_HPP
 
#include "gridtypesDllApi.h"
#include <grid/Grid.hpp>
#include <eagle/PhysicalSpace.hpp>
 
//#define VERBOSE
 
namespace Fiber
{
 
template <int CellDims, int ClusterDepth = 2>
class   CellCluster
{
public:
        typedef TypedArray<Eagle::PhysicalSpace::point>  CoordsArray_t;
        typedef MemArray<1, Eagle::PhysicalSpace::point> CoordsMemArray_t; 
 
        typedef uint32_t CellIndex_t; 
 
        typedef std::vector<CellIndex_t> CellIndices_t;
 
        typedef MemArray<1, CellIndices_t>      CellClusterArray_t;
 
 
static  SkeletonID ClusterSkeletonID()
        {
                return SkeletonID(CellDims, ClusterDepth);
        }
 
static  SkeletonID CellSkeletonID()
        {
                return SkeletonID(CellDims, ClusterDepth-1);
        }
 
static  SkeletonID ID()
        {
                return ClusterSkeletonID();
        } 
 
        RefPtr<Skeleton>        Vertices,
                                Cells,
                                Clusters;
 
        RefPtr<Representation>  CartesianVertices,
                                ClustersAsCartesianVertices,
                                ClustersAsCells;
 
        RefPtr<Field>           Coords,
                                ClusterCoordinates,         // coordinates for each cluster
                                ClusterAsVertexIndices,     // vertex indices for each cluster
 
                                ClusterAsCellIndices,
 
 
                                CellsAsCluster;
 
 
 
        CellCluster(const WeakPtr<Grid>&G = NullPtr() )
        {
                if (!G)
                        return;
 
                Clusters = (*G)( ClusterSkeletonID() ); 
 
                // mandatory
                if (!Clusters)
                {
                        return;
                } 
 
                // optional
                Vertices = G->findVertices();
                Cells    = (*G)( CellSkeletonID() ); 
 
                if (Vertices)
                        CartesianVertices = G->getCartesianRepresentation(*Vertices ); 
 
                if (CartesianVertices)
                        Coords = CartesianVertices->Positions();
 
                ClustersAsCartesianVertices   = (*Clusters)(Vertices); 
                if (ClustersAsCartesianVertices)
                        ClusterAsVertexIndices = ClustersAsCartesianVertices->Positions(); 
 
 
                if (Cells)
                {
                        ClustersAsCells = (*Clusters)(Cells); 
                        if (ClustersAsCells)
                                ClusterAsCellIndices = ClustersAsCells->Positions();
                }
        }
 
        bool    operator=(const WeakPtr<Grid>&G); 
 
        CellCluster&operator=(const CellCluster&LS);
 
        ~CellCluster(); 
 
        operator bool() const
        {
                return ClusterAsCellIndices || ClusterAsVertexIndices;
        } 
 
        bool operator!() const
        {
                return !operator bool();
        } 
 
 
};
 
} // namespace Fiber
 
#endif // __FIBER_GRID_TYPES_CELLCLUSTER_HPP