Branch data     Line data    Source code

       1                 :            : //-----------------------------------------------------------------------------
       2                 :            : //
       3                 :            : //  File: CubitFacetEdgeData.hpp
       4                 :            : //
       5                 :            : //  Purpose:  Child class of CubitFacetEdge.  It is the Cubit-specific version of
       6                 :            : //            of the CubitFacetEdge.
       7                 :            : //
       8                 :            : //  Notes:    Note that this class contains data which is accessed
       9                 :            : //            virtually from CubitFacetEdge.  In most cases, you can create
      10                 :            : //            a CubitFacetEdgeData and treat it as if it is a CubitFacetEdge.
      11                 :            : //            For example:
      12                 :            : //               CubitFacetEdge *cfe = (CubitFacetEdge *) new CubitFacetEdgeData(...);
      13                 :            : //            There should be no reason to reference the CubitFacetEdgeData 
      14                 :            : //            directly.  This is done to allow different data representations
      15                 :            : //            of a facet edge in addition to that used by Cubit.
      16                 :            : //                        
      17                 :            : //-----------------------------------------------------------------------------
      18                 :            : 
      19                 :            : #ifndef CUBITFACETEDGEDATA_HPP
      20                 :            : #define CUBITFACETEDGEDATA_HPP
      21                 :            : 
      22                 :            : // Include for CubitBoolean
      23                 :            : #include "CubitDefines.h"
      24                 :            : #include "CubitPoint.hpp"
      25                 :            : #include "DLIList.hpp"
      26                 :            : #include "CubitFacetEdge.hpp"
      27                 :            : 
      28                 :            : class CubitVector;
      29                 :            : class CubitFacet;
      30                 :            : class CubitPoint;
      31                 :            : 
      32                 :            : class CubitFacetEdgeData : public CubitFacetEdge
      33                 :            : {
      34                 :            : private:
      35                 :            :   CubitPoint *pointArray[2];
      36                 :            :   DLIList<CubitFacet *> adjFacetList;
      37                 :            :   int entityId;
      38                 :            :     //- for debug tracking...
      39                 :            : public:
      40                 :            :   CubitFacetEdgeData(CubitPoint *p1, CubitPoint *p2);
      41                 :            :   CubitFacetEdgeData(CubitPoint *p1, CubitPoint *p2,
      42                 :            :                  CubitFacet *facet1, CubitFacet *facet2,
      43                 :            :                  int edge_index1, int edge_index2);
      44                 :            :     //- constructors
      45                 :            :   ~CubitFacetEdgeData();
      46                 :            :     //- destructor
      47                 :       9372 :   int id(){return entityId;}
      48                 :       1298 :   void set_id( int ent_id ) {entityId=ent_id;};
      49                 :            :   
      50                 :     282282 :   CubitPoint *point( int index) { return pointArray[index]; };
      51                 :          0 :   CubitPoint *start_node() { return point(0); }
      52                 :          0 :   CubitPoint *end_node() { return point(1); }
      53                 :            :     //- get one of its points
      54                 :          0 :   void set_point( CubitPoint *pt, int index ) { pointArray[index] = pt; }
      55                 :            :     //- set one of the points
      56                 :            :   CubitFacet *adj_facet( int index ); 
      57                 :            :     //- get the list of adjacent facets
      58                 :            :   void facets(DLIList<CubitFacet*> &facet_list );
      59                 :            : 
      60                 :            :   void edges(DLIList<CubitFacetEdge*> &edge_list );
      61                 :            :   void points(DLIList<CubitPoint*> &point_list );
      62                 :       7084 :   int num_adj_facets()
      63                 :       7084 :     { return adjFacetList.size(); }
      64                 :          0 :   int number_tris() { return num_adj_facets(); }
      65                 :      11572 :   void marked (int my_flag ) { set_flag(my_flag); }
      66                 :       5984 :   int marked() { return get_flag(); }
      67                 :            :   
      68                 :       3168 :   void add_facet(CubitFacet *facet_ptr){ adjFacetList.append(facet_ptr); }
      69                 :            :   CubitStatus remove_facet( CubitFacet *facet_ptr );
      70                 :            :   
      71                 :            :   CubitStatus merge_edges( CubitFacetEdgeData* other_edge );
      72                 :            :   
      73                 :            :   void flip();
      74                 :            : 
      75                 :            : };
      76                 :            : 
      77                 :            : 
      78                 :            : #endif
      79                 :            : 
      80                 :            :