grid/types/RegularlyFragmentedGrid.hpp

#ifndef __FIBER_GRID_TYPES_REGULARLYFRAGMENTEDREGULARGRID_HPP
#define __FIBER_GRID_TYPES_REGULARLYFRAGMENTEDREGULARGRID_HPP
 
 
#include "GridWithCartesianVertices.hpp"
#include "fish/fiber/field/UniformCartesianArray.hpp"
#include "fish/fiber/field/RegularlyFragmentedField.hpp"
 
 
namespace Fiber
{
 
extern gridtypes_API SkeletonID computeFragmentSkeletonID(const DynamicSize&Fragmentation, const SkeletonID&SID);
extern gridtypes_API SkeletonID computeFragmentSkeletonID(const Field&F, const SkeletonID&SID);
 
extern gridtypes_API bool       createRegularlyFragmentedSkeleton( Grid&, const RefPtr<Skeleton>&, const FragmentIDCollection&FIC);
extern gridtypes_API bool       createRegularlyFragmentedSkeleton( Grid&, const RefPtr<Skeleton>&, const Field&FragmentedField);
extern gridtypes_API bool       createRegularlyFragmentedSkeleton( Grid&, const RefPtr<Skeleton>&);
extern gridtypes_API bool       createRegularlyFragmentedSkeleton( Grid&, const Skeleton&, const FragmentIDCollection&FIC);
extern gridtypes_API bool       createRegularlyFragmentedSkeleton( Grid&, const Skeleton&);
 
 
struct  gridtypes_API   RegularlyFragmentedGridBase : virtual public TypedGrid
{
static  SkeletonID FragmentVerticesSkeletonID()
        {
                return SkeletonID(0, 2);
        } 
 
static  SkeletonID computeFragmentSkeletonID(const Field&F, const SkeletonID&SID);
 
 
        RefPtr<Skeleton>        FragmentVerticesSkeleton;
 
        bool    assign(const RefPtr<Grid>&theGrid)
        {
                if (!TypedGrid::assign(theGrid) ) return false;
 
        Grid&G = *theGrid; 
                FragmentVerticesSkeleton = G( FragmentVerticesSkeletonID() ); 
 
                if (!FragmentVerticesSkeleton) return false;
 
                return true;
        }
 
static  void create( Grid&myGrid )
        {
                myGrid[ FragmentVerticesSkeletonID() ];
        } 
#if 0
static  bool
        createFragmentSkeleton( Grid&myGrid, const RefPtr<Skeleton>&Vertices,
                                const Field&VertexPositions,
                                Skeleton&FragmentSkeleton);
#endif
 
};
 
 
template <int VertexDims>
struct  RegularlyFragmentedGrid : RegularlyFragmentedGridBase
{
static  constexpr int Dims = VertexDims;
 
static  SkeletonID FragmentSkeletonID(int IndexDepth=0,int RefLevel = 0)
        {
        SkeletonID SID(VertexDims, IndexDepth + 2);
 
                if (RefLevel > 0)
                        SID.setIsotropicRefinement( RefLevel );
 
                return SID;
        }
 
static  SkeletonID ID()
        {
                return FragmentSkeletonID();
        }
 
static  SkeletonID FragmentSkeletonID(const SkeletonID&S)
        {
                return SkeletonID( S.DomainSize(), S.IndexDepth()+2, S.RefinementSize() );
        }
 
        RefPtr<Skeleton>                                        FragmentSkeleton;
 
        RefPtr<Representation>                                  FragmentsAsVertices; 
 
        typedef MemArray<VertexDims, RefPtr<FragmentID> >       FragmentArray_t;
 
        RefPtr<FragmentArray_t>                                 FragmentArray;
 
        MultiIndex<VertexDims>  NumberOfFragments() const
        {
                if (FragmentArray)
                        return FragmentArray->Size(); 
 
                return MultiIndex<VertexDims>();
        } 
 
 
        RefPtr<FragmentID> getFragmentID(const MultiIndex<VertexDims>&FragmentIndex) const
        {
                if (FragmentArray)
                        return (*FragmentArray)[FragmentIndex];
 
                return NullPtr();
        }
 
 
        RegularlyFragmentedGrid(const RefPtr<Grid>&G = nullptr)
        {
                assign(G);
        }
 
 
        bool    assign(const RefPtr<Grid>&theGrid)
        {
                FragmentSkeleton = nullptr; 
                FragmentsAsVertices = nullptr; 
                FragmentArray = nullptr;
 
                if (!RegularlyFragmentedGridBase::assign(theGrid) ) return false;
 
        Grid&G = *theGrid;
                FragmentSkeleton = G( FragmentSkeletonID() ); 
                if (!FragmentSkeleton) return false;
 
        RefPtr<Skeleton> Vertices = G.findVertices(); 
                if (!Vertices) return false;
 
                FragmentsAsVertices = (*FragmentSkeleton)( *Vertices ); 
 
                if (!FragmentsAsVertices) return false; 
 
                if (RefPtr<Field> FragmentField = FragmentsAsVertices->getPositions() )
                        FragmentArray = FragmentField->getData();
 
                return true;
        } 
 
static  RegularlyFragmentedGrid
        create( Grid&myGrid, const RefPtr<RegularlyFragmentedField<VertexDims> >&VertexPositions, const SkeletonID&FragmentedSkeletonID)
        {
                RegularlyFragmentedGridBase::create( myGrid ); 
 
        RefPtr<Skeleton> Vertices = myGrid.findVertices(); 
                if (!Vertices)
                        return RegularlyFragmentedGrid( nullptr ); 
 
//      RefPtr<Skeleton> pFragmentSkeleton = myGrid( FragmentSkeletonID(FragmentedSkeletonID) );
        Skeleton&FragmentSkeleton = myGrid[ FragmentSkeletonID(FragmentedSkeletonID) ]; 
 
                return  createFragmentSkeleton( myGrid, Vertices, VertexPositions, FragmentSkeleton);
        }
 
static  RegularlyFragmentedGrid
        create( Grid&myGrid, const RefPtr<RegularlyFragmentedField<VertexDims> >&VertexPositions,
                const RefPtr<Skeleton>&Vertices)
        {
                if (!Vertices) return RegularlyFragmentedGrid( nullptr );
 
                RegularlyFragmentedGridBase::create( myGrid );
 
        Skeleton&FragmentSkeleton = myGrid[ FragmentSkeletonID(*Vertices) ];
 
                return  createFragmentSkeleton( myGrid, Vertices, VertexPositions, FragmentSkeleton);
        }
 
static  RegularlyFragmentedGrid
        create( Grid&myGrid, const RefPtr<RegularlyFragmentedField<VertexDims> >&VertexPositions)
        {
                RegularlyFragmentedGridBase::create( myGrid ); 
 
        int IndexDepth=0; int RefLevel=0;
                Assert( IndexDepth == 0 );
        RefPtr<Skeleton> Vertices = myGrid.findVertices(); 
                if (!Vertices)
                        return RegularlyFragmentedGrid( nullptr ); 
 
//      RefPtr<Skeleton> pFragmentSkeleton = myGrid( FragmentSkeletonID(IndexDepth,RefLevel) );
        Skeleton&FragmentSkeleton = myGrid[ FragmentSkeletonID(IndexDepth,RefLevel) ]; 
 
                return  createFragmentSkeleton( myGrid, Vertices, VertexPositions, FragmentSkeleton);
        }
 
static  RegularlyFragmentedGrid
        createFragmentSkeleton( Grid&myGrid, const RefPtr<Skeleton>&Vertices,
                                const RefPtr<RegularlyFragmentedField<VertexDims> >&VertexPositions,
                                Skeleton&FragmentSkeleton)
        {
                Assert( VertexPositions );
                Assert( VertexPositions->getFragmentIDCollection() );
                Assert( VertexPositions->getFragmentIDCollection()->getFragmentLayout().isValid() );
                if (!VertexPositions->getFragmentIDCollection()->getFragmentLayout().isValid() )
                {
                        Verbose(0) << " NOTE: RegularlyFragmentedGrid::createFragmentSkeleton() got a regularly fragmented field without fragment layout.";
                }
 
        //
        // Note: Vertices dimensionality is -1 yet at this point because we don't have data there so far.
        // because no field is defined on the representations yet. And we can't define a field yet
        // because we want to save it later, and we can't save it until all the representations
        // have been defined because these will not be saved on demand.
        //
        Representation&FragmentsAsVertices = FragmentSkeleton[ *Vertices ];
 
                if (RefPtr<Field> HaveField = FragmentsAsVertices.getPositions())
                {
                        AppVerbose("FiberLib",10) << "Info: RegularlyFragmentedGrid creating found fragments as Vertices";
                }
 
                if (!FragmentsAsVertices.getPositions())
                {
//              RefPtr<MemArrayBase<VertexDims> >
                RefPtr<MemBase>
                        FragmentTopologyField = VertexPositions->newFragmentationArray();
 
#if     0
                        Verbose(0) << "VertexPositions fragments are " << VertexPositions->getNumberOfFragments();
                        Verbose(0) << "FragmentTopologyField is of size " << FragmentTopologyField->Size(); 
 
                        if (!pFragmentSkeleton)
                        {
                                Verbose(0) << "FragmentSkeleton has no size yet, freshly created.";
                        }
#endif
 
                        if (!FragmentsAsVertices.setPositions( new Field( FragmentTopologyField->self() )) ) 
                        {
                                AppVerbose("FiberLib",0) << "CANNOT set positions for RegularlyFragmentedGrid Fragments as Vertices - wrong size!? "
                                           << " VertexPositions fragments are " << VertexPositions->getNumberOfFragments()
                                           << " FragmentTopologyField is of size " << FragmentTopologyField->getSize();
                                return RegularlyFragmentedGrid(nullptr);
                        }
 
/*
                        if (FragmentsAsVertices.getSize())
                                Verbose(0) << " FragmentsAsVertices have size " << *FragmentsAsVertices.getSize(); 
 
                        Verbose(0) << "Fragment Skeleton has size " << FragmentSkeleton.Size();
*/
                }
 
                return RegularlyFragmentedGrid( myGrid.self() );
        }
 
 
static  RegularlyFragmentedGrid
        createWithCartesianVertices( Grid&myGrid, const MultiIndex<VertexDims>&NumberOfFragments)
        {
        RefPtr<RegularlyFragmentedField<VertexDims> >
                Positions = new RegularlyFragmentedField<VertexDims>(NumberOfFragments);
 
                GridWithCartesianVertices::create( myGrid, VertexDims, Positions);
 
                return create(myGrid, Positions);
        }
 
};
 
 
template <int VertexDims>
struct  RegularlyFragmentedGridWithCartesianVertices : public RegularlyFragmentedGrid<VertexDims>
                                                     , public GridWithCartesianVertices
{
        typedef MemArrayBase<VertexDims>        CoordsArray_t;
 
        RefPtr<Representation>  FragmentVerticesInCartesianCoordinates; 
 
        RefPtr<Representation>  PerFragmentDataInCartesianCoordinates;
 
        RefPtr<RegularlyFragmentedField<VertexDims> >           Positions;
 
 
        RefPtr<CreativeArrayBase> getCoordCreator(const MultiIndex<VertexDims>&I) const
        {
                if (Positions)
                        return (*Positions)(I);
 
                return NullPtr();
        }
 
        RefPtr<MemBase> getCoordData(const MultiIndex<VertexDims>&I) const
        {
                if (RefPtr<CreativeArrayBase> CAB = getCoordCreator(I))
                        return CAB->create();
 
                return NullPtr();
        }
 
        RefPtr<CoordsArray_t> getCoords(const MultiIndex<VertexDims>&I) const
        {
                return getCoordData(I);
        } 
 
        RefPtr< RegularlyFragmentedField<VertexDims> > newVertexField(const char*Fieldname)
        {
                if (!CartesianVertices)
                        return NullPtr();
 
        RefPtr< RegularlyFragmentedField<VertexDims> >
                Values    = new RegularlyFragmentedField<VertexDims>( *Positions );
                (*CartesianVertices)[ Fieldname ] = Values; 
                return Values;
        } 
 
        RefPtr< RegularlyFragmentedField<VertexDims> > getVertexField(const char*Fieldname)
        {
                if (!CartesianVertices)
                        return NullPtr();
 
        RefPtr< RegularlyFragmentedField<VertexDims> >
                Values = (*CartesianVertices)( Fieldname );
 
                if (!Values)
                {
                        Values    = new RegularlyFragmentedField<VertexDims>( *Positions ); 
                        (*CartesianVertices)[ Fieldname ] = Values; 
                }
 
                return Values;
        } 
 
        MultiIndex<VertexDims>  NumberOfFragments() const
        {
                if (Positions)
                        return Positions->getNumberOfFragments(); 
 
                return MultiIndex<VertexDims>(0);
        }
 
 
        bool    isValid() const
        {
                return getCoords( MultiIndex<VertexDims>(0) ).valid();
        } 
 
        RegularlyFragmentedGridWithCartesianVertices()
        {}
 
        RegularlyFragmentedGridWithCartesianVertices(const RefPtr<Grid>&theGrid)
        {
                assign( theGrid );
        }
 
        bool    assign(const RefPtr<Grid>&theGrid)
        {
                FragmentVerticesInCartesianCoordinates = nullptr; 
                PerFragmentDataInCartesianCoordinates = nullptr;
                Positions = nullptr;
 
                if (!GridWithCartesianVertices::assign(theGrid) ) return false;
                if (!RegularlyFragmentedGrid<VertexDims>::assign(theGrid) ) return false; 
                if (!this->FragmentVerticesSkeleton)              return false;
 
                FragmentVerticesInCartesianCoordinates= (*this->FragmentVerticesSkeleton)( theGrid->findCartesianChart() ); 
                if (!FragmentVerticesInCartesianCoordinates) return false;
 
                if (this->FragmentSkeleton)
                        PerFragmentDataInCartesianCoordinates = (*this->FragmentSkeleton)( theGrid->findCartesianChart() ); 
 
//              if (!PerFragmentDataInCartesianCoordinates) return false; 
 
                Positions = CartesianPositions;
                if (!Positions) return false;
 
                return true;
        } 
 
 
 
static  RegularlyFragmentedGridWithCartesianVertices
        create( Grid&myGrid, const MultiIndex<VertexDims>&NumberOfFragments,
                        bool    NeedPerFragmentData = false)
        {
        
        RefPtr<RegularlyFragmentedField<VertexDims>>
                Positions = myGrid.getCartesianPositions();
 
 
                if (myGrid.getCartesianPositions() )
                {
                        if (!Positions)
                        {
       
                                Verbose(10) << "Positions with " << myGrid.getCartesianPositions()->nFragments() 
                                            << " fragments are already on the provided grid but incompatible as they are not regularly fragmented, cannot create regularly fragmented Grid.";
                                return RegularlyFragmentedGridWithCartesianVertices(NullPtr());
                        } 
 
                        Verbose(50) << "HAVE Regular Positions with " << Positions->getNumberOfFragments() << " and want " << NumberOfFragments << " fragments."; 
 
                        if (Positions->getNumberOfFragments() != NumberOfFragments)
                                return RegularlyFragmentedGridWithCartesianVertices(NullPtr());
                } 
                else
                {
                        Positions = RegularlyFragmentedField<VertexDims>::newField(NumberOfFragments, myGrid.getCartesianPositions() ); 
                }
 
                // Positions are already on the provided grid but incompatible. 
                if (!Positions)
                {
                        Verbose(10) << "Could not create Positions!?";
                        return RegularlyFragmentedGridWithCartesianVertices(NullPtr());
                }       
 
                GridWithCartesianVertices::create( myGrid, VertexDims, Positions); 
 
                Verbose(0) << "Have cartesian vertices in " << Positions->nFragments() 
                            << " fragments, add fragment topology for "
                            << Positions->getNumberOfFragments() <<" to Grid";
 
                if (RegularlyFragmentedGrid<VertexDims>
                    RG = RegularlyFragmentedGrid<VertexDims>::create( myGrid, Positions))
                {
                        
                RefPtr<Chart> CartesianChart = myGrid.findCartesianChart();
                        Assert(CartesianChart.valid());
 
                        Assert(RG.FragmentSkeleton.valid());
 
                        // it is sufficient to access the skeleton with the [] operator 
                        // to create a Representation. This Representation will be 
                        // used to story fragment-centered information in cartesian coordinates. 
                        if (NeedPerFragmentData)
                        {
                                (*RG.FragmentSkeleton)[ CartesianChart ]; 
                        } 
 
                        Assert(RG.FragmentVerticesSkeleton.valid());
                        (*RG.FragmentVerticesSkeleton)[ CartesianChart ];
                }
 
                return RegularlyFragmentedGridWithCartesianVertices( myGrid.self() );
        }
 
};
 
 
 
} // namespace Fiber
 
#endif // __FIBER_GRID_TYPES_REGULARLYFRAGMENTEDREGULARGRID_HPP