AMRData.h

Go to the documentation of this file.

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

#ifndef _AMRData_h_
#define _AMRData_h_

#include <vector>
#include <vapor/common.h>
#include <vapor/MyBase.h>
#include <vapor/AMRTree.h>


namespace VAPoR {

//
//

class AMRData : public  VetsUtil::MyBase {

public:



 //
 AMRData(
    const AMRTree *tree,
    const size_t cell_dim[3],
    const size_t bmin[3],
    const size_t bmax[3],
    int reflevel = -1
 );

 //
 AMRData(
    const AMRTree *tree,
    const size_t cell_dim[3],
    int reflevel = -1
 );

 //
 AMRData(
    const AMRTree *tree
 );

 //
 AMRData(
    const AMRTree *tree,
    const size_t cell_dim[3],
    const int paramesh_gids[][15],
    const float paramesh_bboxs [][3][2],
    const float paramesh_unk[],
    int total_blocks,
    int reflevel = -1
 );

 virtual ~AMRData() {_AMRDataFree();};

 //
 int SetRegion(
    const size_t min[3],
    const size_t max[3],
    int reflevel
 ); 

 //
 void GetRegion(
    const size_t **min,
    const size_t **max,
    int *reflevel
 ) const;

 
 void Update();

 //
 int    WriteNCDF(
    const string &path,
    int reflevel = -1
 );

 //
 int ReadNCDF(
    const string &path,
    const size_t bmin[3],
    const size_t bmax[3],
    int reflevel = -1
 );

 int ReadNCDF(
    const string &path,
    int reflevel = -1
 );

 //
 static int ReadAttributesNCDF(
    const string &path, size_t cell_dim[3], size_t bmin[3],  size_t bmax[3],
    float data_range[2], int &reflevel, size_t &num_nodes
 );


 //
 float *GetBlock(
    AMRTree::cid_t cellid
 ) const;

 int ReGrid(
    const size_t bmin[3],
    const size_t bmax[3],
    int reflevel,
    float *grid,
    const size_t dim[3]
 ) const;

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


 const AMRTree  *GetTree() const {return(_tree);};

 void GetBounds(size_t bmin[3], size_t bmax[3]) const {
    for (int i=0; i<3; i++) {bmin[i] = _bmin[i]; bmax[i] = _bmax[i];}
 }

private:

 static const string _numNodeToken;
 static const string _blockSizeXToken;
 static const string _blockSizeYToken;
 static const string _blockSizeZToken;
 static const string _varToken;
 static const string _blockMinToken;
 static const string _blockMaxToken;
 static const string _refinementLevelToken;
 static const string _scalarRangeToken;
            
 const AMRTree  *_tree;
 size_t _cellDim[3];    // Dimensions, in # samples, of each cell
 float  **_treeData;    // data for each tree branch
 int *_treeDataMemSize; // mem size allocated to treeData
 size_t _bmin[3];   // bounds of tree subregion (in base blocks)
 size_t _bmax[3];
 int _maxRefinementLevel;   // Maximum refinement level present
 float _dataRange[2];       // min and max range of data;

 void   _AMRData(
    const AMRTree *tree,
    const size_t cell_dim[3],
    const size_t min[3],
    const size_t max[3],
    int reflevel = -1
 );

 void   _AMRDataFree();

 int paramesh_copy_data(
    int index,
    int pid,
    const int paramesh_gids[][15],
    const float paramesh_unk[]
 );

 // Resample a tree branch (base block and children) to a regular 
 // Cartesian grid. x,y,z are the topological coordinates of the tree
 // branch, specified in base blocks (blocks at refinement level 0).
 // min and max specify the extents 
 // of the area to be resampled
 // in block coordinates **relative to the indicated refinement level**. 
 // The coordinate system for min and max is global, i.e. the origin is 
 // the corner of the first base block. 
 //
 void regrid_branch(
    unsigned int x, 
    unsigned int y,
    unsigned int z,
    const size_t min[3],
    const size_t max[3],
    int reflevel,
    float *grid,
    const size_t dim[3]
 ) const;

 // Resample a single cell to a regular grid. This is a help method called
 // by resample_branch. tbranch is the tree branch containing the cell to
 // be processed. 
 //
 void regrid_cell(
    const AMRTreeBranch *tbranch,
    const float *branch_data,       // data associated with tbranch
    AMRTreeBranch::cid_t cellid,    // id of cell to be resampled.
    const size_t min[3],        // same is in regrid_branch
    const size_t max[3],
    int reflevel,
    float *grid,
    const size_t dim[3]
 ) const;

};

};

#endif  //  _AMRData_h_