templateForest.h

Go to the documentation of this file.

#ifndef _TEMPLATEFOREST_H_
#define _TEMPLATEFOREST_H_
#include "communicate.h"
#include "definitions.h"
#include "tree.h"
#include "typedefs.h"

template <class T>
using treeList = std::list<T>; 
template <size_t M> 
using seed = std::unordered_map<morton<M>, uint>;


//template <size_t N, typename Nvalue, size_t M, typename Mvalue, template< size_t L, typename Lvalue> class T=Tree >
template <size_t N, typename Nvalue, size_t M, typename Mvalue, class T >
class TemplateForest
{
    protected:
    real ancestorlength[3]; 
    real ancestorcoords[3]; 
    uint npx;               
    uint npy;               
    uint npz;               
    private:
    MpiCom Com; 
    int duplicated=0;
    treeList<Tree<N,Nvalue>> trees;                                         
    uint maxProcLevel; 
    bitlist<M> seeds;  /*maybe in the future add this to class tree*/
    uint maxseedlevel; 
    Tree<M, real> geom;  
    vector<uint> destination; 
    vector<uint> sendtag; 
    vector<uint> recvtag;
    vector <uint> nbrsOfNbrs;
    vector<bitset<M + N>> *message=nullptr;
    struct Zoltan_Struct *zz=nullptr; /*<Zoltan structure to be used for partitioning */ 
    Zoltan_Out zoltan_out;
    MPI_Comm graphComm;
    MPI_Request *request=nullptr;
    MPI_Request *request1=nullptr;
    char   nameAppendix[80];
    unsigned long long meshSize;

    // seed<M> seeds; /*!< look up the tree that need to be transfered to other procs */
    // may be use tuple in the future*/
    // std::tuple<morton<M>,Tree<N,Nvalue>> lookup();

    public:
//    TemplateForest<N, Nvalue, M, Mvalue, T>( T &proc, real *length, real *coords, uint nx, uint ny, uint nz ); /*!<constructor */
          
    TemplateForest<N, Nvalue, M, Mvalue, T>( ){}; 
    TemplateForest<N, Nvalue, M, Mvalue, T>(int argcs,char *pArgs[], T &proc, real *length, real *coords, uint nx, uint ny, uint nz ); 
    void construct(int argcs,char *pArgs[], T &proc, real *length, real *coords, uint nx, uint ny, uint nz );
    uint getTotalSize();
    void assignSeeds( real *length,T &proc);
//    void formProcTop(Tree<M, Mvalue> &proc ,uint proclevel,real *geom_xyz,int geom_nn);
    void assignGeom( T &proc,real *geom_xyz, uint geom_nn );
    void encodeGeometry(); 
    void refineEachTree( uint nlevel ); 
    void moveGeom( T &proc, real *geom_xyz,uint n, real x[3]); 
    void getListEachTree();
    bool isInSeed( morton<M> &key, uint *counter ); 
    void flipAll( morton<N> &key, uint *mylevel, uint *direction );
    void getDirections( morton<N + M> &key, uint combinedlevel, vector<uint> &directions );
    void recoverAllZeroSingularity(morton<N+M> &key, const uint &combinedlevel); 
    void combinedLevel(const morton<N+M> &key, uint *level );
    void findSeedLevelForRcvdMessage(const morton<N+M> &key, uint *mylevel, Tree<M,Mvalue> & proc);
    void findSeedLevelForRcvdMessage(const morton<N+M> &key, uint *mylevel, FullTree<M,Mvalue> & proc);
    void constructSeedKeyForRcvdMessage(const morton<N+M> &key,const uint &seedlevel, morton<M> &seedkey);
    void constructElementKeyForRcvdMessage(const morton<N+M> &key,const uint &seedlevel, morton<N> &elementkey);
    void removeAllZeroSingularity(morton<N+M> &key,const uint &combinedlevel);   
    void getMaxSeedsLevel(T &proc);
    void findFlipLevel( morton<N + M> key, uint *mylevel, uint *changedirectionlevel,
                        uint *direction ); 
    void flipForNbr( morton<N + M> &key, uint *mylevel, uint *changedirectionlevel,
                     uint *direction ); 
    void getTotalMeshSize(); 
    void getNbrSeedLevel( morton<N + M> &combinedkey, uint topologylevel, uint *nbrseedleve, Tree<M,Mvalue> &proc );
    void getNbrSeedLevel( morton<N + M> &combinedkey, uint topologylevel, uint *nbrseedleve, FullTree<M,Mvalue> &proc );
    uint forestsize();
    void getElemNbrs(Tree<M, Mvalue> &proc,const morton<M> key, bitvector<M> &nbr ); 
    void comPatternConstruct( Tree<M, Mvalue> &proc ); // might be a bug in here
    void comPatternConstruct( FullTree<M, Mvalue> &proc, vector<uint> &Nbrs); 
    void fourToOneBalance( T &proc ); 
    void refineForestBalanced( uint nlevel,T &proc );
    void nonCollectiveNbrComm(  );

    // composite morton code functions
    // void flipForNbr( morton<M> &key, uint *mylevel, uint *changedirectionlevel, uint *direction );
    // typename bitlist<M>::iterator find( morton<M> key );

    void pushToDerefineEachTree( uint nlevel, Tree<M, uint> &proc ); 
    void retainFourToOneBalance( Tree<M, uint> &proc ); 
    void checkZoltanPartConsistency(Tree<M,Mvalue>&proc ); 
    void createCommGraph(uint Nnbr);  // works for both of the objects if we use the proper getElemNbrs
    void createNbrsOfNbrs( );  // this one uses neighbor connectivity   
    void checkGraphConsistency(); 
    void filterRefineList();
    void setMaxProcLevel(const uint refinelevel );   
  
    //uint findIndexInSeed( Tree<M,uint> &proc,  morton<M> &seedkey );
    uint findIndexInSeed( T &proc,  morton<M> &seedkey );

//  void appendToMessage(Tree<M, uint> &proc,const uint seednbrlevel ,  morton<M+N> &seednbrkey ,morton<M+N> &combinedkey,const uint combinedlevel);

    void appendToMessage( T &proc, morton<M> &seednbrkey ,morton<M+N> &combinedkey,const uint combinedlevel );


#if(0)
// derefine routines
   void zoltanGeomrepart(  Tree<M,Mvalue>& proc,uint setmethod );
// debug routnes
    void debug( Tree<M, Mvalue> &proc );
    void debugDerefine( Tree<M, Mvalue> &proc );
    void checkNbrsOfNbrsConsistency();
    bool checkWithNbrs(bool *sendbuf,bool *recvbuf); 
    void rcvrMessageSize(int *sendbuf, int *recvbuf); 
    void constructCommWeak(const vector<int>Nbr);
// graph communication trial
#endif
    void MPIStartUp(); 
    void checkInputParams(int argcs,char *pArgs[]); 
    void runInfo();
    void currentDateTime();
    template <size_t N1, typename Nvalue1, size_t M1, typename Mvalue1,class T1 >
    friend class templatePhdf5;

    ~TemplateForest(); 
   // ~TemplateForest(){}; /*!< Destructor of the object*/

};


#endif