Branch data Line data Source code
1 : : #ifndef MESHKIT_MODELENT_HPP
2 : : #define MESHKIT_MODELENT_HPP
3 : :
4 : : #include "meshkit/iGeom.hpp"
5 : : #include "meshkit/Types.hpp"
6 : : #include "moab/Interface.hpp"
7 : : #include <cassert>
8 : : #include <vector>
9 : : #include <set>
10 : : #include <map>
11 : :
12 : : namespace MeshKit {
13 : :
14 : : class ModelEnt;
15 : : class MKCore;
16 : : class IAVariable;
17 : :
18 : : /** \class ModelEnt ModelEnt.hpp "meshkit/ModelEnt.hpp"
19 : : * \brief The class used in MeshKit for referring to model entities and mesh associated with them.
20 : : *
21 : : * Instances of this class are references to the entities stored in the geometry and mesh
22 : : * databases. Destruction/construction of ModelEnt instances does not cause destruction/construction
23 : : * of the corresponding database entities (one exception to this statement is that an argument to the
24 : : * constructor can request that the mesh entity set be created for the corresponding geometry entity).
25 : : *
26 : : * A ModelEnt instance keeps a reference to the MKCore object to which it is associated; through that
27 : : * instance it can get access to the geometry/mesh/relation database instances.
28 : : * \nosubgrouping
29 : : */
30 : : class ModelEnt
31 : : {
32 : : public:
33 : :
34 : : /** \name Constructor/destructor
35 : : */
36 : : /**@{*/
37 : :
38 : : /** \brief Constructor; mesh entity can be missing, in which case it's retrieved or created
39 : : *
40 : : * \param mk MeshKit instance
41 : : * \param geom_ent Geometry entity corresponding to this ModelEntity
42 : : * \param igeom iGeom instance
43 : : * \param mesh_ent Mesh entity set corresponding to this ModelEntity
44 : : * \param sizing_index Sizing function index (from MBCore) to be used to mesh this entity
45 : : */
46 : : ModelEnt(MKCore *mk,
47 : : iGeom::EntityHandle geom_ent,
48 : : int geom_index,
49 : : moab::EntityHandle mesh_ent = 0,
50 : : int mesh_index = -1,
51 : : int irel_index = -1,
52 : : int sizing_index = -1);
53 : :
54 : : /** \brief Constructor; mesh entity can be missing, in which case it's retrieved or created
55 : : *
56 : : * \param mk MeshKit instance
57 : : * \param geom_set Geometry entity set corresponding to this ModelEntity
58 : : * \param igeom iGeom instance
59 : : * \param mesh_ent Mesh entity set corresponding to this ModelEntity
60 : : * \param sizing_index Sizing function index (from MBCore) to be used to mesh this entity
61 : : */
62 : : ModelEnt(MKCore *mk,
63 : : iGeom::EntitySetHandle geom_set,
64 : : int geom_index,
65 : : moab::EntityHandle mesh_ent = 0,
66 : : int mesh_index = -1,
67 : : int irel_index = -1,
68 : : int sizing_index = -1,
69 : : IAVariable *ia_var = NULL);
70 : :
71 : : /** \brief Destructor
72 : : */
73 : : virtual ~ModelEnt();
74 : :
75 : : /**@}*/
76 : :
77 : : /** \name Topology
78 : : */
79 : : /**@{*/
80 : :
81 : : /** \brief Return children as vectors of vectors, e.g. for loops or shells
82 : : *
83 : : * No ordered flag, since that's implied by definition
84 : : * \param child_ents Child entities returned
85 : : */
86 : : void children(std::vector<MEntVector> &child_ents) const;
87 : :
88 : : /** \brief Return children as vectors of vectors, e.g. for loops or shells
89 : : *
90 : : * No ordered flag, since that's implied by definition
91 : : * \param child_ents Child entities returned
92 : : */
93 : : void children(std::vector<MEntVector> &child_ents);
94 : :
95 : : /** \brief Return children as vectors of vectors, e.g. for loops or shells
96 : : *
97 : : * No ordered flag, since that's implied by definition
98 : : * \param child_ents Child entities returned
99 : : */
100 : : void children(std::vector<std::vector<moab::EntityHandle> > &child_ents) const;
101 : :
102 : : /** \brief Return children as vectors of vectors, e.g. for loops or shells
103 : : *
104 : : * No ordered flag, since that's implied by definition
105 : : * \param child_ents Child entities returned
106 : : */
107 : : void children(std::vector<std::vector<iGeom::EntityHandle> > &child_ents) const;
108 : :
109 : : /** \brief Return adjacencies to this model entity of the input dimension
110 : : *
111 : : * This function appends adjacencies to the input vector.
112 : : * \param dim Dimension of entities requested; if -1, all adjacent entities are returned
113 : : * \param adjs Adjacent entities
114 : : */
115 : : void get_adjacencies(int dim, MEntVector &adjs) const;
116 : :
117 : : /** \brief Return adjacencies to this model entity of the input dimension
118 : : *
119 : : * This function appends adjacencies to the input vector.
120 : : * \param dim Dimension of entities requested; if -1, all adjacent entities are returned
121 : : * \param adjs Adjacent entities
122 : : */
123 : : void get_adjacencies(int dim, std::vector<iGeom::EntityHandle> &adjs) const;
124 : :
125 : : /** \brief Return adjacencies to this model entity of the input dimension
126 : : *
127 : : * This function appends adjacencies to the input vector.
128 : : * \param dim Dimension of entities requested; if -1, all adjacent entities are returned
129 : : * \param adjs Adjacent entities
130 : : */
131 : : void get_adjacencies(int dim, std::vector<moab::EntityHandle> &adjs) const;
132 : :
133 : : /** \brief Return adjacencies to this model entity of the input dimension
134 : : *
135 : : * This function adds adjacencies to the input range.
136 : : * \param dim Dimension of entities requested; if -1, all adjacent entities are returned
137 : : * \param adjs Adjacent entities
138 : : */
139 : : void get_adjacencies(int dim, moab::Range &adjs) const;
140 : :
141 : : /** \brief Return a shared entity of specified dimension
142 : : *
143 : : * If no shared entities are found, NULL is returned. If more than one are found,
144 : : * an Error is thrown with MK_MULTIPLE_FOUND as the code.
145 : : * \param ent2 Other entity
146 : : * \param to_dim Dimension of shared entity
147 : : * \return Shared entity
148 : : */
149 : : ModelEnt *shared_entity(ModelEnt *ent2, int to_dim);
150 : :
151 : : /** \brief Get adjacent entities, with specified boolean on results
152 : : * \param from_ents Entities whose adjacencies are being queried
153 : : * \param to_dim Dimension of adjacencies requested
154 : : * \param to_ents Adjacent entities
155 : : * \param op_type Boolean type, intersect or union
156 : : * \param only_to_ents if is true, get adjacencies from to_ents
157 : : */
158 : : void get_adjs_bool(MEntVector &from_ents,
159 : : int to_dim,
160 : : MEntVector &to_ents,
161 : : BooleanType op_type,
162 : : bool only_to_ents = true);
163 : : /**@}*/
164 : :
165 : : /** \name Geometric evaluation
166 : : */
167 : : /**@{*/
168 : :
169 : : //! Return the topological dimension of this model entity
170 : : int dimension() const;
171 : :
172 : : //! Measure of this entity, -DBL_MAX for vertices, or length, area, or volume
173 : : double measure() const;
174 : :
175 : : //! Similar as measure, but based on mesh
176 : : double measure_discrete() const;
177 : :
178 : : /** \brief Evaluate entity at a point
179 : : *
180 : : * If any of the evaluation results are not wanted, pass NULL for them. At least one
181 : : * must be provided. This function throws an error if called on a vertex or volume and
182 : : * non-NULL is passed for direction or curvature. Direction is the tangent for edges,
183 : : * normal for surfaces.
184 : : * \param x Start point x
185 : : * \param y Start point y
186 : : * \param z Start point z
187 : : * \param close Closest point
188 : : * \param direction Tangent or normal returned for edges or surfaces
189 : : * \param curvature1 1st curvature for edges or surfaces
190 : : * \param curvature2 2nd curvature for edges or surfaces
191 : : */
192 : : void evaluate(double x, double y, double z,
193 : : double *close = NULL,
194 : : double *direction = NULL,
195 : : double *curvature1 = NULL,
196 : : double *curvature2 = NULL) const;
197 : :
198 : : /** \brief Evaluate entity at a point, based on mesh data
199 : : *
200 : : * If any of the evaluation results are not wanted, pass NULL for them. At least one
201 : : * must be provided. This function throws an error if called on a vertex or volume and
202 : : * non-NULL is passed for direction or curvature. Direction is the tangent for edges,
203 : : * normal for surfaces.
204 : : * \param x Start point x
205 : : * \param y Start point y
206 : : * \param z Start point z
207 : : * \param close Closest point
208 : : * \param direction Tangent or normal returned for edges or surfaces
209 : : * \param curvature1 1st curvature for edges or surfaces
210 : : * \param curvature2 2nd curvature for edges or surfaces
211 : : */
212 : : void evaluate_discrete(double x, double y, double z,
213 : : double *close = NULL,
214 : : double *direction = NULL,
215 : : double *curvature1 = NULL,
216 : : double *curvature2 = NULL) const;
217 : :
218 : : //! Get the id of the geometry/mesh entity, if any
219 : : int id() const;
220 : :
221 : : /**@}*/
222 : :
223 : : /** \name Mesh
224 : : */
225 : : /**@{*/
226 : :
227 : : /** \brief Create mesh set for this ModelEnt
228 : : *
229 : : * This function creates the entity set for a geometry entity, and tags that set
230 : : * according to convention (GEOM_DIMENSION and GLOBAL_ID). It also sets the relation
231 : : * with the corresponding geometry entity. The value of flag controls whether a
232 : : * vector- or set-based entity set is created:
233 : : * flag = 1 : create a vector-based set
234 : : * flag = 0 : create a set-based set
235 : : * flag = -1: check dimension of iGeomEnt; if 1, vector-based set, otherwise set-based set
236 : : * \param ordered_flag Ordered flag
237 : : */
238 : : void create_mesh_set(int ordered_flag = -1);
239 : :
240 : : /** \brief Commit mesh to a model entity
241 : : *
242 : : * Takes the input mesh entities, adds them to the entity set for this model entity,
243 : : * and (if both-type relation on the mesh side) sets the relations to the corresponding
244 : : * geometry entity.
245 : : * \param mesh_ents Mesh entities being assigned to this model entity
246 : : * \param mstate The meshed state after this mesh is added
247 : : */
248 : : void commit_mesh(moab::Range &mesh_ents,
249 : : MeshedState mstate);
250 : :
251 : : /** \brief Commit mesh to a model entity
252 : : *
253 : : * Takes the input mesh entities, adds them to the entity set for this model entity,
254 : : * and (if both-type relation on the mesh side) sets the relations to the corresponding
255 : : * geometry entity.
256 : : * \param mesh_ents Pointer to mesh entities being assigned to this model entity
257 : : * \param num_ents Number of mesh entities in list
258 : : * \param mstate The meshed state after this mesh is added
259 : : */
260 : : void commit_mesh(moab::EntityHandle *mesh_ents,
261 : : int num_ents,
262 : : MeshedState mstate);
263 : :
264 : : /** \brief Return the mesh on this entity, of the specified dimension or (if dim=-1) all dimensions
265 : : *
266 : : * This function will return the mesh entities on bounding entities too, if requested. This is useful
267 : : * for example for assembling the nodes bounding a surface, as some of those nodes are on model
268 : : * vertices. If requesting mesh on a periodic edge, end vertex will appear on both ends of the returned
269 : : * vector.
270 : : * \param dim Dimension of entities requested
271 : : * \param ments Entities
272 : : * \param bdy_too If true, returns (dim)-dimensional entities from bounding entities too
273 : : */
274 : : void get_mesh(int dim,
275 : : std::vector<moab::EntityHandle> &ments,
276 : : bool bdy_too = false);
277 : :
278 : : /** \brief Return the mesh bounding this entity, their senses, and optionally the loops/shells
279 : : *
280 : : * In the case where vertices are requested (dim=0), vertices on end of loops are *not* repeated
281 : : * \param dim Dimension of boundary entities requested
282 : : * \param bdy Boundary entities
283 : : * \param senses Senses of boundary entities
284 : : * \param group_sizes If non-NULL, pointer to vector where group sizes will be returned
285 : : */
286 : : void boundary(int dim,
287 : : std::vector<moab::EntityHandle> &bdy,
288 : : std::vector<int> *senses = NULL,
289 : : std::vector<int> *group_sizes = NULL);
290 : :
291 : : /** \brief Return the model entities bounding this entity, their senses, and optionally the loops/shells
292 : : * \param dim Dimension of boundary entities requested
293 : : * \param elements Boundary entities
294 : : * \param senses Senses of boundary entities
295 : : * \param group_sizes If non-NULL, pointer to vector where group sizes will be returned
296 : : */
297 : : void boundary(int dim,
298 : : MEntVector &elements,
299 : : std::vector<int> *senses,
300 : : std::vector<int> *group_sizes = NULL);
301 : :
302 : : /** \brief Return mesh bounding this model entity in a Range (unordered wrt model entity)
303 : : *
304 : : * This function returns boundary entities in a Range, which means they're not guaranteed
305 : : * to be ordered consistently with respect to the model entity orientation. The input range
306 : : * is appended to (i.e. it is not emptied first).
307 : : * \param dim Dimension of requested boundary entities
308 : : * \param ents Boundary entities requested
309 : : */
310 : : void boundary(int dim,
311 : : moab::Range &ents) const;
312 : :
313 : : /** \brief From a vector of entity handles, return connectivity as integer ids, and coords of vertices if requested
314 : : *
315 : : * The entity handles are ordered and made unique, assigned ids, then the id vector is assembled
316 : : * in the same order as the input handle vector. Optionally this function returns the moab tag
317 : : * used to assign ids, and the moab range used to get unique ids
318 : : * \param ents Vector of entities whose ids to assign
319 : : * \param senses Senses of entities in ents; if NULL, assume forward sense, or no sense if ents are vertices
320 : : * \param tagh Tag handle to use for ids; if zero, local tag is used then deleted
321 : : * \param ents_as_ids Vector of ids that get assigned, ordered same as connectivity of ents (or ents itself if they're vertices)
322 : : * \param coords Coordinates of vertices corresponding to ents_as_ids
323 : : * \param verts_range Vertices in ents, as a range; if non-NULL, populated range is returned; this range is
324 : : * cleared in this function
325 : : * \param start_index Starting index for vertex numbering
326 : : */
327 : : void get_indexed_connect_coords(std::vector<moab::EntityHandle> &ents,
328 : : std::vector<int> *senses,
329 : : moab::Tag tagh,
330 : : std::vector<int> &ents_as_ids,
331 : : std::vector<double> &coords,
332 : : moab::Range *verts_range = NULL,
333 : : int start_index = 0);
334 : :
335 : : /** \brief Get meshed state
336 : : * \return Meshed state
337 : : */
338 : : MeshedState get_meshed_state();
339 : :
340 : : /** \brief Set the meshed state
341 : : * \param mstate
342 : : */
343 : : void set_meshed_state(MeshedState mstate);
344 : :
345 : : /**@}*/
346 : :
347 : : /** \name Mesh intervals, sizing functions
348 : : */
349 : :
350 : : /**@{*/
351 : :
352 : : /** \brief Get sizing function index
353 : : * \return Returns -1 if it has not been set for this entity
354 : : */
355 : : int sizing_function_index() const;
356 : :
357 : : /** \brief Set sizing function index
358 : : * \param index Sizing function index being set
359 : : * \param children_too If true, sizing function index is propagated to child (bounding) entities
360 : : */
361 : : void sizing_function_index(int index, bool children_too = true);
362 : :
363 : : /** \brief Get mesh interval size, if any
364 : : * Returns -1 if no size set on this entity. If intervals are set and this is a model edge, returns computed size.
365 : : * \return Interval size for this ModelEnt.
366 : : */
367 : : double mesh_interval_size() const;
368 : :
369 : : //! Get intervals
370 : : int mesh_intervals() const;
371 : :
372 : : /** \brief Set intervals
373 : : * \param ints Set value
374 : : */
375 : : void mesh_intervals(int ints);
376 : :
377 : : //! Get firmness
378 : : Firmness interval_firmness() const;
379 : :
380 : : /** \brief Set firmness
381 : : * \param firm Set value
382 : : */
383 : : void interval_firmness(Firmness firm);
384 : :
385 : : //! Get constrainEven
386 : : bool constrain_even() const;
387 : :
388 : : /** \brief Set constrainEven
389 : : * \param flag Set value
390 : : */
391 : : void constrain_even(bool flag);
392 : :
393 : : /**@}*/
394 : :
395 : : /** \name MeshOps
396 : : */
397 : :
398 : : /**@{*/
399 : :
400 : : /** \brief Add a MeshOp that points to this ModelEnt
401 : : *
402 : : * \param meshop MeshOp to add
403 : : */
404 : : void add_meshop(MeshOp *meshop);
405 : :
406 : : /** \brief Remove a MeshOp that pointed to this ModelEnt
407 : : *
408 : : * \param meshop MeshOp to remove
409 : : */
410 : : void remove_meshop(MeshOp *meshop);
411 : :
412 : : /** \brief Get MeshOps pointing to this ModelEnt
413 : : *
414 : : * \param meshops MeshOps returned
415 : : */
416 : : void get_meshops(std::vector<MeshOp*> &meshops);
417 : :
418 : : /** \brief decide if there is a meshop defined for this model entity
419 : : *
420 : : * return true if the list of meshops is not empty
421 : : */
422 : 1176 : bool is_meshops_list_empty()
423 : : {
424 : 1176 : return meshOps.empty();
425 : : }
426 : :
427 : : /**@}*/
428 : :
429 : : /** \name Interfaces, entities
430 : : */
431 : :
432 : : /**@{*/
433 : :
434 : : //! Get the MKCore object
435 : : MKCore *mk_core() const;
436 : :
437 : : //! Get geometry entity handle
438 : : iGeom::EntityHandle geom_handle() const;
439 : :
440 : : //! Get geometry entity handle for a given mesh entity set
441 : : iGeom::EntityHandle geom_handle(moab::EntityHandle ment) const;
442 : :
443 : : /** \brief Get iGeom instance associated with this model entity
444 : : * \return Returns 0 by default
445 : : */
446 : : iGeom * igeom_instance() const ;
447 : :
448 : : /** \brief Get moab instance associated with this model entity
449 : : * \return Returns 0 by default
450 : : */
451 : : moab::Interface * moab_instance() const ;
452 : :
453 : : //! Get mesh entity set handle
454 : : moab::EntityHandle mesh_handle() const;
455 : :
456 : : //! Get mesh entity set handle for a given geometry entity
457 : : moab::EntityHandle mesh_handle(iGeom::EntityHandle gent) const;
458 : :
459 : : //! Get mesh entity set handle for a given geometry entity
460 : : moab::EntityHandle mesh_handle(iGeom::EntitySetHandle gent) const;
461 : :
462 : 18 : int iGeomIndex()
463 : 18 : {return igeomIndex;}
464 : :
465 : 43 : int iRelPairIndex()
466 : 43 : {return irelIndex;}
467 : :
468 : : IAVariable *ia_var() {return iaVariable;}
469 : : const IAVariable *ia_var() const {return iaVariable;}
470 : : void ia_var(IAVariable *var) {iaVariable = var;}
471 : :
472 : : private:
473 : :
474 : : /** \brief Return the next entity in the loop, using winding number
475 : : * \param this_edge Edge next to one being requested
476 : : * \param this_sense Sense of this_edge
477 : : * \param tmp_adjs Optional vector of candidates
478 : : * \return Next edge in loop
479 : : */
480 : : ModelEnt *next_winding(ModelEnt *this_edge,
481 : : int this_sense,
482 : : MEntVector &tmp_adjs);
483 : :
484 : : /** \brief Initialize mesh set parents/children to parallel geometric topology
485 : : */
486 : : void init_parents_children();
487 : :
488 : : /** \brief Initialize mesh set contents to parallel geometry set contents
489 : : */
490 : : void init_group_contents();
491 : :
492 : : //! Set senses tag on moabEntSet wrt adjacent entities
493 : : void set_downward_senses();
494 : :
495 : : //! MeshKit instance to which this model entity is associated
496 : : MKCore *mkCore;
497 : :
498 : : //! iGeom instance index associated with this model entity
499 : : int igeomIndex;
500 : :
501 : : //! MOAB instance index associated with this model entity
502 : : int meshIndex;
503 : :
504 : : //! iRel pair index associated with this model entity
505 : : int irelIndex;
506 : :
507 : : //! Geometry entity for this model entity
508 : : iGeom::EntityHandle iGeomEnt;
509 : :
510 : : //! Geometry set for this model entity
511 : : iGeom::EntitySetHandle iGeomSet;
512 : :
513 : : //! Mesh entity set for this model entity
514 : : moab::EntityHandle moabEntSet;
515 : :
516 : : //! Sizing function associated with this model entity
517 : : int sizingFunctionIndex;
518 : :
519 : : //! Mesh intervals for this model entity
520 : : int meshIntervals;
521 : :
522 : : //! Mesh interval firmness for this model entity
523 : : Firmness intervalFirmness;
524 : :
525 : : //! Constrain mesh intervals to be even
526 : : bool constrainEven;
527 : :
528 : : //! Meshed state of this entity
529 : : MeshedState meshedState;
530 : :
531 : : //! MeshOps pointing to this entity
532 : : std::vector<MeshOp*> meshOps;
533 : :
534 : : //! interval assignment variable
535 : : IAVariable *iaVariable;
536 : : };
537 : :
538 : 27001 : inline MKCore *ModelEnt::mk_core() const
539 : : {
540 : 27001 : return mkCore;
541 : : }
542 : :
543 : 46757 : inline iGeom::EntityHandle ModelEnt::geom_handle() const
544 : : {
545 : 46757 : return iGeomEnt;
546 : : }
547 : :
548 : 2481 : inline moab::EntityHandle ModelEnt::mesh_handle() const
549 : : {
550 : 2481 : return moabEntSet;
551 : : }
552 : :
553 : : inline void ModelEnt::children(std::vector<std::vector<moab::EntityHandle> > &child_ents) const
554 : : {
555 : : std::vector<MEntVector> tmp_vec;
556 : : children(tmp_vec);
557 : : std::vector<moab::EntityHandle> tmp_vec2;
558 : : for (std::vector<MEntVector>::iterator vit1 = tmp_vec.begin(); vit1 != tmp_vec.end(); vit1++) {
559 : : tmp_vec2.clear();
560 : : for (MEntVector::iterator vit2 = (*vit1).begin(); vit2 != (*vit1).end(); vit2++)
561 : : tmp_vec2.push_back((*vit2)->mesh_handle());
562 : : child_ents.push_back(tmp_vec2);
563 : : }
564 : : }
565 : :
566 : : /** \brief Return children as vectors of vectors, e.g. for loops or shells
567 : : *
568 : : * No ordered flag, since that's implied by definition
569 : : * \param child_ents Child entities returned
570 : : */
571 : : inline void ModelEnt::children(std::vector<std::vector<iGeom::EntityHandle> > &child_ents) const
572 : : {
573 : : std::vector<MEntVector> tmp_vec;
574 : : children(tmp_vec);
575 : : std::vector<iGeom::EntityHandle> tmp_vec2;
576 : : for (std::vector<MEntVector>::iterator vit1 = tmp_vec.begin(); vit1 != tmp_vec.end(); vit1++) {
577 : : tmp_vec2.clear();
578 : : for (MEntVector::iterator vit2 = (*vit1).begin(); vit2 != (*vit1).end(); vit2++)
579 : : tmp_vec2.push_back((*vit2)->geom_handle());
580 : : child_ents.push_back(tmp_vec2);
581 : : }
582 : : }
583 : :
584 : 1268 : inline int ModelEnt::sizing_function_index() const
585 : : {
586 : 1268 : return sizingFunctionIndex;
587 : : }
588 : :
589 : : //! Get intervals
590 : 596 : inline int ModelEnt::mesh_intervals() const
591 : : {
592 : 596 : return meshIntervals;
593 : : }
594 : :
595 : : //! Set intervals
596 : 580 : inline void ModelEnt::mesh_intervals(int ints)
597 : : {
598 : 580 : meshIntervals = ints;
599 : 580 : }
600 : :
601 : : //! Get firmness
602 : 4 : inline Firmness ModelEnt::interval_firmness() const
603 : : {
604 : 4 : return intervalFirmness;
605 : : }
606 : :
607 : : //! Set firmness
608 : 273 : inline void ModelEnt::interval_firmness(Firmness firm)
609 : : {
610 : 273 : intervalFirmness = firm;
611 : 273 : }
612 : :
613 : 295 : inline bool ModelEnt::constrain_even() const
614 : : {
615 : 295 : return constrainEven;
616 : : }
617 : :
618 : 78 : inline void ModelEnt::constrain_even(bool flag)
619 : : {
620 : 78 : constrainEven = flag;
621 : 78 : }
622 : :
623 : 1196 : inline MeshedState ModelEnt::get_meshed_state()
624 : : {
625 : 1196 : return meshedState;
626 : : }
627 : :
628 : 159 : inline void ModelEnt::set_meshed_state(MeshedState mstate)
629 : : {
630 : 159 : meshedState = mstate;
631 : 159 : }
632 : :
633 : : inline void ModelEnt::evaluate_discrete(double x, double y, double z,
634 : : double *close,
635 : : double *direction,
636 : : double *curvature1,
637 : : double *curvature2) const
638 : : {
639 : : evaluate(x, y, z, close, direction, curvature1, curvature2);
640 : : }
641 : :
642 : : /** \brief Add a MeshOp that points to this ModelEnt
643 : : * \param meshop MeshOp to add
644 : : */
645 : 580 : inline void ModelEnt::add_meshop(MeshOp *meshop)
646 : : {
647 [ + - ][ + - ]: 580 : assert(std::find(meshOps.begin(), meshOps.end(), meshop) == meshOps.end());
[ - + ]
648 : 580 : meshOps.push_back(meshop);
649 : 580 : }
650 : :
651 : : /* \brief Remove a MeshOp that pointed to this ModelEnt
652 : : * \param meshop MeshOp to remove
653 : : */
654 : : inline void ModelEnt::remove_meshop(MeshOp *meshop)
655 : : {
656 : : assert(std::find(meshOps.begin(), meshOps.end(), meshop) != meshOps.end());
657 : : meshOps.erase(std::remove(meshOps.begin(), meshOps.end(), meshop), meshOps.end());
658 : : }
659 : :
660 : : /* \brief Get MeshOps pointing to this ModelEnt
661 : : * \param meshop MeshOps returned
662 : : */
663 : 313 : inline void ModelEnt::get_meshops(std::vector<MeshOp*> &meshops)
664 : : {
665 : 313 : meshops.resize(meshOps.size());
666 : 313 : std::copy(meshOps.begin(), meshOps.end(), meshops.begin());
667 : 313 : }
668 : :
669 : : // TODO: unimplemented functions (these are just here because SWIG expects some
670 : : // implementation!
671 : : inline void ModelEnt::get_adjacencies(int dim, std::vector<iGeom::EntityHandle> &adjs) const {}
672 : : inline void ModelEnt::get_adjacencies(int dim, std::vector<moab::EntityHandle> &adjs) const {}
673 : : inline void ModelEnt::get_adjacencies(int dim, moab::Range &adjs) const {}
674 : : inline void ModelEnt::children(std::vector<MEntVector> &child_ents) const {}
675 : : inline void ModelEnt::children(std::vector<MEntVector> &child_ents) {}
676 : :
677 : : } // namespace meshkit
678 : :
679 : : #endif
|
