RefVertex.hpp

Go to the documentation of this file.

#ifndef REF_VERTEX_HPP
#define REF_VERTEX_HPP

#include "BasicTopologyEntity.hpp"

class RefVolume;
class RefFace;
class TBPoint;

class CUBIT_GEOM_EXPORT RefVertex : public BasicTopologyEntity
{
public :

  typedef RefEdge ParentType;
  
  friend class RefEntityFactory;
    //- the factory is allowed to call the (private) constructors

  virtual ~RefVertex() ;
    //- The destructor

  static const char* get_class_name()
     {
       return "Vertex";
     }

  virtual const char* class_name() const
     {
       return get_class_name();
     }
  
  DagType dag_type() const { return DagType::ref_vertex_type(); }
  const std::type_info& entity_type_info() const { return typeid(RefVertex); }
  
  TBPoint* get_point_ptr() ;
  TBPoint const* get_point_ptr() const ;
    //R TBPoint*
    //R- A pointer to the TBPoint to which the current 
    //R- vertex points. 
    //- This function returns a pointer to the TBPoint
    //- which the current vertex points to.

  CubitVector coordinates () const;
    //R CubitVector
    //R- Contains the coordinate values {x y z} of this RefVertex
    //- Returns the spatial coordinates of this RefVertex.

  virtual CubitVector center_point();
    //- Return the "center" of this RefVertex (its coordinates)

  virtual int dimension() const
      { return 0; }
    //- returns the geometric dimension of RefVertex'es. 

  void get_parent_ref_entities(DLIList<RefEntity*>& entity_list);

   //int number_mesh_elements(int dimension = -1,
   //                        ElementType type = INVALID_ELEMENT_TYPE);
    //- Returns number of mesh entities owned by this geometry entity
    //- of the specified dimension. If dimension == -1, the highest 
    //- dimension elements are returned.

  void common_ref_edges( RefVertex *other_vertex,
                         DLIList <RefEdge*> &common_ref_edges,
                         RefFace *owning_face = NULL );
    //- returns all the common edges between this and the other vertex.
    //- It is possible for two vertices to be shared by more than
    //- one refedge on a surface.  Use this function rather than
    //- the next for robustness.
    //- The common edges must have this vertex and other_vertex as its
    //- start and end vertices.

  RefEdge *common_ref_edge(RefVertex *other_vertex, 
                           RefFace *owning_face = NULL);
    //- returns an edge sharing the other vertex and owned by owning_face 
    //- (if non-NULL)
    //- The edge must have this vertex and other_vertex as its
    //- start and end vertices.

  CubitBoolean about_spatially_equal( RefVertex* ref_vertex_ptr_2,
                                      double tolerance_factor = 1.0,
                                      CubitBoolean notify_ref_entity =
                                      CUBIT_FALSE );
    //R-CUBIT_TRUE/CUBIT_FALSE
    //I RefVertex*, double, CubitBoolean
    //I- Second RefVertex to compare, Tolerance factor to for GEOMETRY_RESABS,
    //I- and flag for notifying compared RefEntities.
    //O CubitBoolean
    //O- if the two vertices are spatially equal within the GEOMETRY_RESABS*
    //-the tolerance_factor, then CUBIT_TRUE will be returned.  Otherwise
    //-CUBIT_FALSE is returned.

protected :

  RefVertex(TBPoint* pointPtr) ;
    //- Contructor: Sets up a reference vertex from a TBPoint

private :

  void initialize();
    //- Initializes all member data

  RefVertex( const RefVertex& );
  void operator=( const RefVertex& );

};

// ********** BEGIN HELPER CLASSES         **********
// ********** END   HELPER CLASSES         **********

// ********** BEGIN INLINE FUNCTIONS       **********
// ********** END INLINE FUNCTIONS         **********
 
// ********** BEGIN FRIEND FUNCTIONS       **********
// ********** END FRIEND FUNCTIONS         **********
 
// ********** BEGIN EXTERN FUNCTIONS       **********
// ********** END EXTERN FUNCTIONS         **********

template <> struct DLIListSorter<RefVertex*>
{
  bool operator()(RefVertex* a, RefVertex* b) { return a->id() < b->id(); }
};

#endif