amroc/hds/GridDataBlock.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef _included_GridDataBlock_h
#define _included_GridDataBlock_h

#include "DAGHParams.h"

#include "Coords.h"
#include "BBox.h"

#include "GridBox.h"
#include "GridBoxList.h"
#include "PackedGridDataBucket.h"
#include "GridTable.h"
#include "GridHierarchy.h"

#include "CommServer.h"

#include "GDBInteraction.h"

/* Utility functions */
void gdbSetRanks(const int rank, const int align, short* ranks);
void gdbAlignBBox(const int, class BBox&, const int);

#include "GridFunctionVoid.h"

#include "GridData1.h"
#include "GridData2.h"
#include "GridData3.h"

#include <iosfwd>

template <class Type, int dim> class GridFunction;
template <class Type, int dim> class GridDataBlock;
template <class Type, int dim> std::ostream& operator<<(std::ostream&, const GridDataBlock<Type,dim>&);
template <class Type, int dim> std::ofstream& operator<<(std::ofstream&, const GridDataBlock<Type,dim>&);
template <class Type, int dim> std::ifstream& operator>>(std::ifstream&, GridDataBlock<Type,dim>&);
template <class Type, int dim> std::stringstream& operator<<(std::stringstream&,
                                                             const GridDataBlock<Type,dim>&);
template <class Type, int dim> std::stringstream& operator>>(std::stringstream&, 
                                                             GridDataBlock<Type,dim>&);  

template <class Type, int dim>
class GridDataBlock {
  friend class GridFunction<Type,dim>;

  const int gfid;

  /**************************************************************/
  /* level, geometry & other specs */
  /**************************************************************/
public:
  short timenum;  
  short levelnum;              /* levelnum */ 

  /**************************************************************/
private:
  short myindex;
  short* sten_rad;       

  /**************************************************************/
  /* structure info */
  /**************************************************************/
  short ranks[dim];             /* my ranks (if align != DAGH_All) */
  BBox merged_bbox;           /* merged bbox ... */
  BBox interior_bbox;           
  /**************************************************************/

  BBox prolongbbox[2*dim]; 
  short prolongflag[2*dim];
  
  BBoxList* bndrybboxlist[2*dim];
  int bndryindex[2*dim]; 

  int reuse;

  GridData<Type,dim> data;

  /**************************************************************/

  /**************************************************************/
  /* Interlevel communication */
  /**************************************************************/
  GDB_Interaction* gdb_parent_info;
  int gdb_parent_index;
  GDB_Interaction* gdb_child_info;
  int gdb_child_index;
  
  /**************************************************************/
  /* Detailed information for ghost communication */
  /**************************************************************/
  short comm_flag;
  int maxindex;
  GDB_Interaction*** gdb_write_info;   
  int** gdb_write_index;
  GDB_Interaction*** gdb_read_info; 
  int** gdb_read_index;   
  GridTableGhostRcv *gdb_data_rcv;
  /**************************************************************/
   
  /**************************************************************/
  GridTable &gtable;
  /**************************************************************/

  /**************************************************************/
  GridHierarchy &dagh;
  /**************************************************************/

private:
   /**************************************************************/
   /* Disable the following */
   /**************************************************************/
   GridDataBlock(const GridDataBlock<Type,dim>& other);
   GridDataBlock<Type,dim> const &operator=(const GridDataBlock<Type,dim>& other);

private:
   /**************************************************************/
   /* The constructor */
   /**************************************************************/
   GridDataBlock(GridFunctionVoid& gf,
                 GridHierarchy& gh,
                 GridTable& gt,
                 const GhostInteraction& gi,
                 const int midx, 
                 const GridBox& gb,
                 const int time,
                 const int level,
                 const int bwidth,
                 BBoxList* bndrybbl,
                 BBoxList* prolongbbl,
                 const int extghwidth,
                 const short* olap,
                 const short *sten,
                 const int align,
                 const int mindex,
                 const int cflag,
                 const GridDataBlock<Type,dim>* gdbtmpl);
        
   /**************************************************************/
   /* The destructor */
   /**************************************************************/
   ~GridDataBlock();

   /**************************************************************/
   /* Set up internals */
   /**************************************************************/
   void intersectgbl(GridFunctionVoid& gf, 
                     GridBoxList& gbl, 
                     const BBox& bbtest,
                     const int& level,
                     GridBoxList& resgbl,
                     const short* olap, 
                     const short* sten,
                     const int& align,
                     GridBoxList** workgbl,
                     const BBox* bballow = 0);

   void gdbSetUpLevelInteractionInfo(GridFunctionVoid& gf, 
                                     GridHierarchy& gh,
                                     const short* olap,
                                     const int& align);

   void gdbSetUpBoundaries(const int& bwidth,
                           BBoxList* bndrybbl,
                           BBoxList* prolongbbl,
                           const short* olap);

   void gdbSetUpGhostInteractionInfo(GridFunctionVoid& gf,
                                     const BBox& di_bbox,
                                     const BBox& dm_bbox,
                                     const GhostInteraction& gi,
                                     const short* olap,
                                     const short* dsten_rad,
                                     const int align);
     
   void gdbAddLevelInteractionInfo(GridFunctionVoid& gf, 
                                   GridBoxList& lgbl, 
                                   const int& level, 
                                   GDB_Interaction*& gdb_il_info, 
                                   int& mindex,
                                   const short* olap,
                                   const int& align);
   void gdbAddGhostInteractionInfo(const int axis, const int dir,
                                   const BBox& rb, const BBox& wb,
                                   const BBox& hisbb,
                                   const int owner, const int idx,
                                   BBox*** setup_write_info,
                                   BBox*** setup_read_info);

   /**************************************************************/
   /* Main setup */
   /**************************************************************/
   void gdbSetUpMain(const int extghwidth);

   /**************************************************************/
   /* Interlevel info */
   /**************************************************************/
public:
   inline int has_parents() const { return (gdb_parent_index>0); }
   inline const int& parents() const { return (gdb_parent_index); }
   inline const GDB_Interaction* parentlist() const { return (gdb_parent_info); }
   inline GDB_Interaction* parentlist() { return (gdb_parent_info); }
   inline const BBox& parentbox(const int& j) { return (gdb_parent_info[j].bbox); }
   inline const int& parentidx(const int& j) { return (gdb_parent_info[j].idx); }
   
   inline int has_children() const { return (gdb_child_index>0); }
   inline const int& children() const { return (gdb_child_index); }
   inline const GDB_Interaction* childlist() const { return (gdb_child_info); }
   inline GDB_Interaction* childlist() { return (gdb_child_info); }
   inline const BBox& childbox(const int& j) { return (gdb_child_info[j].bbox); }
   inline const int& childidx(const int& j) { return (gdb_child_info[j].idx); }

   /**************************************************************/
   /* Ghost communications */
   /**************************************************************/
private:
   int gdbWriteGhosts(const int proc,
                      const int time_value,
                      const int axis,
                      const int dir,
                      GridDataBucket<Type>& gdb,
                      const int at);

public:
   inline GDB_Interaction** gdbReadInfo(const int proc)
     { return ( (gdb_read_info[proc]) ? gdb_read_info[proc] : 0 ); }
   inline GDB_Interaction** gdbWriteInfo(const int proc)
     { return ( (gdb_write_info[proc]) ? gdb_write_info[proc] : 0 ); }
   /**************************************************************/
   
   /**************************************************************/
   /* Data communications */
   /**************************************************************/
private:
   void gdbWriteData(const int time_value, GridDataBucket<Type>& gdb, const int at);
   void gdbWriteData(const int time_value, const BBox& where, 
                     GridDataBucket<Type>& gdb, const int at);
   /**************************************************************/

   /**************************************************************/
   /* Bounding box access */
   /**************************************************************/
public:
   inline const BBox& boundingbox() const { return (merged_bbox); }
   inline const BBox& interiorbox() const { return (interior_bbox); }
   inline const BBox& databox() const { return (griddata().bbox()); }  

   inline int has_externalboundaries() const { 
     for (register int r=0; r<2*dim; r++) 
       if (bndryindex[r]>0) return 1; 
     return 0; 
   }
   inline int has_externalboundary(const int dir) const { return (bndryindex[dir]>0); }
   inline const int& externalboundaries(const int dir) const { return (bndryindex[dir]); }
   inline int externalboundaries(const int dir) { return (bndryindex[dir]); }
   inline const BBoxList* externalbndrylist(const int dir) const { return (bndrybboxlist[dir]); }
   inline BBoxList* externalbndrylist(const int dir) { return (bndrybboxlist[dir]); }

   inline int has_adaptiveboundaries() const { 
     for (register int r=0; r<2*dim; r++) 
       if (prolongflag[r]==DAGHTrue) return 1; 
     return 0; 
   }
   inline int has_adaptiveboundary(const int dir) const { return (prolongflag[dir]==DAGHTrue); }
   inline const BBox& adaptivebndrybox(const int dir) const { return (prolongbbox[dir]); }

   void gdbPrintData(std::ostream& os) const;
   int MemoryUsage();
   /**********************************************************************/

   /**************************************************************/
   /* Data access */
   /**************************************************************/
public:
   GridData<Type,dim> &griddata() { return (data); }
   const GridData<Type,dim> &griddata() const { return (data); }
   /**********************************************************************/

   friend std::ostream& operator<< <>(std::ostream&,
                                      const GridDataBlock<Type,dim>&);
   friend std::ofstream& operator<< <>(std::ofstream&,
                                       const GridDataBlock<Type,dim>&);
   friend std::ifstream& operator>> <>(std::ifstream&,
                                       GridDataBlock<Type,dim>&);
   friend std::stringstream& operator<< <>(std::stringstream&,
                                            const GridDataBlock<Type,dim>&);
   friend std::stringstream& operator>> <>(std::stringstream&,
                                           GridDataBlock<Type,dim>&);  

  };

#include "GridDataBlock.ipp"

#endif

---