FragmentedUniformGrid3D.hpp

#ifndef __FIBER_GRID_TYPES_REGULARLYFRAGMENTEDUNIFORMGRIDD_HPP
#define __FIBER_GRID_TYPES_REGULARLYFRAGMENTEDUNIFORMGRIDD_HPP
 
#include "RegularlyFragmentedGrid.hpp"
 
namespace Fiber
{
 
struct  gridtypes_API   FragmentedUniformGrid3D : public RegularlyFragmentedGridWithCartesianVertices<3>
{
 
        typedef UniformCartesianArray   CoordsArray_t;
 
        RefPtr<UniformCartesianArray> FragmentCoordinates;
 
        RefPtr<UniformCartesianArray> FragmentBathycenters;
 
        FragmentedUniformGrid3D(const RefPtr<Grid>&theGrid)
        {
                assign( theGrid );
        } 
 
        FragmentedUniformGrid3D(const Grid&theGrid)
        {
                assign( theGrid.self() );
        } 
 
        ~FragmentedUniformGrid3D();
 
        bool    assign(const RefPtr<Grid>&theGrid)
        {
                if (!RegularlyFragmentedGridWithCartesianVertices::assign(theGrid))
                        return false; 
 
                if (FragmentVerticesInCartesianCoordinates  &&
                    FragmentVerticesInCartesianCoordinates->getPositions() )
                {
                        FragmentCoordinates =
                                FragmentVerticesInCartesianCoordinates->getPositions()->getData();
                }
                else
                        FragmentCoordinates = nullptr;
 
                if (PerFragmentDataInCartesianCoordinates &&
                                PerFragmentDataInCartesianCoordinates->getPositions() )
                {
                        FragmentBathycenters =
                                PerFragmentDataInCartesianCoordinates->getPositions()->getData(); 
                } 
                else
                        FragmentBathycenters = nullptr;
 
                if (!FragmentCoordinates)
                        return false;
 
                return true;
        } 
 
        RefPtr<CoordsArray_t> getCoords(const MultiIndex<3>&I) const
        {
                return getCoordData(I);
        }
 
        bool    isValid() const
        {
                return FragmentCoordinates.valid();
        } 
 
 
static  FragmentedUniformGrid3D
        create( const MultiIndex<3>&NumberOfFragments, 
                Grid&myGrid,
                const Eagle::point3&start, 
                const MultiIndex<3>&PerFragmentDims,
                const Eagle::point3&end,
                const MultiIndex<3>&Overlap ={1,1,1});
 
 
 
static FragmentedUniformGrid3D 
        create( const MultiIndex<3>&NumberOfFragments, 
                Grid&myGrid,
                const Eagle::point3&start,
                const Eagle::point3&end_hint,
                const Eagle::tvector3&CellSize,
                const MultiIndex<3>&Overlap);
 
 
static FragmentedUniformGrid3D 
        create( const MultiIndex<3> NumberOfFragments,
                 Grid&myGrid,
                 Eagle::point3 start,
                 MultiIndex<3> PerFragmentDims,
                 const Eagle::tvector3 PerFragmentSize,
                 const MultiIndex<3> Overlap,
                 const Eagle::tvector3 CellShift);
 
 
static  FragmentedUniformGrid3D 
                createInternal( const MultiIndex<3>&NumberOfFragments, 
                                Grid&myGrid,
                                const Eagle::point3&start,
                                const Eagle::tvector3&CellSize,
                                const MultiIndex<3>&Overlap,
                                const MultiIndex<3>&PerFragmentDims,
                                const Eagle::point3&EndAsIntegerMultipleOfCellSize);
 
};
 
 
 
 
} // namespace Fiber
 
#endif // __FIBER_GRID_TYPES_REGULARLYFRAGMENTEDUNIFORMGRIDD_HPP