odaUtils.h

Go to the documentation of this file.

#ifndef __ODAUTILS_H__
#define __ODAUTILS_H__

#include "mpi.h"
#include <vector>
#include "petscvec.h"

#ifdef __DEBUG__
#ifndef __DEBUG_DA__
#define __DEBUG_DA__
#endif
#endif

#ifdef PETSC_USE_LOG

#include "petscsys.h"

namespace ot {
  extern int pickGhostsEvent;
  extern int addBdySiblingsEvent;
  extern int DAaprioriCommEvent;

  extern int daInitEvent;
  extern int daFinalEvent;
  extern int DAbPart1Event;
  extern int DAbPart2Event;
  extern int DAbPart3Event;
}

#define PROF_DA_INIT_BEGIN PetscLogEventBegin(daInitEvent,0,0,0,0);
#define PROF_DA_INIT_END PetscLogEventEnd(daInitEvent,0,0,0,0); \
  return ;

#define PROF_DA_FINAL_BEGIN PetscLogEventBegin(daFinalEvent,0,0,0,0);
#define PROF_DA_FINAL_END PetscLogEventEnd(daFinalEvent,0,0,0,0); \
  return ;

#define PROF_PICK_GHOSTS_BEGIN PetscLogEventBegin(pickGhostsEvent,0,0,0,0);
#define PROF_PICK_GHOSTS_END PetscLogEventEnd(pickGhostsEvent,0,0,0,0); \
  return ;

#define PROF_ADD_BDY_SIBLINGS_BEGIN PetscLogEventBegin(addBdySiblingsEvent,0,0,0,0);
#define PROF_ADD_BDY_SIBLINGS_END PetscLogEventEnd(addBdySiblingsEvent,0,0,0,0); \
  return ;

#define PROF_DA_APRIORI_COMM_BEGIN PetscLogEventBegin(DAaprioriCommEvent,0,0,0,0);
#define PROF_DA_APRIORI_COMM_END PetscLogEventEnd(DAaprioriCommEvent,0,0,0,0); \
  return ;

#define PROF_DA_BPART1_BEGIN PetscLogEventBegin(DAbPart1Event,0,0,0,0);
#define PROF_DA_BPART1_END PetscLogEventEnd(DAbPart1Event,0,0,0,0); 

#define PROF_DA_BPART2_BEGIN PetscLogEventBegin(DAbPart2Event,0,0,0,0);
#define PROF_DA_BPART2_END PetscLogEventEnd(DAbPart2Event,0,0,0,0); 

#define PROF_DA_BPART3_BEGIN PetscLogEventBegin(DAbPart3Event,0,0,0,0);
#define PROF_DA_BPART3_END PetscLogEventEnd(DAbPart3Event,0,0,0,0); 

#else

#define PROF_DA_INIT_BEGIN 
#define PROF_DA_INIT_END return ;

#define PROF_DA_FINAL_BEGIN 
#define PROF_DA_FINAL_END return ;

#define PROF_ADD_BDY_SIBLINGS_BEGIN 
#define PROF_ADD_BDY_SIBLINGS_END return ;

#define PROF_PICK_GHOSTS_BEGIN 
#define PROF_PICK_GHOSTS_END return;

#define PROF_DA_APRIORI_COMM_BEGIN
#define PROF_DA_APRIORI_COMM_END return;

#define PROF_DA_BPART1_BEGIN 
#define PROF_DA_BPART1_END  

#define PROF_DA_BPART2_BEGIN 
#define PROF_DA_BPART2_END  

#define PROF_DA_BPART3_BEGIN 
#define PROF_DA_BPART3_END  

#endif

namespace ot { 

  namespace DA_FLAGS {

    enum SortOrderType {
      XYZ, YXZ, XZY, ZXY, YZX, ZYX
    };

    enum ElementFlagType {
      DEP_ELEM=32, FOREIGN=255
    };

    enum loopType {
      ALL, WRITABLE, DEPENDENT, INDEPENDENT, W_DEPENDENT, FROM_STORED
    };

  }//end namespace

  //Forward Declarations
  class TreeNode;
  class DA;

  template<unsigned char cNum>
    unsigned char getElemType(unsigned char hnMask);

  unsigned int getSortOrder(unsigned int x, unsigned int y, 
      unsigned int z, unsigned int sz);

  unsigned char getTouchConfig(const ot::TreeNode& curr,
      const ot::TreeNode& next, unsigned int maxDepth);

  void assignBoundaryFlags(ot::DA* da, 
      std::vector<unsigned char> & bdyFlagVec);

  bool isRegularGrid(ot::DA* da);

  void interpolateData(ot::DA* da, std::vector<double>& in,
      std::vector<double>& out, std::vector<double>* gradOut,
      unsigned int dof, std::vector<double>& pts);

  void interpolateData(ot::DA* da, Vec in, Vec out, Vec* gradOut,
      unsigned int dof, std::vector<double>& pts);

  unsigned int getGlobalMinLevel(ot::DA* da);

  unsigned int getGlobalMaxLevel(ot::DA* da);     

  void writePartitionVTK(ot::DA* da, const char* outFilename);

  //@deprecated
  void pickGhostCandidates(const std::vector<ot::TreeNode> & blocks,
      const std::vector<ot::TreeNode> &nodes, std::vector<ot::TreeNode>& res,
      unsigned int dim, unsigned int maxDepth) ;

  void includeSiblingsOfBoundary(std::vector<ot::TreeNode>& allBoundaryLeaves, 
      const ot::TreeNode& myFirstOctant, const ot::TreeNode& myLastOctant);

  void prepareAprioriCommMessagesInDAtype1(const std::vector<ot::TreeNode>& in,
      std::vector<ot::TreeNode>& allBoundaryLeaves, std::vector<ot::TreeNode>& blocks,
      const std::vector<ot::TreeNode>& allBlocks, int myRank, int npes, int* sendCnt,
      std::vector<std::vector<unsigned int> >& sendNodes);

  void prepareAprioriCommMessagesInDAtype2(const std::vector<ot::TreeNode>& in,
      std::vector<ot::TreeNode>& allBoundaryLeaves, std::vector<ot::TreeNode>& blocks,
      const std::vector<ot::TreeNode>& minsOfBlocks, int myRank, int npes, int* sendCnt,
      std::vector<std::vector<unsigned int> >& sendNodes);


  //@deprecated
  int addSecondRing(const std::vector<ot::TreeNode> & nodes,
      const std::vector<unsigned int> & firstLayer,
      const std::vector<ot::TreeNode> & blocks,
      std::vector<unsigned int> & secondRing);

  int DA_blockPartStage2(std::vector<TreeNode> &nodes,
      std::vector<TreeNode> &globalCoarse,
      unsigned int dim, unsigned int maxDepth, MPI_Comm commActive);

  int DA_blockPartStage3(std::vector<TreeNode> &nodes,
      std::vector<TreeNode>& globalCoarse, std::vector<ot::TreeNode>& minsAllBlocks,
      unsigned int dim, unsigned int maxDepth, MPI_Comm commActive);

  void DA_Initialize(MPI_Comm comm);

  void DA_Finalize();

  int createShapeFnCoeffs_Type1(MPI_Comm comm);
  int createShapeFnCoeffs_Type2(MPI_Comm comm);
  int createShapeFnCoeffs_Type3(MPI_Comm comm);

  /*
     @author Rahul S. Sampath
     @brief Injects values from fine grid nodes
     to coarse grid nodes. Coarse and fine grids must be aligned. 
     setZero sets the argument to 0.
     T must support the '+=' operator.
     */
  template <typename T>
    void injectNodalVector(ot::DA* dac, ot::DA* daf, unsigned int dof,
        std::vector<T>& fVec, std::vector<T>& cVec, void (*setZero)(T&));

}//end namespace

#define GET_ETYPE_BLOCK(type,hnMask,cNum) {\
  if(hnMask) {\
    switch(cNum) {\
      case 0:{\
               type = ot::getElemType<0>(hnMask);\
               break;\
             }\
      case 1:{\
               type = ot::getElemType<1>(hnMask);\
               break;\
             }\
      case 2:{\
               type = ot::getElemType<2>(hnMask);\
               break;\
             }\
      case 3:{\
               type = ot::getElemType<3>(hnMask);\
               break;\
             }\
      case 4:{\
               type = ot::getElemType<4>(hnMask);\
               break;\
             }\
      case 5:{\
               type = ot::getElemType<5>(hnMask);\
               break;\
             }\
      case 6:{\
               type = ot::getElemType<6>(hnMask);\
               break;\
             }\
      case 7:{\
               type = ot::getElemType<7>(hnMask);\
               break;\
             }\
      default:{\
                assert(false);\
              }\
    }\
  }\
}

#include "odaUtils.txx"

#endif /*ODAUTILS_H_*/

---