---

AMRData.h

Go to the documentation of this file.

/*
   compiling instructions:   cc -o AMRData.o AMRData.c
   pretty simple.  Straight ANSI C  add whatever optimizations work good for
   your compiler.
*/

/* multi-include guard */
#ifndef AMRdata_h
#define AMRdata_h


/* AMR - CCA Forum interface proposal.  V 0.5  */
/* Follows MPI-ish naming convention */

/*
  exception handling ?   we could have an error handler be
  registered, so C++ people or others can choose to raise
  exceptions on error.  not critical though, in my opinion.
  In the absence of an error handler, we can just abort.
  or do the HDF5 and MPI thing of returning an error code.
  
  In practice, I have found that I prefer the code to DIE
  when an error occurs, which lets me send the debugger
  right to where the process went wrong.  bailing with an
  error code or exception handle or handler function makes
  debugging just too bothersome.  The code manages to "get away"
  from where the problem occured.  

  This touches on an old argument I have been making for years:
  exception handling only makes any sense in an environment where
  exceptions can be handled and there is some logical meaning to
  "continuing".  In Scientific computing codes, I have never
  encountered this paradigm done successfully.  Science is reproducible
  and excpetions are, by definition, exceptional behaviour.

*/
/* Keep C++ compilers from getting confused */
#if defined(__cplusplus)
#define CONST const
extern "C" {
#else
#define CONST
#endif


  /* ========= Client side functions ======================*/

void AMR_Create(int MPI_communicator,
                int components,
                int dimension,
                int centering,
                int type,
                int ordering,
                int* levelhandle);
/* how to handle the situation where MPI_Comm exists or not ? 
   many people compile and use AMR packages without MPI on their
   system.  Perhaps different ways of compiling it ?  I've
   given my proposal here. */


void AMR_AddPatchInt(   int levelhandle, 
                        CONST int* loRange, CONST int* hiRange,
                        CONST int* loValid, CONST int* hiValid,
                        CONST int* dataPtr);

void AMR_AddPatchFloat( int levelhandle, 
                        CONST int* loRange, CONST int* hiRange,
                        CONST int* loValid, CONST int* hiValid,
                        CONST float* dataPtr);

void AMR_AddPatchDouble(int levelhandle, 
                        CONST int* loRange, CONST int* hiRange,
                        CONST int* loValid, CONST int* hiValid,
                        CONST double* dataPtr);

void AMR_AddPatchLong(  int levelhandle, 
                        CONST int* loRange, CONST int* hiRange,
                        CONST int* loValid, CONST int* hiValid,
                        CONST long* dataPtr);

void AMR_Close(int levelhandle);

void AMR_Delete(int levelhandle);


  /* ============ Server side functions =====================*/

void AMR_GetInfo(int levelhandle,
                 int* MPI_communicator,
                 int* nComponents,
                 int* dimension,
                 int* centering,
                 int* type,
                 int* ordering,
                 int* localcount);


void AMR_GetPatchInfo(   int levelhandle, int patch,
                         int* loRange, int* hiRange,
                         int* loValid, int* hiValid);

void AMR_GetPatchInt(    int levelhandle, int patch, int**    dataPtr);
void AMR_GetPatchFloat(  int levelhandle, int patch, float**  dataPtr);
void AMR_GetPatchDouble( int levelhandle, int patch, double** dataPtr);
void AMR_GetPatchLong(   int levelhandle, int patch, long**   dataPtr);



  /*============Fortran friendly bindings for these functions=========*/

void amrcreate_(int* MPI_communicator,
                int* components,
                int* dimension,
                int* centering,
                int* type,
                int* ordering,
                int* levelhandle);

void amraddpatchint_(   int* levelhandle, 
                       int* loRange,  int* hiRange,
                         int* loValid,  int* hiValid,
                         int* dataPtr);

void amraddpatchfloat_( int* levelhandle, 
                         int* loRange,  int* hiRange,
                         int* loValid,  int* hiValid,
                         float* dataPtr);


void amraddpatchdouble_(int* levelhandle, 
                         int* loRange,  int* hiRange,
                         int* loValid,  int* hiValid,
                         double* dataPtr);


void amraddpatchlong_(  int* levelhandle, 
                         int* loRange,  int* hiRange,
                         int* loValid,  int* hiValid,
                         long* dataPtr);


void amrclose_(int* levelhandle);


void amrdelete_(int* levelhandle);




void amrgetinfo_(int* levelhandle,
                 int*  MPI_communicator,
                 int*  nComponents,
                 int*  dimension,
                 int*  centering,
                 int*  type,
                 int*  ordering,
                 int*  localcount);

void amrgetpatchinfo_(   int* levelhandle, int* patch,
                         int*  loRange, int*  hiRange,
                         int*  loValid, int*  hiValid);

void amrgetpatchint_(    int* levelhandle, int* patch, int*    data);
void amrgetpatchfloat_(  int* levelhandle, int* patch, float*  data);
void amrgetpatchdouble_( int* levelhandle, int* patch, double* data);
void amrgetpatchlong_(   int* levelhandle, int* patch, long*   data);

  /*
error handling functions.  These are optional.  can override
the function called on error conditions.  Thus a user can
protect stderr output, or raise an exception in their own
system.  default handler prints message to stderr and
calls abort()
  */
void AMR_setErrorHandler(void (*e)(char*));

void (*AMR_getErrorHandler())(char*);

#if defined(__cplusplus)
}
#endif



#endif

---