Tree.hpp

Go to the documentation of this file.

#ifndef MOAB_TREE_HPP
#define MOAB_TREE_HPP

#include "moab/Interface.hpp"
#include "moab/BoundBox.hpp"
#include "moab/CartVect.hpp"
#include "moab/FileOptions.hpp"
#include "moab/TreeStats.hpp"

#include <string>
#include <vector>
#include <math.h>
#include <assert.h>

namespace moab {

    class Interface;
    class Range;
    class ElemEvaluator;

    class Tree
    {
  public:
      Tree(Interface* iface);

      virtual ~Tree();

      virtual ErrorCode reset_tree() = 0;

      ErrorCode delete_tree_sets();
      
      virtual ErrorCode build_tree(const Range& entities,
                                   EntityHandle *tree_root_set = NULL,
                                   FileOptions *options = NULL) = 0;

      virtual ErrorCode get_bounding_box(BoundBox &box, EntityHandle *tree_node = NULL) const;
  
      virtual ErrorCode get_info(EntityHandle root,
                                 double min[3], double max[3], 
                                 unsigned int &max_dep);
  
      ErrorCode find_all_trees( Range& results );
      
      virtual ErrorCode point_search(const double *point,
                                     EntityHandle& leaf_out,
                                     const double iter_tol = 1.0e-10,
                                     const double inside_tol = 1.0e-6,
                                     bool *multiple_leaves = NULL,
                                     EntityHandle *start_node = NULL,
                                     CartVect *params = NULL) = 0;

      virtual ErrorCode distance_search(const double *point,
                                        const double distance,
                                        std::vector<EntityHandle>& leaves_out,
                                        const double iter_tol = 1.0e-10,
                                        const double inside_tol = 1.0e-6,
                                        std::vector<double> *dists_out = NULL,
                                        std::vector<CartVect> *params_out = NULL,
                                        EntityHandle *start_node = NULL) = 0;

      Interface* moab() { return mbImpl; }

      const Interface* moab() const { return mbImpl; }

      double get_max_depth() {return maxDepth;}
      
      double get_max_per_leaf() {return maxPerLeaf;}

      TreeStats &tree_stats() {return treeStats;}
      
      const TreeStats &tree_stats() const {return treeStats;}
      
      ErrorCode create_root( const double box_min[3], const double box_max[3],
                             EntityHandle& root_handle);
      
      virtual ErrorCode print() = 0;
      
      inline ElemEvaluator *get_eval() {return myEval;}
      
      inline void set_eval(ElemEvaluator *eval) {myEval = eval;}
      
      virtual ErrorCode parse_options(FileOptions &opts) = 0;

  protected:

      ErrorCode parse_common_options(FileOptions &options);

      Tag get_box_tag(bool create_if_missing = true);

        // moab instance
      Interface *mbImpl;

        // bounding box for entire tree
      BoundBox boundBox;
      
        // max entities per leaf
      int maxPerLeaf;
      
        // max depth of tree
      int maxDepth;
      
        // tree depth, set by build_tree
      int treeDepth;
      
        // min width of box, handled like tolerance
      double minWidth;

        // meshset creation flags
      unsigned int meshsetFlags;

        // clean up flag
      bool cleanUp;

        // tree root
      EntityHandle myRoot;

        // tag used to mark bounding box of nodes
      Tag boxTag;

        // tag name used for boxTag
      std::string boxTagName;

        // tree traversal stats
      TreeStats treeStats;

        // element evaluator
      ElemEvaluator *myEval;
    };

    inline Tree::Tree(Interface* iface) 
            : mbImpl(iface), maxPerLeaf(6), maxDepth(30), treeDepth(-1), minWidth(1.0e-10),
              meshsetFlags(0), cleanUp(true), myRoot(0), boxTag(0), myEval(0)
    {}

    inline Tree::~Tree() 
    {
    }
    
    inline ErrorCode Tree::get_bounding_box(BoundBox &box, EntityHandle *tree_node) const
    {
      if ((tree_node && *tree_node == myRoot) || !tree_node) {
        box = boundBox;
        return MB_SUCCESS;
      }
      else return MB_FAILURE;
    }
  
    inline ErrorCode Tree::get_info(EntityHandle /* root */,
                                    double * /*min[3]*/, double * /* max[3]*/, 
                                    unsigned int &/*dep*/) 
    {
      return MB_NOT_IMPLEMENTED;
    }

    inline Tag Tree::get_box_tag(bool create_if_missing) 
    {
      if (!boxTag && create_if_missing) {
        assert(boxTagName.length() > 0);
        ErrorCode rval = moab()->tag_get_handle(boxTagName.c_str(), 6, MB_TYPE_DOUBLE, boxTag, MB_TAG_CREAT | MB_TAG_SPARSE);
        if (MB_INVALID_SIZE == rval) {
            // delete the tag and get it again, legacy file...
          rval = moab()->tag_delete(boxTag);
          if (MB_SUCCESS != rval) return 0;
          boxTag = 0;
          return get_box_tag(true);
        }
        
        if (MB_SUCCESS != rval) return 0;
      }
      
      return boxTag;
    }
    
} // namespace moab 

#endif