RefEntity.hpp

Go to the documentation of this file.

//-------------------------------------------------------------------------
// Filename      : RefEntity.hpp
//
// Purpose       : This file consolidates functionality from several
//                 base classes in CUBIT, and serves as the entry point
//                 to geometry from the meshing and other CUBIT classes
//
// Creator       : Tim Tautges (in it's new state)
//
// Creation Date : 9/99
//-------------------------------------------------------------------------

#ifndef REFENTITY_HPP
#define REFENTITY_HPP

// ********** BEGIN CUBIT INCLUDES         **********
#include "CubitObservable.hpp"
#include "CubitEntity.hpp"
#include "CubitAttribUser.hpp"
#include "CubitColor.hpp"
#include "ToolDataUser.hpp"
#include "DagType.hpp"
#include "GeometryEvent.hpp"

// ********** END CUBIT INCLUDES           **********

// ********** BEGIN FORWARD DECLARATIONS   **********

class CubitString;
template <class X> class DLIList;
class RefVolume;
class RefFace;
class RefEdge;
class RefVertex;
class RefEntity;
class MeshEntity;
class CubitEntity;

class Body;
class RefGroup;
class RefEdge;
class RefFace;
class RefVolume;
class RefVertex;

// ********** END FORWARD DECLARATIONS     **********

// ********** BEGIN MACRO DEFINITIONS     **********
// ********** END MACRO DEFINITIONS       **********

// ********** BEGIN ENUM DEFINITIONS     **********

enum AutoMergeStatus {
  AUTO_MERGE_AUTO = 2,
  AUTO_MERGE_ON   = 1,
  AUTO_MERGE_OFF  = 0
};


// ********** END ENUM DEFINITIONS       **********
class CUBIT_GEOM_EXPORT RefEntity: public CubitEntity,
                 public CubitObservable,
                 public ToolDataUser,
                 public CubitAttribUser
{
public:
  
  RefEntity() ;
    //- The default constructor
  
  virtual ~RefEntity ();
    //- A pure virtual destructor - this ensures that the class is
    //- non-instantiable.

  static const char* get_ref_class_name(const std::type_info& ref_type);
  
  static RefEntity* get_by_name(const CubitString& name);

  virtual CubitString entity_name() const;
  
  CubitStatus entity_name (CubitString name);

  void entity_names(DLIList<CubitString> &names) const;

  int num_names() const;

  CubitStatus generate_default_name ( CubitString &name );

  CubitStatus assign_default_name( CubitBoolean user_setting = CUBIT_FALSE );

  CubitStatus remove_entity_name(CubitString const & name);
  CubitStatus remove_entity_names();
  void merge_entity_names(RefEntity* dead_entity);
  void switch_entity_names(RefEntity *other_entity);
 
  //- Generic flag for temporary use by algorithms.
  //- Value is volatile and may change unexpectedly.
  virtual void marked(int value);
  virtual int  marked ();
  
  virtual void is_mergeable(AutoMergeStatus val);

  AutoMergeStatus merge_status() const;

  bool is_mergeable();

  CubitBoolean is_merged();
  // return true if this RefEntity has multiple TopologyBridges.

  void update_auto_merge_state();
    
  virtual bool children_mergeable();
  
  virtual int can_modify();
  
  virtual int dimension() const; 
  
  virtual void get_child_ref_entities(DLIList<RefEntity*>& entity_list); 
  
  void get_all_child_ref_entities(DLIList<RefEntity*>& entity_list);
  
  static void get_all_child_ref_entities(DLIList<RefEntity*>& input_list,
                  DLIList<RefEntity*>& output_list );


  static void gather_bdy_entities( DLIList<RefEntity*> &entity_list, 
                                   DLIList<RefEntity*> &bdy_list );

  virtual void get_parent_ref_entities(DLIList<RefEntity*>& entity_list) = 0;
  
  void get_all_parent_ref_entities(DLIList<RefEntity*>& entity_list,
                                   const int get_bodies = CUBIT_FALSE );
  
  static void change_to_parent_ref_entities( DLIList<RefEntity*>& ancestors );
 












  RefEntity *join( RefEntity* ref_entity_2, DLIList<RefEntity*> &join_set );
  static RefEntity *join( DLIList<RefEntity*> &ref_entities, 
                          DLIList<RefEntity*> &join_set );
  
  //- like join, except returns the lower order entities common to the input 
  //- entities
  RefEntity *meet( RefEntity* ref_entity_2, DLIList<RefEntity*> &join_set );
  static RefEntity *meet( DLIList<RefEntity*> &ref_entities, 
                          DLIList<RefEntity*> &join_set );

  int valence(RefEntity *parent = NULL);

  
  //- Return TRUE if this is entity, or a direct child (parent) of entity.
  virtual CubitBoolean is_child(RefEntity *entity);
  virtual CubitBoolean is_parent(RefEntity *entity);

  int num_parent_ref_entities();
  
//   void common_draw_label(int color, const int label_style);
//     //- Common code used for drawing labels. Actually, the entire
//     //- draw_label function could be implemented here if the
//     //- is_*_labeling_on() functions were virtual or better implemented.

  //CubitBoolean is_free_ref_entity();
    //- return CUBIT_TRUE if this ref entity has no non-virtual parents

  virtual CubitVector center_point();
  
  virtual double measure();
  
  virtual CubitString measure_label();
  
  virtual int validate();
  
  virtual DagType dag_type() const = 0;

  virtual const std::type_info& entity_type_info() const = 0;

  static DagType dag_type( const std::type_info& );
 
  DagType get_parent_ref_entity_type() const;

  DagType get_child_ref_entity_type() const;

  static DagType get_parent_ref_entity_type( DagType child_type );

  static DagType get_child_ref_entity_type( DagType parent_type );
  
  void notify_sub_all_observers(const GeometryEvent::Type& event);

  void comparison_found(RefEntity* partner);
  
  void add_compare_data(RefEntity* partner) ;
  
  void remove_compare_data() ;
    
  RefEntity* get_compare_partner() ;

//========  Change Code by RY of Cat,  5/7/99 11:08:12 AM  ========
  void get_related_entity_list(const std::type_info& related_entity_type,
                   DLIList<RefEntity*>& entity_list);
  //- to parse group in <ref_entity> commands
//========  Change End by RY of Cat,  5/7/99 11:08:12 AM  ========

  virtual void set_id(int i );
 
  void set_id(int i, CubitBoolean emit_event );

  static const std::type_info& get_entity_type_info(const char* entity_type);
   
  static DagType dag_type( const char* cli_type_name );
  
  virtual void color(int value);

  virtual int color() const;

  inline void local_tolerance( double value ){ localTolerance = value; }
  inline double local_tolerance( void ){ return localTolerance; }

protected :

  int          autoMergeStatus;//- Whether entity will participate
                               //- in 'merge all XXX' operation.
  int markedFlag;      //- Scratch flag for algorithm use.
                       //- NOTE: should be Bit markedFlag: 8 ntfolwe
  Bit listFlag : 1;    //- Scratch flag for low-level use

  int mColor; // color of this entity
   
private:

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

  void list_mark(int value);
  int  list_mark();
    //- Generic flag for marking whether an entity is in a list or not.
    //- For internal use by RefEntity.

  // This local tolerance is used in tolerant imprinting
  // This local tolerance is set automatically by LocalToleranceTool class
  double localTolerance;

};

// ********** BEGIN INLINE FUNCTIONS       **********

inline void
RefEntity::marked(int value)
{markedFlag = value;}

inline int
RefEntity::marked()
{return (int) markedFlag;}

inline void
RefEntity::list_mark(int value)
{listFlag = value;}

inline int
RefEntity::list_mark()
{return listFlag;}

// ********** END INLINE FUNCTIONS         **********

// ********** BEGIN FRIEND FUNCTIONS       **********
// ********** END FRIEND FUNCTIONS         **********

// ********** BEGIN EXTERN FUNCTIONS       **********
// ********** END EXTERN FUNCTIONS         **********

// ********** BEGIN HELPER CLASS DECLARATIONS **********
// ********** END   HELPER CLASS DECLARATIONS **********

template <> struct DLIListSorter<RefEntity*>
{
  bool operator()(RefEntity* a, RefEntity* b)
  {
    if (a == NULL)
    {
      if(a == b)
        return false;
      else
        return true;
    }
    else if(b == NULL)
    {
      return false;
    }
    else if (a->id() < b->id())
    {
      return true;
    }
    else if (a->id() > b->id())
    {
      return false;
    }
    // equal id, sort on dimension
    return a->dimension() < b->dimension();
  }
};

#endif