tree.h

Go to the documentation of this file.

#ifndef _TREE_H_
#define _TREE_H_
#include "definitions.h"

template <size_t N, typename value>
class Hdf5Xmf;

template <size_t N, typename value>
class Tree
{
    template <size_t N1, typename value2>
    friend class Hdf5Xmf; 
    protected:
    real ancestorlength[3];    
    real ancestorcoords[3];    
    morton<N> ancestorkey = 0; 
    uint npx;                  
    uint npy;                  
    uint npz;                  
    private:
    bitmap<N, value> mesh;                         
    std::unordered_map<morton<N>, int> refinelist; 
    bitvector<N> mortonSTL;                        
    // bitvector<N> derefinelist; /*!< list of elements tagged to be removed*/
    //                               might have some of its elements removed, due to this reason, I do not use vector but rather list*/
    //    bitvector<N> mortonSTL ;  /*!< vector to store geometric points in morton code */
    std::unordered_map<morton<N>, int> derefinelist; 
    public:
    bitvector<N> boundarylist; 
    // I wanted seed to each tree but that requires another template parameter M for seed which is normally less than
    // N , i.e. M < N
    //  might not be bad to do this, I have not decided yet

    public:
    Tree( real *length, real *coords, uint nx, uint ny, uint nz ); 
    Tree( real *length, real *coords );                            
    Tree() {};
    void construct( real *length, real *coords, uint nx, uint ny, uint nz ); 
    virtual void level( morton<N> key, uint *level );                        
    void centroid( morton<N> key, real *xyz );   
    void enclosingBox( morton<N> key, real *X ); 
    virtual typename bitmap<N, value>::iterator begin(); 
    virtual typename bitmap<N, value>::iterator end();   
    virtual uint size();                                 
    void reserve( uint *reservedsize );                  
    void siblings( morton<N> key, uint mylevel, morton<N> *sibkey ); 
    void refine( morton<N> key );                                    
    void derefine( morton<N> key );                                  
    void refineRefineList();                                         
    void refineRefineList(bitvector<N>&V);                                         
    void fourToOneP( uint istart,
                     uint iend ); 
    void refineRefineList( uint istart, uint iend ); 
    void fourToOne(); 
    void findFlipLevel( morton<N> key, uint *mylevel, uint *changedirectionlevel,
                        uint *direction ); 
    void flipForNbr( morton<N> *key, uint *mylevel, uint *changedirectionlevel,
                     uint *direction );       
    uint IsInVectorList( morton<N> key );     
    void addToList( morton<N> key );          
    uint count( morton<N> key );              
    void addToDerefineList( morton<N> key );  
    void derefineDerefineList( uint nlevel ); 
                                              // geometry
    uint isInsideSolid( const morton<N> key, const real *geom_xyz,
                        uint n ); 
    virtual typename bitmap<N, value>::iterator find( morton<N> key ); 
    void insertKey( morton<N> key );
    void convertStl2Morton( uint geom_size, real *geom_xyz ); 
                                                              //    template<size_t N1>
    void pushToRefinelist( uint level ); 
    bool isBoundary( morton<N> &key );
    void extractBoundary();
    void getDirections( morton<N> &key, vector<uint> &directions );
    //    void getElemNbr(morton<N> &key);
    uint refineListSize();
    void clearRefineList();
    void extractBoundaryP( uint istart, uint iend );
    bool isInMeshList( const morton<N> &key );
    bool isInRefineList( const morton<N> &key );
    void constructHigherLevelNbrs( const morton<N> &key, const uint &keylevel, const uint &direction, morton<N> *nbr );
    void printMesh();
    bool isBoundary( const morton<N> &key, uint direction );
    //  void readRefineList(morton<N>&, uint);
    std::pair<morton<N>, int> readRefineList( typename std::unordered_map<morton<N>, int>::iterator it );
    morton<N> readDerefineList( typename std::unordered_map<morton<N>, int>::iterator it );
    // typename std::unordered_map<morton<N>,int>::iterator  readDerefineList(morton<N> key);
    void getKey( uint i, morton<N> &key );
    void clearMortonSTL();
    // derefine functions
    void retainFourToOne();
    void removeFromDerefineList( typename std::unordered_map<morton<N>, int>::iterator it );
    typename unordered_map<morton<N>, int>::iterator Dbegin();
    typename unordered_map<morton<N>, int>::iterator Dend();
    void derefineDerefineList();
    void clearMesh();
    void pushToDerefinelist( uint nlevel );
    typename unordered_map<morton<N>, int>::iterator Rbegin();
    typename unordered_map<morton<N>, int>::iterator Rend();
    typename std::unordered_map<morton<N>, int>::iterator findInDerefine( morton<N> key ); 
    void mortonSTLclear();
    void flipRefineElemTag( typename std::unordered_map<morton<N>, int>::iterator it );
    void refinelistReset();
    void constructNonlocalHigherLevelNbrs( const morton<N> &key, const uint &keylevel, const uint &direction, morton<N> *nbr );
    void insertSeed( morton<N> &key );

    void insertNbrs( vector<int> &Nbrs );
    void enclosingBoxFixedLevel( morton<N> key, uint mylevel, real *X );
    void centroidFixedLevel( morton<N> key, const uint mylevel, real *xyz );

    virtual void convertCoordToMorton( real *xyz, morton<N> &key ); 
    typename std::unordered_map<morton<N>, int>::iterator  findInList( morton<N> key );                                                         /*
       template <size_t N1, typename Nvalue1, size_t N2>
       friend void convertCoordToMorton(Tree<N1,Nvalue1> T, real *xyz, morton<N2> &key );
    */

    /*
      template <size_t N1, typename Nvalue1, size_t M1, typename Mvalue1>
      friend class Phdf5;
  */

    ~Tree(); 
};
// the reason I am keeping these separate is because of the need for the solution vector in the base class
// template<size_t N>
// class Hdf5XmfV;

template <size_t N, typename value>
class Voxel : public Tree<N, value>
{
    private:
    uint maxlevel; 
    uint numMax;   
    bitmap<N, value> mesh;
    bitvector<N> lookup;

    public:
    Voxel( real *length, real *coords ) : Tree<N, value>( length, coords, 2, 2, 2 ) {}; 
    void setLevel( uint *l );                                                           
    void generateSearchTree( real *geom_xyz, uint n );                                  
    void distributeGeomToLeaves( real *geom_xyz, uint n ); 
    uint checkSiblingStatus( morton<N> key, morton<N> *sibkey );
    ;                        
    void derefineGeomTree(); 
    bool IsInsideSegment( morton<N> key, real *xyz );

    template <size_t N1, typename value1>
    friend class Hdf5XmfV; 
    ~Voxel();              
                           // add ete <size_t N, typename value>
                           // void Tree<N, value>::refine( morton<N> key )
    // rase because regular refine does not free the memory, though I reallocate in the next step, normally it should not leak
    // void  erase(morton key); /* rather specialized version of erase, since the memory has to be freed as well*/
};

#if ( 1 )
template <size_t N, typename value>
class FullTree : public Tree<N, value>
{
    private:
    uint fixedlevel; 
    bitmap<N, value> mesh;
    std::unordered_map<morton<N>, int> refinelist;   
    bitvector<N> mortonSTL;                          
    std::unordered_map<morton<N>, int> derefinelist; 
    public:
    FullTree( real *length, real *coords ) : Tree<N, value>( length, coords, 2, 2, 2 ) {}; 
    void setLevel( const uint &l );                                                        
    void level( morton<N> key, uint *level );
    void insertKey( morton<N> key );
    uint getLevel();
    // this class has its own mesh as private so it needs ti have its own iterators as well, inheritance does not do this automatically
    void nbrsConstrcut( vector<uint> &Nbrs, uint myrank );
    bool isBoundary( uint &direction, uint myrank );
    typename bitmap<N, value>::iterator find( morton<N> key ); 
    uint size();
    //
    void convertCoordToMorton(real* xyz , morton<N>&key);
    void assignProcs( vector<uint> &Nbrs, uint myrank );
    void findFlipLevel( morton<WSIZE> key,uint fixedlevel, uint *changedirectionlevel, uint *direction ) ;   
    void flipForNbr( morton<WSIZE> *key, uint fixedlevel, uint *changedirectionlevel, uint *direction );

    typename bitmap<N, value>::iterator begin(); 
    typename bitmap<N, value>::iterator end();
    // void centroid( morton<N> key, real *xyz );   /*!< calculates the centroid of the cube given the morton key of the element*/
    // void enclosingBox( morton<N> key, real *X ); /*!< calculates the range that an element occupies in 3D space for a given Element*/
    ~FullTree() {}; 
    // add erase because regular refine does not free the memory, though I reallocate in the next step, normally it should not leak
    // void  erase(morton key); /* rather specialized version of erase, since the memory has to be freed as well*/
};
#endif

#endif