LCOV - code coverage report
Current view: top level - geom/cgm - RefVertex.hpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 8 8 100.0 %
Date: 2020-06-30 00:58:45 Functions: 5 5 100.0 %
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : #ifndef REF_VERTEX_HPP
       2                 :            : #define REF_VERTEX_HPP
       3                 :            : 
       4                 :            : #include "BasicTopologyEntity.hpp"
       5                 :            : 
       6                 :            : class RefVolume;
       7                 :            : class RefFace;
       8                 :            : class TBPoint;
       9                 :            : 
      10                 :            : class CUBIT_GEOM_EXPORT RefVertex : public BasicTopologyEntity
      11                 :            : {
      12                 :            : public :
      13                 :            : 
      14                 :            :   typedef RefEdge ParentType;
      15                 :            :   
      16                 :            :   friend class RefEntityFactory;
      17                 :            :     //- the factory is allowed to call the (private) constructors
      18                 :            : 
      19                 :            :   virtual ~RefVertex() ;
      20                 :            :     //- The destructor
      21                 :            : 
      22                 :       1360 :   static const char* get_class_name()
      23                 :            :      {
      24                 :       1360 :        return "Vertex";
      25                 :            :      }
      26                 :            : 
      27                 :       1360 :   virtual const char* class_name() const
      28                 :            :      {
      29                 :       1360 :        return get_class_name();
      30                 :            :      }
      31                 :            :   
      32                 :     305890 :   DagType dag_type() const { return DagType::ref_vertex_type(); }
      33                 :       2298 :   const std::type_info& entity_type_info() const { return typeid(RefVertex); }
      34                 :            :   
      35                 :            :   TBPoint* get_point_ptr() ;
      36                 :            :   TBPoint const* get_point_ptr() const ;
      37                 :            :     //R TBPoint*
      38                 :            :     //R- A pointer to the TBPoint to which the current 
      39                 :            :     //R- vertex points. 
      40                 :            :     //- This function returns a pointer to the TBPoint
      41                 :            :     //- which the current vertex points to.
      42                 :            : 
      43                 :            :   CubitVector coordinates () const;
      44                 :            :     //R CubitVector
      45                 :            :     //R- Contains the coordinate values {x y z} of this RefVertex
      46                 :            :     //- Returns the spatial coordinates of this RefVertex.
      47                 :            : 
      48                 :            :   virtual CubitVector center_point();
      49                 :            :     //- Return the "center" of this RefVertex (its coordinates)
      50                 :            : 
      51                 :      94722 :   virtual int dimension() const
      52                 :      94722 :       { return 0; }
      53                 :            :     //- returns the geometric dimension of RefVertex'es. 
      54                 :            : 
      55                 :            :   void get_parent_ref_entities(DLIList<RefEntity*>& entity_list);
      56                 :            : 
      57                 :            :    //int number_mesh_elements(int dimension = -1,
      58                 :            :    //                        ElementType type = INVALID_ELEMENT_TYPE);
      59                 :            :     //- Returns number of mesh entities owned by this geometry entity
      60                 :            :     //- of the specified dimension. If dimension == -1, the highest 
      61                 :            :     //- dimension elements are returned.
      62                 :            : 
      63                 :            :   void common_ref_edges( RefVertex *other_vertex,
      64                 :            :                          DLIList <RefEdge*> &common_ref_edges,
      65                 :            :                          RefFace *owning_face = NULL );
      66                 :            :     //- returns all the common edges between this and the other vertex.
      67                 :            :     //- It is possible for two vertices to be shared by more than
      68                 :            :     //- one refedge on a surface.  Use this function rather than
      69                 :            :     //- the next for robustness.
      70                 :            :     //- The common edges must have this vertex and other_vertex as its
      71                 :            :     //- start and end vertices.
      72                 :            : 
      73                 :            :   RefEdge *common_ref_edge(RefVertex *other_vertex, 
      74                 :            :                            RefFace *owning_face = NULL);
      75                 :            :     //- returns an edge sharing the other vertex and owned by owning_face 
      76                 :            :     //- (if non-NULL)
      77                 :            :     //- The edge must have this vertex and other_vertex as its
      78                 :            :     //- start and end vertices.
      79                 :            : 
      80                 :            :   CubitBoolean about_spatially_equal( RefVertex* ref_vertex_ptr_2,
      81                 :            :                                       double tolerance_factor = 1.0,
      82                 :            :                                       CubitBoolean notify_ref_entity =
      83                 :            :                                       CUBIT_FALSE );
      84                 :            :     //R-CUBIT_TRUE/CUBIT_FALSE
      85                 :            :     //I RefVertex*, double, CubitBoolean
      86                 :            :     //I- Second RefVertex to compare, Tolerance factor to for GEOMETRY_RESABS,
      87                 :            :     //I- and flag for notifying compared RefEntities.
      88                 :            :     //O CubitBoolean
      89                 :            :     //O- if the two vertices are spatially equal within the GEOMETRY_RESABS*
      90                 :            :     //-the tolerance_factor, then CUBIT_TRUE will be returned.  Otherwise
      91                 :            :     //-CUBIT_FALSE is returned.
      92                 :            : 
      93                 :            : protected :
      94                 :            : 
      95                 :            :   RefVertex(TBPoint* pointPtr) ;
      96                 :            :     //- Contructor: Sets up a reference vertex from a TBPoint
      97                 :            : 
      98                 :            : private :
      99                 :            : 
     100                 :            :   void initialize();
     101                 :            :     //- Initializes all member data
     102                 :            : 
     103                 :            :   RefVertex( const RefVertex& );
     104                 :            :   void operator=( const RefVertex& );
     105                 :            : 
     106                 :            : };
     107                 :            : 
     108                 :            : // ********** BEGIN HELPER CLASSES         **********
     109                 :            : // ********** END   HELPER CLASSES         **********
     110                 :            : 
     111                 :            : // ********** BEGIN INLINE FUNCTIONS       **********
     112                 :            : // ********** END INLINE FUNCTIONS         **********
     113                 :            :  
     114                 :            : // ********** BEGIN FRIEND FUNCTIONS       **********
     115                 :            : // ********** END FRIEND FUNCTIONS         **********
     116                 :            :  
     117                 :            : // ********** BEGIN EXTERN FUNCTIONS       **********
     118                 :            : // ********** END EXTERN FUNCTIONS         **********
     119                 :            : 
     120                 :            : template <> struct DLIListSorter<RefVertex*>
     121                 :            : {
     122                 :            :   bool operator()(RefVertex* a, RefVertex* b) { return a->id() < b->id(); }
     123                 :            : };
     124                 :            : 
     125                 :            : #endif
     126                 :            : 

Generated by: LCOV version 1.11