DualTool.hpp

Go to the documentation of this file.

#ifndef MOAB_DUAL_TOOL_HPP
#define MOAB_DUAL_TOOL_HPP

#include "moab/Forward.hpp"

namespace moab {

class DualTool
{
public:
  static const char *DUAL_SURFACE_TAG_NAME;

  static const char *DUAL_CURVE_TAG_NAME;

  static const char *IS_DUAL_CELL_TAG_NAME;

  static const char *DUAL_ENTITY_TAG_NAME;

  static const char *EXTRA_DUAL_ENTITY_TAG_NAME;

  static const char *DUAL_GRAPHICS_POINT_TAG_NAME;

  class GraphicsPoint 
  {
  public:
    GraphicsPoint() 
      {xyz[0] = 0.0; xyz[1] = 0.0; xyz[2] = 0.0; id = -1;}

    GraphicsPoint(float xi, float yi, float zi, int idi) 
      {xyz[0] = xi; xyz[1] = yi; xyz[2] = zi; id = idi;}

    GraphicsPoint(float xyzi[3], int idi)
      {xyz[0] = xyzi[0]; xyz[1] = xyzi[1]; xyz[2] = xyzi[2]; id = idi;}

    GraphicsPoint(double xyzi[3], int idi)
      {xyz[0] = xyzi[0]; xyz[1] = xyzi[1]; xyz[2] = xyzi[2]; id = idi;}

    GraphicsPoint(const GraphicsPoint &gp) 
      {xyz[0] = gp.xyz[0]; xyz[1] = gp.xyz[1]; xyz[2] = gp.xyz[2]; id = gp.id;}
    
    float xyz[3];
    int id;
  };
  
  DualTool(Interface *impl);
  
  ~DualTool();

  ErrorCode construct_dual(EntityHandle *entities, 
                             const int num_entities);
  
  ErrorCode construct_hex_dual(EntityHandle *entities,
                                 const int num_entities);
  
  ErrorCode construct_hex_dual(Range &entities);
  
  ErrorCode get_dual_entities(const int dim, 
                                EntityHandle *entities, 
                                const int num_entities, 
                                Range &dual_ents);
  
  ErrorCode get_dual_entities(const int dim, 
                                EntityHandle *entities, 
                                const int num_entities, 
                                std::vector<EntityHandle> &dual_ents);

  EntityHandle get_dual_entity(const EntityHandle this_ent) const;
  
  EntityHandle get_extra_dual_entity(const EntityHandle this_ent);
  
  static ErrorCode get_dual_hyperplanes(const Interface *impl, const int dim, 
                                          Range &dual_ents);

  ErrorCode get_graphics_points(EntityHandle dual_ent,
                                  std::vector<int> &npts,
                                  std::vector<GraphicsPoint> &gpoints);
  
  ErrorCode get_graphics_points(const Range &in_range,
                                  std::vector<GraphicsPoint> &gpoints,
                                  const bool assign_ids = false,
                                  const int start_id = 0);
  
  EntityHandle next_loop_vertex(const EntityHandle last_v,
                                  const EntityHandle this_v,
                                  const EntityHandle dual_surf);
  
  Tag dualSurface_tag() const;
  ErrorCode dualSurface_tag(const Tag tag);
  
  Tag dualCurve_tag() const;
  ErrorCode dualCurve_tag(const Tag tag);

  Tag isDualCell_tag() const;
  ErrorCode isDualCell_tag(const Tag tag);

  Tag dualEntity_tag() const;
  ErrorCode dualEntity_tag(const Tag tag);

  Tag extraDualEntity_tag() const;
  ErrorCode extraDualEntity_tag(const Tag tag);

  Tag dualGraphicsPoint_tag() const;
  ErrorCode dualGraphicsPoint_tag(const Tag tag);

  Tag globalId_tag() const;
  ErrorCode globalId_tag(const Tag tag);

  EntityHandle get_dual_hyperplane(const EntityHandle ncell);

  bool is_blind(const EntityHandle chord);
  
  ErrorCode set_dual_surface_or_curve(EntityHandle entity, 
                                        const EntityHandle dual_hyperplane,
                                        const int dimension);
  
  ErrorCode atomic_pillow(EntityHandle odedge, EntityHandle &quad1,
                            EntityHandle &quad2);

  ErrorCode rev_atomic_pillow(EntityHandle pillow, Range &chords);

  ErrorCode face_shrink(EntityHandle odedge);
  
  ErrorCode rev_face_shrink(EntityHandle edge);
  
  ErrorCode face_open_collapse(EntityHandle ocl, EntityHandle ocr);

  ErrorCode foc_get_ents(EntityHandle ocl, 
                           EntityHandle ocr, 
                           EntityHandle *quads, 
                           EntityHandle *split_edges, 
                           EntityHandle *split_nodes, 
                           Range &hexes, 
                           EntityHandle *other_edges, 
                           EntityHandle *other_nodes);
  
  ErrorCode get_opposite_verts(const EntityHandle middle_edge, 
                                 const EntityHandle chord, 
                                 EntityHandle *verts);

  ErrorCode get_dual_entities(const EntityHandle dual_ent,
                                Range *dcells,
                                Range *dedges,
                                Range *dverts,
                                Range *dverts_loop,
                                Range *dedges_loop);
  
  ErrorCode list_entities(const Range &entities) const;
  ErrorCode list_entities(const EntityHandle *entities,
                            const int num_entities) const;
  
  ErrorCode delete_whole_dual();
  
  ErrorCode check_dual_adjs();

private:

  ErrorCode construct_dual_vertices(const Range &all_regions,
                                      Range &new_dual_ents);
  
  ErrorCode construct_dual_edges(const Range &all_faces,
                                      Range &new_dual_ents);
  
  ErrorCode construct_dual_faces(const Range &all_edges,
                                      Range &new_dual_ents);
  
  ErrorCode construct_dual_cells(const Range &all_verts,
                                   Range &new_dual_ents);
  
  ErrorCode construct_dual_hyperplanes(const int dim, 
                                         EntityHandle *entities, 
                                         const int num_entities);

  ErrorCode order_chord(EntityHandle chord_set);
  
  ErrorCode construct_new_hyperplane(const int dim, EntityHandle &new_hyperplane,
                                       int &id);
  
  ErrorCode traverse_hyperplane(const Tag hp_tag, 
                                  EntityHandle &this_hp, 
                                  EntityHandle this_ent);
  
  ErrorCode construct_hp_parent_child();
  
  ErrorCode get_radial_dverts(const EntityHandle edge,
                                std::vector<EntityHandle> &rad_verts,
                                bool &bdy_edge);
  
  ErrorCode construct_dual_vertex(EntityHandle entity, 
                                    EntityHandle &dual_ent, 
                                    const bool extra = false,
                                    const bool add_graphics_pt = true);

  ErrorCode add_graphics_point(EntityHandle entity,
                                 double *avg_pos = NULL);
  
  ErrorCode get_cell_points(EntityHandle dual_ent,
                              std::vector<int> &npts,
                              std::vector<GraphicsPoint> &points);

  bool check_1d_loop_edge(EntityHandle this_ent);
  
  ErrorCode check_dual_equiv_edges(Range &dual_edges);
  
  ErrorCode delete_dual_entities(EntityHandle *entities, const int num_entities);

  ErrorCode delete_dual_entities(Range &entities);
  
  ErrorCode fs_check_quad_sense(EntityHandle hex0,
                                  EntityHandle quad0,
                                  std::vector<EntityHandle> *connects);
  
  ErrorCode fs_get_quads(EntityHandle odedge, 
                           EntityHandle *quads,
                           EntityHandle *hexes,
                           std::vector<EntityHandle> *connects);
  
  ErrorCode  fs_get_quad_loops(EntityHandle *hexes, 
                                 std::vector<EntityHandle> *connects, 
                                 std::vector<EntityHandle> *side_quads);
  
  ErrorCode fsr_get_fourth_quad(std::vector<EntityHandle> *connects,
                                  std::vector<EntityHandle> *side_quads);

/*  
  ErrorCode foc_get_merge_ents(EntityHandle *quads, EntityHandle *new_quads, 
                                 Range &edge, Range &new_edge,
                                 std::vector<EntityHandle> &merge_ents);
*/

  ErrorCode foc_delete_dual(EntityHandle *split_quads,
                              EntityHandle *split_edges,
                              Range &hexes);

  ErrorCode split_pair_nonmanifold(EntityHandle *split_quads,
                                     EntityHandle *split_edges,
                                     EntityHandle *split_nodes,
                                     std::vector<EntityHandle> *star_dp1,
                                     std::vector<EntityHandle> *star_dp2,
                                     EntityHandle *other_edges,
                                     EntityHandle *other_nodes,
                                     EntityHandle *new_quads,
                                     EntityHandle *new_edges,
                                     EntityHandle *new_nodes);
  
  ErrorCode foc_get_addl_ents(std::vector<EntityHandle> *star_dp1, 
                                std::vector<EntityHandle> *star_dp2, 
                                EntityHandle *split_edges,
                                EntityHandle split_node,
                                Range *addl_ents);
  
  ErrorCode foc_get_stars(EntityHandle *split_quads,
                            EntityHandle *split_edges,
                            std::vector<EntityHandle> *star_dp1,
                            std::vector<EntityHandle> *star_dp2);
  
  void print_cell(EntityHandle cell);
  
  Interface *mbImpl;

  enum
  {
    GP_SIZE=20
  };
  
  Tag dualCurveTag;
  Tag dualSurfaceTag;
  Tag isDualCellTag;
  Tag dualEntityTag;
  Tag extraDualEntityTag;
  Tag dualGraphicsPointTag;
  Tag categoryTag;
  Tag globalIdTag;

  int maxHexId;
};

inline Tag DualTool::dualSurface_tag() const
{
  return dualSurfaceTag;
}

inline Tag DualTool::dualCurve_tag() const
{
  return dualCurveTag;
}

inline Tag DualTool::isDualCell_tag() const
{
  return isDualCellTag;
}

inline Tag DualTool::dualEntity_tag() const
{
  return dualEntityTag;
}

inline Tag DualTool::extraDualEntity_tag() const
{
  return extraDualEntityTag;
}

inline Tag DualTool::dualGraphicsPoint_tag() const
{
  return dualGraphicsPointTag;
}

inline Tag DualTool::globalId_tag() const
{
  return globalIdTag;
}

inline ErrorCode DualTool::dualSurface_tag(const Tag tag) 
{
  ErrorCode result = MB_FAILURE;
  if ((0 == dualSurfaceTag && tag) || dualSurfaceTag != tag) {
    dualSurfaceTag = tag;
    result = MB_SUCCESS;
  }
  
  return result;
}
  
inline ErrorCode DualTool::dualCurve_tag(const Tag tag)
{
  ErrorCode result = MB_FAILURE;
  if ((0 == dualCurveTag && tag) || dualCurveTag != tag) {
    dualCurveTag = tag;
    result = MB_SUCCESS;
  }
  
  return result;
}
  
inline ErrorCode DualTool::isDualCell_tag(const Tag tag)
{
  ErrorCode result = MB_FAILURE;
  if ((0 == isDualCellTag && tag) || isDualCellTag != tag) {
    isDualCellTag = tag;
    result = MB_SUCCESS;
  }
  
  return result;
}
  
inline ErrorCode DualTool::dualEntity_tag(const Tag tag)
{
  ErrorCode result = MB_FAILURE;
  if ((0 == dualEntityTag && tag) || dualEntityTag != tag) {
    dualEntityTag = tag;
    result = MB_SUCCESS;
  }
  
  return result;
}
  
inline ErrorCode DualTool::extraDualEntity_tag(const Tag tag)
{
  ErrorCode result = MB_FAILURE;
  if ((0 == extraDualEntityTag && tag) || extraDualEntityTag != tag) {
    extraDualEntityTag = tag;
    result = MB_SUCCESS;
  }
  
  return result;
}
  
inline ErrorCode DualTool::dualGraphicsPoint_tag(const Tag tag)
{
  ErrorCode result = MB_FAILURE;
  if ((0 == dualGraphicsPointTag && tag) || dualGraphicsPointTag != tag) {
    dualGraphicsPointTag = tag;
    result = MB_SUCCESS;
  }
  
  return result;
}
  
inline ErrorCode DualTool::globalId_tag(const Tag tag)
{
  ErrorCode result = MB_FAILURE;
  if ((0 == globalIdTag && tag) || globalIdTag != tag) {
    globalIdTag = tag;
    result = MB_SUCCESS;
  }
  
  return result;
}

} // namespace moab 

#endif