AMRIO.h

Go to the documentation of this file.

//
//      $Id$
//
//***********************************************************************
//                                                                      *
//                      Copyright (C)  2006                         *
//          University Corporation for Atmospheric Research             *
//                      All Rights Reserved                             *
//                                                                      *
//***********************************************************************
//
//  File:       AMRIO.h
//
//  Author:     John Clyne
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       Thu Jan 5 16:57:43 MST 2006
//
//  Description:    
//
//
#ifndef _AMRIO_h_
#define _AMRIO_h_

#include <cstdio>
#include <vapor/MyBase.h>
#include <vapor/AMRTree.h>
#include <vapor/AMRData.h>
#include <vapor/VDFIOBase.h>

namespace VAPoR {


//
//
class VDF_API   AMRIO : public VAPoR::VDFIOBase {

public:

 //
 AMRIO(
    const MetadataVDC &metadata
 );

 //
 AMRIO(
    const string &metafile
 );

 virtual ~AMRIO();

 //
 int    VariableExists(
    size_t ts,
    const char *varname,
    int reflevel = 0,
    int lod = 0
 ) const ;

 //
 int    OpenTreeWrite(
    size_t timestep
 );

 //
 int    OpenTreeRead(
    size_t timestep
 );

 //
 int    CloseTree();

 //
 int    TreeRead(AMRTree *tree);


 int    TreeWrite(const AMRTree *tree);


 int    OpenVariableWrite(
    size_t timestep,
    const char *varname,
    int reflevel = -1,
    int lod = -1
 );

 virtual int BlockWriteRegion(
    const float *region, const size_t bmin[3], const size_t bmax[3],
    bool block=true
 ) { SetErrMsg("Not implemented"); return(-1); }

 virtual int WriteRegion(
    const float *region, const size_t min[3], const size_t max[3]
 ) { SetErrMsg("Not implemented"); return(-1); }

 virtual int WriteRegion(
    const float *region
 ) { SetErrMsg("Not implemented"); return(-1); }

 virtual int WriteSlice(const float *slice)
    { SetErrMsg("Not implemented"); return(-1); }

 
 int    OpenVariableRead(
    size_t timestep,
    const char *varname,
    int reflevel = 0,
    int lod = 0
 );

 virtual int BlockReadRegion(
    const size_t bmin[3], const size_t bmax[3], float *region, bool unblock=true
 ) { SetErrMsg("Not implemented"); return(-1); }

 virtual int ReadRegion(
    const size_t min[3], const size_t max[3], float *region
 ) { SetErrMsg("Not implemented"); return(-1); }

 virtual int ReadRegion(
    float *region
 ) { SetErrMsg("Not implemented"); return(-1); }

 virtual int ReadSlice(float *slice) {
    SetErrMsg("Not implemented"); return(-1);
 }

 //
 virtual int    CloseVariable();

 //
 int    VariableRead(AMRData *data);

 int    VariableWrite(AMRData *data);


 int    GetBlockMins(const float **mins, int reflevel) const;

 int    GetBlockMaxs(const float **maxs, int reflevel) const;

 const float *GetDataRange() const {return (_dataRange);}

 void GetValidRegion(
    size_t min[3], size_t max[3], int reflevel
 ) const;


private:
 typedef int int32_t;

 static const int MAX_LEVELS = 32;  // Max # of refinement leveles permitted

 int    _reflevel;  // refinement level of currently opened file.
                        
 string _varName;       // Currently opened variable
 string _treeFileName;  // Currenly opened tree file name
 string _dataFileName;  // Currenly opened amr data file name

 int    _treeIsOpen;    // true if an AMR tree file is open
 int    _dataIsOpen;    // true if an AMR data file is open
 int    _treeWriteMode; // true if file opened for writing
 int    _dataWriteMode; // true if file opened for writing
 float  _dataRange[2];
 size_t _validRegMin[3];
 size_t _validRegMax[3];


 int _AMRIO();
 int mkpath(size_t timestep, string *path) const;
 int mkpath(size_t timestep, const char *varname, string *path) const;

};

}

#endif  //  _WavletBlock3d_h_