AMRTree.h

Go to the documentation of this file.

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

#ifndef _AMRTree_h_
#define _AMRTree_h_

#include <vector>
#include <vapor/common.h>
#include <vapor/MyBase.h>
#include <vapor/EasyThreads.h>
#include <vapor/AMRTreeBranch.h>
#include <vapor/ExpatParseMgr.h>


namespace VAPoR {

//
//

class AMRTree : public VetsUtil::MyBase, public ParsedXml {

public:


 // An unique identifier for each cell in the tree
 //
 typedef AMRTreeBranch::cid_t cid_t;


 //
 AMRTree(
    const size_t basedim[3], 
    const double min[3], 
    const double max[3]
 );

 AMRTree(
    const string &path
 );

 //
 AMRTree(
    const size_t basedim[3], 
    const int paramesh_gids[][15],
    const float paramesh_bboxs [][3][2],
    const int paramesh_refine_levels[],
    int paramesh_total_blocks
 );

 //
 AMRTree();

 virtual ~AMRTree();

 //
 void   DecodeCellID(
    AMRTree::cid_t cellid,
    AMRTree::cid_t *baseblockidx,
    AMRTree::cid_t *nodeidx
 ) const;

 //
 int    DeleteCell(AMRTree::cid_t cellid);


 //
 AMRTree::cid_t FindCell(const double ucoord[3], int reflevel = -1) const;

 int    GetCellLocation(
    AMRTree::cid_t cellid, size_t xyz[3], int *reflevel
 ) const;

 AMRTree::cid_t GetCellID(const size_t xyz[3], int reflevel) const;

 //
 const size_t *GetBaseDim() const { return(_baseDim); };

 //
 const AMRTreeBranch    *GetBranch(const size_t xyz[3]) const;

 const AMRTreeBranch    *GetBranch(cid_t baseblockidx) const;

 int    GetCellBounds(  
    cid_t cellid, double minu[3], double maxu[3]
 ) const;

 //
 AMRTree::cid_t GetCellChildren(AMRTree::cid_t cellid) const;


 //
 int    GetCellLevel(AMRTree::cid_t cellid) const;



 //
 AMRTree::cid_t GetCellNeighbor(
    AMRTree::cid_t cellid, int face
 ) const;


 //
 AMRTree::cid_t GetCellParent(AMRTree::cid_t cellid) const;

 int    GetRefinementLevel(const size_t min[3], const size_t max[3]) const;

 //
 int    GetRefinementLevel() const; 

 AMRTree::cid_t GetNumCells(
    const size_t min [3], 
    const size_t max[3], 
    int reflevel = -1
 ) const;

 //
 AMRTree::cid_t GetNumCells(int reflevel = -1) const;


 AMRTree::cid_t RefineCell(AMRTree::cid_t cellid);

 void EndRefinement();

 AMRTree::cid_t GetNextCell(bool restart);


 int    MapUserToVoxel(
    int reflevel, const double ucoord[3], size_t vcoord[3]
 );

 //
 int Write(const string &path) const;

 //
 int Read(const string &path);

 int _parameshGetBaseBlocks(
    vector <int> &baseblocks,
    const size_t basedim[3],
    const int gids[][15],
    const float bboxs [][3][2],
    int totalblocks
 ) const;

private:

 cid_t _x_index;        // tree traversal index;
 int _tbits;    // # bits used to encode base cell index
 int _tbbits;   // # bits used to encode branch cell id 
 static const string _rootTag;
 static const string _minExtentsAttr;
 static const string _maxExtentsAttr;
 static const string _baseDimAttr;
 static const string _fileVersionAttr;

 int _xml_help_loc; // hack to maintains XML state info at different levels
 int _objIsInitialized;

 size_t _baseDim[3];    // Dimension of tree expressed in base blocks
 double _minBounds[3];  // Min domain extents expressed in user coordinates
 double _maxBounds[3];  // Max domain extents expressed in user coordinates


 AMRTreeBranch  **_treeBranches;    // One branch per base block;

 XmlNode    *_rootNode; // root of XML tree used to represent AMR tree 

 int _fileVersion;

 int    _AMRTree(
    const size_t basedim[3], 
    const double min[3], 
    const double max[3]
 );

 void _freeAMRTree();

 void   _encode_cellid(
    cid_t baseblockidx, cid_t nodeidx, cid_t *cellid
 ) const;

 int paramesh_refine_baseblocks(
    int index,
    int pid,
    const int gids[][15]
 );

 bool elementStartHandler(
    ExpatParseMgr*, int depth , std::string& tag, const char **attr
 );
 bool elementEndHandler(ExpatParseMgr*, int depth , std::string&);

 // XML Expat element handler helps. A different handler is defined
 // for each possible state (depth of XML tree) from 0 to 3
 //
 void _startElementHandler0(ExpatParseMgr*,const string &tag, const char **attrs);
 void _startElementHandler1(ExpatParseMgr*,const string &tag, const char **attrs);
 void _startElementHandler2(ExpatParseMgr*,const string &tag, const char **attrs);
 void _endElementHandler0(ExpatParseMgr*,const string &tag);
 void _endElementHandler1(ExpatParseMgr*,const string &tag);
 void _endElementHandler2(ExpatParseMgr*,const string &tag);



};

};

#endif  //  _AMRTree_h_