Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : RefEntity.hpp
3 : : //
4 : : // Purpose : This file consolidates functionality from several
5 : : // base classes in CUBIT, and serves as the entry point
6 : : // to geometry from the meshing and other CUBIT classes
7 : : //
8 : : // Creator : Tim Tautges (in it's new state)
9 : : //
10 : : // Creation Date : 9/99
11 : : //-------------------------------------------------------------------------
12 : :
13 : : #ifndef REFENTITY_HPP
14 : : #define REFENTITY_HPP
15 : :
16 : : // ********** BEGIN CUBIT INCLUDES **********
17 : : #include "CubitObservable.hpp"
18 : : #include "CubitEntity.hpp"
19 : : #include "CubitAttribUser.hpp"
20 : : #include "CubitColor.hpp"
21 : : #include "ToolDataUser.hpp"
22 : : #include "DagType.hpp"
23 : : #include "GeometryEvent.hpp"
24 : :
25 : : // ********** END CUBIT INCLUDES **********
26 : :
27 : : // ********** BEGIN FORWARD DECLARATIONS **********
28 : :
29 : : class CubitString;
30 : : template <class X> class DLIList;
31 : : class RefVolume;
32 : : class RefFace;
33 : : class RefEdge;
34 : : class RefVertex;
35 : : class RefEntity;
36 : : class MeshEntity;
37 : : class CubitEntity;
38 : :
39 : : class Body;
40 : : class RefGroup;
41 : : class RefEdge;
42 : : class RefFace;
43 : : class RefVolume;
44 : : class RefVertex;
45 : :
46 : : // ********** END FORWARD DECLARATIONS **********
47 : :
48 : : // ********** BEGIN MACRO DEFINITIONS **********
49 : : // ********** END MACRO DEFINITIONS **********
50 : :
51 : : // ********** BEGIN ENUM DEFINITIONS **********
52 : :
53 : : enum AutoMergeStatus {
54 : : AUTO_MERGE_AUTO = 2,
55 : : AUTO_MERGE_ON = 1,
56 : : AUTO_MERGE_OFF = 0
57 : : };
58 : :
59 : :
60 : : // ********** END ENUM DEFINITIONS **********
61 : : //! Base class for all geometry entities, body, volume, surface...
62 : : class CUBIT_GEOM_EXPORT RefEntity: public CubitEntity,
63 : : public CubitObservable,
64 : : public ToolDataUser,
65 : : public CubitAttribUser
66 : : {
67 : : public:
68 : :
69 : : RefEntity() ;
70 : : //- The default constructor
71 : :
72 : : virtual ~RefEntity ();
73 : : //- A pure virtual destructor - this ensures that the class is
74 : : //- non-instantiable.
75 : :
76 : : //! \brief Gets the class name of a RefEntity type.
77 : : static const char* get_ref_class_name(const std::type_info& ref_type);
78 : :
79 : : //! \brief Gets the RefEntity with the passed in name.
80 : : static RefEntity* get_by_name(const CubitString& name);
81 : :
82 : : //! \brief Gets the name of this RefEntity.
83 : : virtual CubitString entity_name() const;
84 : :
85 : : //! \brief Sets the name of this RefEntity.
86 : : CubitStatus entity_name (CubitString name);
87 : :
88 : : //! \brief Gets the names of this RefEntity.
89 : : void entity_names(DLIList<CubitString> &names) const;
90 : :
91 : : //! \brief Get the number of names this RefEntity has.
92 : : int num_names() const;
93 : :
94 : : //! \brief Generates a default name for this RefEntity. 'name' is prepended
95 : : //! to the default name.
96 : : CubitStatus generate_default_name ( CubitString &name );
97 : :
98 : : //! \brief Assigns a default name to the entity.
99 : : CubitStatus assign_default_name( CubitBoolean user_setting = CUBIT_FALSE );
100 : :
101 : : CubitStatus remove_entity_name(CubitString const & name);
102 : : CubitStatus remove_entity_names();
103 : : void merge_entity_names(RefEntity* dead_entity);
104 : : void switch_entity_names(RefEntity *other_entity);
105 : :
106 : : //@{
107 : : //- Generic flag for temporary use by algorithms.
108 : : //- Value is volatile and may change unexpectedly.
109 : : virtual void marked(int value);
110 : : virtual int marked ();
111 : : //@}
112 : :
113 : : //! \brief Setting auto merge status flag.
114 : : virtual void is_mergeable(AutoMergeStatus val);
115 : :
116 : : //! \brief Gets auto merge status flag.
117 : : AutoMergeStatus merge_status() const;
118 : :
119 : : //! \brief Query to see if entity is free to merge.
120 : : bool is_mergeable();
121 : :
122 : : //! \brief Query to see if entity is merged.
123 : : CubitBoolean is_merged();
124 : : // return true if this RefEntity has multiple TopologyBridges.
125 : :
126 : : //! Updates the auto merge state of the entity.
127 : : void update_auto_merge_state();
128 : :
129 : : //! \brief Get whether all child entities are mergeable.
130 : : virtual bool children_mergeable();
131 : :
132 : : //! Allow unmerging and other operations. Default in
133 : : //! RefEntity always returns true. Provided for
134 : : //! derived classes to override.
135 : : virtual int can_modify();
136 : :
137 : : //! Returns the geometric dimension of the entity.
138 : : //! vertex == 0, edge == 1, etc.
139 : : virtual int dimension() const;
140 : :
141 : : //! Appends all immediate (child) RefEntities owned by this RefEntity to
142 : : //! entity_list. (The query goes down just one dimension.)
143 : : virtual void get_child_ref_entities(DLIList<RefEntity*>& entity_list);
144 : :
145 : : //! Appends all child RefEntities owned by this entity to entity_list.
146 : : //! (The query recurses all the way down to RefEntities of dimension 0).
147 : : void get_all_child_ref_entities(DLIList<RefEntity*>& entity_list);
148 : :
149 : : //! Appends all child RefEntities owned by entities in input_list to output_list
150 : : static void get_all_child_ref_entities(DLIList<RefEntity*>& input_list,
151 : : DLIList<RefEntity*>& output_list );
152 : :
153 : :
154 : : //! Gather the boundary entities of the entity_list into the bdy_list.
155 : : //! Entities appear once in bdy_list, and will not appear in bdy_list
156 : : //! if they are already in the entity_list.
157 : : //! Uses listMark.
158 : : static void gather_bdy_entities( DLIList<RefEntity*> &entity_list,
159 : : DLIList<RefEntity*> &bdy_list );
160 : :
161 : : //! Appends all RefEntities that own this (parent RefEntities) to
162 : : //! entity_list.
163 : : //! (The query goes up just one dimension. For example, if this is a
164 : : //! vertex, the resulting list contains only RefEdges).
165 : : virtual void get_parent_ref_entities(DLIList<RefEntity*>& entity_list) = 0;
166 : :
167 : : //! Appends all parent RefEntities owned by this entity to entity_list.
168 : : //! Recurses up to RefVolumes, or RefBodies if get_bodies is true.
169 : : void get_all_parent_ref_entities(DLIList<RefEntity*>& entity_list,
170 : : const int get_bodies = CUBIT_FALSE );
171 : :
172 : : //! Modify the input list to contain the list of RefEntities that are
173 : : //! the parents of each of the RefEntities in the original list.
174 : : static void change_to_parent_ref_entities( DLIList<RefEntity*>& ancestors );
175 : :
176 : : //@{
177 : : //! RefEntity* join( RefEntity* ref_entity_2 );
178 : : //! Computes the geometric "join" of elements (elements on the list or
179 : : //! this and ref_entity_2).
180 : : //! Definition "Join" = The lowest dimensional entitity that
181 : : //! is a higher dimensional ancestor of them all.
182 : : //! Note join could be one of the entities itself, NULL,
183 : : //! or multiple elements.
184 : : //! E.g. The join of a vertex and a curve containing the vertex is
185 : : //! the curve. The join of two curves of a split cylinder is
186 : : //! both containing surfaces.
187 : : //! The join of two entities in separate, unmerged volumes is null.
188 : : //! Returns the first element of the join_set, or NULL if set is empty.
189 : : RefEntity *join( RefEntity* ref_entity_2, DLIList<RefEntity*> &join_set );
190 : : static RefEntity *join( DLIList<RefEntity*> &ref_entities,
191 : : DLIList<RefEntity*> &join_set );
192 : : //@}
193 : :
194 : : //@{
195 : : //- like join, except returns the lower order entities common to the input
196 : : //- entities
197 : : RefEntity *meet( RefEntity* ref_entity_2, DLIList<RefEntity*> &join_set );
198 : : static RefEntity *meet( DLIList<RefEntity*> &ref_entities,
199 : : DLIList<RefEntity*> &join_set );
200 : : //@}
201 : :
202 : : //! the valence of this entity with respect to parent (absolute
203 : : //! valence if parent is null)
204 : : int valence(RefEntity *parent = NULL);
205 : :
206 : :
207 : : //@{
208 : : //- Return TRUE if this is entity, or a direct child (parent) of entity.
209 : : virtual CubitBoolean is_child(RefEntity *entity);
210 : : virtual CubitBoolean is_parent(RefEntity *entity);
211 : : //@}
212 : :
213 : : //! returns the number of parent entities of this; also useful for determining
214 : : //! whether an entity is free or not; returns -1 on error
215 : : int num_parent_ref_entities();
216 : :
217 : : // void common_draw_label(int color, const int label_style);
218 : : // //- Common code used for drawing labels. Actually, the entire
219 : : // //- draw_label function could be implemented here if the
220 : : // //- is_*_labeling_on() functions were virtual or better implemented.
221 : :
222 : : //CubitBoolean is_free_ref_entity();
223 : : //- return CUBIT_TRUE if this ref entity has no non-virtual parents
224 : :
225 : : //! Return the approximate (spatial) center of this RefEntity
226 : : virtual CubitVector center_point();
227 : :
228 : : //! A generic geometric extent function.
229 : : //! Returns volume for RefVolumes, area for RefFaces, length for RefEdge,
230 : : //! and 1.0 for RefVertices
231 : : //! A RefGroup calculates the maximum dimension of its contained
232 : : //! entities and returns the sum of the measures() of all entities
233 : : //! of that dimension.
234 : : //! Default return value is 0.0 for all other entities.
235 : : virtual double measure();
236 : :
237 : : //! Returns the type of measure: (volume, area, length, or N/A)
238 : : virtual CubitString measure_label();
239 : :
240 : : //! Perform checks to see if entity valid.
241 : : virtual int validate();
242 : :
243 : : //! Returns the dag type of this enity.
244 : : virtual DagType dag_type() const = 0;
245 : :
246 : : //! Returns the type info of this enity.
247 : : virtual const std::type_info& entity_type_info() const = 0;
248 : :
249 : : //! Translates the type info into dag type.
250 : : static DagType dag_type( const std::type_info& );
251 : :
252 : : //! Gets the parent RefEntity type.
253 : : DagType get_parent_ref_entity_type() const;
254 : :
255 : : //! Gets the child RefEntity type.
256 : : DagType get_child_ref_entity_type() const;
257 : :
258 : : //! Given a child dag type, returns the parent dag type.
259 : : static DagType get_parent_ref_entity_type( DagType child_type );
260 : :
261 : : //! Given a parent dag type, returns the child dag type.
262 : : static DagType get_child_ref_entity_type( DagType parent_type );
263 : :
264 : : //! send event to all observers (static and non-static) for
265 : : //! this entity and all children
266 : : void notify_sub_all_observers(const GeometryEvent::Type& event);
267 : :
268 : : //! Make temporary TDCompare objects and attach to "this" and
269 : : //! the "partner" object.
270 : : void comparison_found(RefEntity* partner);
271 : :
272 : : //!R void
273 : : //!I partner
274 : : //!I- The compare partner for this object
275 : : //! This function makes the connection between the two RefEntities,
276 : : //! this and partner. At the end of this function the two entities
277 : : //! would know who they compare with.
278 : : void add_compare_data(RefEntity* partner) ;
279 : :
280 : : //!- This function clears the compare related temporary data.
281 : : void remove_compare_data() ;
282 : :
283 : : //!R RefEntity*
284 : : //!R- The partner set in add_compare_data(), or NULL if none
285 : : //!R- has been set.
286 : : RefEntity* get_compare_partner() ;
287 : :
288 : : //======== Change Code by RY of Cat, 5/7/99 11:08:12 AM ========
289 : : void get_related_entity_list(const std::type_info& related_entity_type,
290 : : DLIList<RefEntity*>& entity_list);
291 : : //- to parse group in <ref_entity> commands
292 : : //======== Change End by RY of Cat, 5/7/99 11:08:12 AM ========
293 : :
294 : : //! Set the id of this RefEntity to i
295 : : virtual void set_id(int i );
296 : :
297 : : //! Sets the id of this RefEntity and emits specified event static observers.
298 : : void set_id(int i, CubitBoolean emit_event );
299 : :
300 : : //! Returns the type of a class given the class name.
301 : : static const std::type_info& get_entity_type_info(const char* entity_type);
302 : :
303 : : //! Returns a dag type based on name passed in, i.e., body, volume, surface..
304 : : static DagType dag_type( const char* cli_type_name );
305 : :
306 : : //! Sets the color of this RefEntity.
307 : : virtual void color(int value);
308 : :
309 : : //! Gets the color of this RefEntity.
310 : : virtual int color() const;
311 : :
312 : : //! Get and set the local tolerance of this RefEntity. This is used in tolerant imprinting.
313 : 0 : inline void local_tolerance( double value ){ localTolerance = value; }
314 : 20696 : inline double local_tolerance( void ){ return localTolerance; }
315 : :
316 : : protected :
317 : :
318 : : int autoMergeStatus;//- Whether entity will participate
319 : : //- in 'merge all XXX' operation.
320 : : int markedFlag; //- Scratch flag for algorithm use.
321 : : //- NOTE: should be Bit markedFlag: 8 ntfolwe
322 : : Bit listFlag : 1; //- Scratch flag for low-level use
323 : :
324 : : int mColor; // color of this entity
325 : :
326 : : private:
327 : :
328 : : RefEntity( const RefEntity& );
329 : : void operator=( const RefEntity& );
330 : :
331 : : void list_mark(int value);
332 : : int list_mark();
333 : : //- Generic flag for marking whether an entity is in a list or not.
334 : : //- For internal use by RefEntity.
335 : :
336 : : // This local tolerance is used in tolerant imprinting
337 : : // This local tolerance is set automatically by LocalToleranceTool class
338 : : double localTolerance;
339 : :
340 : : };
341 : :
342 : : // ********** BEGIN INLINE FUNCTIONS **********
343 : :
344 : : inline void
345 : 713216 : RefEntity::marked(int value)
346 : 713216 : {markedFlag = value;}
347 : :
348 : : inline int
349 : 173595 : RefEntity::marked()
350 : 173595 : {return (int) markedFlag;}
351 : :
352 : : inline void
353 : 0 : RefEntity::list_mark(int value)
354 : 0 : {listFlag = value;}
355 : :
356 : : inline int
357 : 0 : RefEntity::list_mark()
358 : 0 : {return listFlag;}
359 : :
360 : : // ********** END INLINE FUNCTIONS **********
361 : :
362 : : // ********** BEGIN FRIEND FUNCTIONS **********
363 : : // ********** END FRIEND FUNCTIONS **********
364 : :
365 : : // ********** BEGIN EXTERN FUNCTIONS **********
366 : : // ********** END EXTERN FUNCTIONS **********
367 : :
368 : : // ********** BEGIN HELPER CLASS DECLARATIONS **********
369 : : // ********** END HELPER CLASS DECLARATIONS **********
370 : :
371 : : template <> struct DLIListSorter<RefEntity*>
372 : : {
373 : : bool operator()(RefEntity* a, RefEntity* b)
374 : : {
375 : : if (a == NULL)
376 : : {
377 : : if(a == b)
378 : : return false;
379 : : else
380 : : return true;
381 : : }
382 : : else if(b == NULL)
383 : : {
384 : : return false;
385 : : }
386 : : else if (a->id() < b->id())
387 : : {
388 : : return true;
389 : : }
390 : : else if (a->id() > b->id())
391 : : {
392 : : return false;
393 : : }
394 : : // equal id, sort on dimension
395 : : return a->dimension() < b->dimension();
396 : : }
397 : : };
398 : :
399 : : #endif
400 : :
|
