GridHierarchyCalls.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef _included_GridHierarchyCalls_h
#define _included_GridHierarchyCalls_h

/*************************************************************************/
/* Setup DAGH */
/*************************************************************************/

inline void SetBaseGrid(GridHierarchy &GH, double const *bbox, int const *shape, 
                        const int& ncuts, const int *cuts)      
  { GH.DAGH_SetBaseGrid(bbox, shape, ncuts, cuts); }
inline void SetTimeSpecs(GridHierarchy &GH, double const starttime, 
                        double const stoptime, int const numtsteps)
  { GH.DAGH_SetTimeSpecs(starttime,stoptime,numtsteps); }

inline void SetBoundaryType(GridHierarchy &GH, int const type)
  { GH.DAGH_SetBoundaryType(type); }
inline void SetAdaptBoundaryType(GridHierarchy &GH, int const type)
  { GH.DAGH_SetAdaptBoundaryType(type); }
inline void SetBoundaryWidth(GridHierarchy &GH, int const width)
  { GH.DAGH_SetBoundaryWidth(width); }
inline void SetPeriodicBoundaries(GridHierarchy &GH, int const dir, int const value)
  { GH.DAGH_SetPeriodicBoundaries(dir,value); }

inline void SetExternalGhostWidth(GridHierarchy &GH, int const width)
  { GH.DAGH_SetExternalGhostWidth(width); }

inline void SetRefineFactor(GridHierarchy &GH, int const rfactor)
  { GH.DAGH_SetRefineFactor(rfactor); }
inline void SetRefineFactor(GridHierarchy &GH, int const lev, int const rfactor)
  { GH.DAGH_SetRefineFactor(lev,rfactor); }

inline void SetDistributionType(GridHierarchy &GH, int const type)
   { GH.DAGH_SetDistributionType(type); }

inline void SetDistributionType(GridHierarchy &GH, int const type, BBoxList& bbl)
   { GH.DAGH_SetDistributionType(type,bbl); }

inline void SetWorkFunction(GridHierarchy &GH, void *wf)
   { GH.DAGH_SetWorkFunction(wf); }

inline void ComposeHierarchy(GridHierarchy &GH)
  { GH.DAGH_ComposeHierarchy(); }

inline void ComposeGridFunctions(GridHierarchy &GH)
  { GH.DAGH_ComposeGridFunctions(); }

inline int GridFunctionTemplate(GridHierarchy& GH, GridFunctionVoid& GFV)
  { return (GH.DAGH_GridFunctionTemplate(GFV)); }

/*************************************************************************/
/* Queries */
/*************************************************************************/
inline void SetCurrentTime(GridHierarchy &GH, int const ctime, int const lev)
  { GH.setCurrentTime(ctime, lev); }
inline int CurrentTime(GridHierarchy &GH, int const lev)
  { return (GH.getCurrentTime(lev)); }
inline void IncrCurrentTime(GridHierarchy &GH, int const lev)
  { GH.incrCurrentTime(lev); }

inline int StepSize(GridHierarchy &GH, int const lev)
  { return (GH.stepsize(lev)); }

inline int TimeStep(GridHierarchy &GH, int const lev)
  { return (GH.timestep(lev)); }

inline int AbsStepsTaken(GridHierarchy &GH, int const lev)
  { return (GH.stepstaken(GH.getCurrentTime(lev)+GH.timestep(lev),lev)); }
inline int StepsTaken(GridHierarchy &GH, int const lev)
  { return (GH.stepstaken(GH.getCurrentTime(lev),lev)); }

inline int RefineFactor(GridHierarchy &GH, int const lev)
  { return (GH.refinefactor(lev)); }
inline int RefinedBy(GridHierarchy &GH, int const lev)
  { return (GH.refinedby(lev)); }

inline int TotalLevels(GridHierarchy &GH)
  { return (GH.totallevels()); }
inline int MaxLevel(GridHierarchy &GH)
  { return (GH.maxlevel()); }
inline int CoarseLevel(GridHierarchy &GH)
  { return (GH.coarselevel()); }
inline int FineLevel(GridHierarchy &GH)
  { return (GH.finelevel()); }

inline double DeltaT(GridHierarchy &GH, int const level)
  { return (GH.delta_t(level)); }
inline double DeltaX(GridHierarchy &GH, int const dim, int const level)
  { return (GH.delta_x(dim,level)); }

/*************************************************************************/
/* Coarsening factor used when constructing GridUnits on level 0 */
/*************************************************************************/
inline const int& GuCFactor(GridHierarchy &GH)
  { return (GH.gucfactor()); }
inline void SetGuCFactor(GridHierarchy &GH, const int& cfac)
  { GH.setgucfactor(cfac); }

/*************************************************************************/
/* Maximal GridBox Size. Allows machine-dependent patch-size adjustment  */
/*************************************************************************/
inline const int& MaxGridBoxSize(GridHierarchy &GH)
  { return (GH.maxGridBoxSize()); }
inline void SetMaxGridBoxSize(GridHierarchy &GH, const int& gbsize)
  { GH.setmaxGridBoxSize(gbsize); }

/*************************************************************************/
/* Set/Query Updated Timestep Info */
/*************************************************************************/
inline int UpdatedValueAt(GridHierarchy &GH) { return (GH.updatedvaluestep()); }
inline void SetUpdatedValueStep(GridHierarchy &GH, const int ustep) 
  { GH.setupdatedvaluestep(ustep); }

/*************************************************************************/
/* Refine & Recompose */
/*************************************************************************/
inline void Refine(GridHierarchy &GH, int const lev)
  { GH.DAGH_Refine(lev); }

inline void Refine(GridHierarchy &GH, BBoxList &bblist, int const lev)
  { GH.DAGH_Refine(bblist, lev); }

inline void RecomposeHierarchy(GridHierarchy &GH)
  { GH.DAGH_RecomposeHierarchy(); }

inline void RecomposeHierarchy(GridHierarchy &GH, int Partition)
  { GH.DAGH_RecomposeHierarchy(Partition); }


/*************************************************************************/
/* Redistribution */
/*************************************************************************/
inline void RedistributeHierarchy(GridHierarchy &GH, const int type)
        { GH.DAGH_RedistributeHierarchy(type); }
inline void RedistributeHierarchy(GridHierarchy &GH, const int type, BBoxList& bbl)
        { GH.DAGH_RedistributeHierarchy(type, bbl); }

/*************************************************************************/
/* Checkpoint */
/*************************************************************************/
inline void Checkpoint(GridHierarchy &GH, const char* name)
  { GH.DAGH_Checkpoint(name); }

inline void ComposeHierarchy(GridHierarchy &GH, 
                             const char* name)
  { GH.DAGH_ComposeHierarchy(name); }

inline bool RecomposeHierarchy(GridHierarchy &GH, 
                               const char* name)
  { return GH.DAGH_RecomposeHierarchy(name); }

/*************************************************************************/
/* Ghost communications */
/*************************************************************************/
inline void Sync(GridHierarchy &GH, int const t, int const l)
  { GH.DAGH_SyncGhostRegions(t, l); }
inline void Sync(GridHierarchy &GH, int const t, int const l,
                 int const axis, int const dir)
  { GH.DAGH_SyncGhostRegions(t, l, axis, dir); }

/*************************************************************************/
/* DAGH IO support */
/*************************************************************************/
inline void DAGHSetIOType(GridHierarchy &GH, short const type)
  { GH.DAGH_SetIOType(type); }
inline const short& DAGHIOType(GridHierarchy &GH)
  { return GH.DAGH_IOType(); }
inline DAGHIO_WriteFunc DAGHIOWrite(GridHierarchy &GH) 
  { return GH.DAGH_IOWrite(); }
inline DAGHIO_ReadFunc DAGHIORead(GridHierarchy &GH) 
  { return GH.DAGH_IORead(); }
inline void DAGHIOFlush(GridHierarchy &GH)
  { GH.DAGH_IOFlush(); }
inline void DAGHIOClose(GridHierarchy &GH)
  { GH.DAGH_IOClose(); }
inline void DAGHIOEnd(GridHierarchy &GH)
  { GH.DAGH_IOEnd(); }

#endif

---