FragmentTopology.hpp

#ifndef __FIBER_GRID_TYPES_FRAGMENTTOPOLOGY_HPP
#define __FIBER_GRID_TYPES_FRAGMENTTOPOLOGY_HPP
 
#include "fish/fiber/field/RegularlyFragmentedField.hpp"
#include "fish/fiber/grid/SkeletonID.hpp"
#include "fish/fiber/grid/Skeleton.hpp"
 
#include "TypedGrid.hpp"
 
namespace Fiber
{
 
extern gridtypes_API SkeletonID FragmentSkeletonID(const SkeletonID&S, int NewDimension);
 
struct gridtypes_API FragmentTopology : virtual public TypedGrid
{
        RefPtr<Skeleton>        FragmentSkeleton; 
 
        RefPtr<Representation>                          FragmentsAsBaseElements; 
 
        typedef TypedArray<RefPtr<FragmentID> >         FragmentArray_t;
 
        RefPtr<FragmentArray_t>                         FragmentArray; 
 
 
 
static  bool    isAPossibleFragmentSkeletonID(const SkeletonID&Candidate, const SkeletonID&BaseSkeletonID);
 
        
        using  NamedSkeleton_t = std::map<std::string, MemCore::WeakPtr<Fiber::Skeleton>>;
 
        bool    assign(const RefPtr<Grid>&theGrid, const SkeletonID&S,int FragmentTopologyDimension);
        
        FragmentTopology(const RefPtr<Grid>&theGrid, const SkeletonID&S,int FragmentTopologyDimension)
        {
                assign( theGrid, S,FragmentTopologyDimension);
        } 
 
        ~FragmentTopology(); 
 
static  void create( Grid&theGrid, const SkeletonID&S, const RefPtr<FragmentArray_t>&theFragmentArray, int FragmentTopologyDimension); 
 
        using   FragmentSkeletonSearch_t = std::tuple<string, RefPtr<Fiber::Skeleton>>;
 
static  FragmentSkeletonSearch_t
        findHighestDimensionalSkeleton(const SkeletonID&WhichOne, const NamedSkeleton_t&AvailableGridSkeletons); 
 
static  RefPtr<Skeleton>
                findHighestDimensionalSkeleton(const SkeletonID&WhichOne, const SkeletonMap&AvailableGridSkeletons); 
 
static  RefPtr<Representation>
                findHighestDimensionalRepresentation(
                        const SkeletonID&WhichOne, const SkeletonMap&AvailableGridSkeletons); 
 
static  RefPtr<Field>
                findHighestDimensionalFragmentationField(
                        const SkeletonID&WhichOne, const SkeletonMap&AvailableGridSkeletons);
 
 
static  FragmentSkeletonSearch_t
        findMatchingSkeleton(const SkeletonID&WhichOne, const NamedSkeleton_t&AvailableGridSkeletons); 
 
static  FragmentSkeletonSearch_t
        findSkeletonWithRelativeRepresentation(const SkeletonID&WhichOne, int DimensionOfFragmentSkeleton,
                                               const NamedSkeleton_t&AvailableGridSkeletons);
        
};
 
using FragmentSkeleton = FragmentTopology;
 
 
template <int Dims>
struct RegularFragmentTopology : public FragmentTopology
{
        typedef MemArray<Dims, RefPtr<FragmentID> >     FragmentArray_t;
 
        RefPtr<FragmentArray_t>
                RegularFragmentArray() const
        {
                return this->FragmentArray;
        }
 
        bool    assign(const RefPtr<Grid>&theGrid, const SkeletonID&S)
        {
                if (!FragmentTopology::assign( theGrid, S,Dims)) return false;
 
                if (!RegularFragmentArray() ) return false; 
 
                return true;
        }
        
        RegularFragmentTopology(const RefPtr<Grid>&theGrid, const SkeletonID&S)
        {
                if (!assign( theGrid, S))
                        RefPtr<Grid>::operator=(nullptr);
        } 
 
static  void create( Grid&theGrid, const SkeletonID&S, const RefPtr<FragmentArray_t>&theFragmentArray)
        {
                FragmentSkeleton::create( theGrid,S,theFragmentArray,Dims);
        }
 
};
 
 
} // namespace Fiber
 
 
#endif //  __FIBER_GRID_TYPES_FRAGMENTTOPOLOGY_HPP