Branch data Line data Source code
1 : : // CAVirtualVG class
2 : :
3 : : #include "CAVirtualVG.hpp"
4 : : #include "CubitSimpleAttrib.hpp"
5 : : #include "TopologyEntity.hpp"
6 : : #include "RefEntity.hpp"
7 : : #include "BasicTopologyEntity.hpp"
8 : : #include "RefEdge.hpp"
9 : : #include "RefVertex.hpp"
10 : : #include "TDUniqueId.hpp"
11 : : #include "CADeferredAttrib.hpp"
12 : :
13 : 10348 : CubitAttrib* CAVirtualVG_creator(RefEntity* entity, const CubitSimpleAttrib &p_csa)
14 : : {
15 [ + - ]: 10348 : return new CAVirtualVG(entity, p_csa);
16 : : }
17 : :
18 : :
19 : 10348 : CAVirtualVG::CAVirtualVG(RefEntity *owner, const CubitSimpleAttrib &simple_attrib)
20 [ + - ][ + - ]: 10348 : : CubitAttrib(owner)
[ + - ]
21 : : {
22 : 10348 : numVC = 0;
23 : 10348 : numVV = 0;
24 : :
25 [ + - ][ - + ]: 10348 : if(!simple_attrib.isEmpty())
26 : : {
27 : : // generate a simple attribute containing the data in this CA
28 [ # # ]: 0 : const std::vector<double> &d_list = simple_attrib.double_data_list();
29 [ # # ]: 0 : const std::vector<int> &i_list = simple_attrib.int_data_list();
30 : :
31 : : // (no string)
32 : :
33 : : // now the integers
34 : : // numVV, numVC
35 : 0 : int offset = 0;
36 [ # # ]: 0 : numVV = i_list[offset++];
37 [ # # ]: 0 : numVC = i_list[offset++];
38 : :
39 : : // vgUIDs
40 : : int i;
41 [ # # ]: 0 : for (i = numVV+(3*numVC); i > 0; i--)
42 [ # # ][ # # ]: 0 : vgUIDs.append(i_list[offset++]);
43 : :
44 : : // numVCPoints
45 : 0 : int sum = 0;
46 [ # # ]: 0 : for (i = numVC; i > 0; i--) {
47 [ # # ]: 0 : int temp_int = i_list[offset++];
48 [ # # ]: 0 : numVCPoints.append(temp_int);
49 : 0 : sum += temp_int;
50 : : }
51 : :
52 : 0 : offset = 0;
53 : : // pointUIDList
54 [ # # ]: 0 : for (i = numVV+sum; i > 0; i--) {
55 [ # # ]: 0 : double x = d_list[offset++];
56 [ # # ]: 0 : double y = d_list[offset++];
57 [ # # ]: 0 : double z = d_list[offset++];
58 [ # # ][ # # ]: 0 : posVector.append(new CubitVector( x, y, z ) );
[ # # ]
59 : : }
60 : :
61 : : // If we are constructing from a CubitSimpleAttrib,
62 : : // then this attrib is already written
63 [ # # ]: 0 : has_written(CUBIT_TRUE);
64 : : }
65 : 10348 : }
66 : :
67 : 10348 : CubitStatus CAVirtualVG::update()
68 : : {
69 : :
70 : : // the owner entity is virtual; put a CAVirtualVG on the underlying entity to represent
71 : : // this entity
72 : :
73 [ - + ]: 10348 : if (hasUpdated) return CUBIT_SUCCESS;
74 : : /*
75 : : assert(attrib_owner() != 0);
76 : :
77 : : TopologyEntity *topo_entity = CAST_TO(attrib_owner(), TopologyEntity);
78 : : assert(topo_entity != 0);
79 : :
80 : : DLIList<VirtualEntity*> ve_list;
81 : : VirtualGeometryEngine::instance()->get_VEs(topo_entity, ve_list, CUBIT_FALSE, CUBIT_FALSE);
82 : :
83 : : for( int i = ve_list.size(); i--; )
84 : : {
85 : : ParasiteEntity *vge = dynamic_cast<ParasiteEntity*>(ve_list.get_and_step());
86 : :
87 : : if (vge == NULL) {
88 : : // this entity isn't a virtual entity - if this entity doesn't have any virtual
89 : : // entities registered, set delete flag, then exit
90 : : if (numVV == 0 && numVC == 0)
91 : : delete_attrib(CUBIT_TRUE);
92 : : else {
93 : : PRINT_DEBUG_90("Keeping CA_VIRTUAL_VG for %s %d\n",
94 : : attrib_owner()->class_name(), attrib_owner()->id());
95 : : hasUpdated = CUBIT_TRUE;
96 : : }
97 : :
98 : : continue;
99 : : }
100 : :
101 : : // ok, we have a virtual entity; first get the underlying entity, and a CAVVG for that
102 : : // entity
103 : : BasicTopologyEntity* bte_ptr = vge->bte_bound_to();
104 : :
105 : : if (!bte_ptr) {
106 : : PRINT_ERROR("Couldn't find underlying BTE for virtual entity %s %d.\n",
107 : : attrib_owner()->class_name(), attrib_owner()->id());
108 : : return CUBIT_FAILURE;
109 : : }
110 : :
111 : : CAVirtualVG *other_CAVVG = (CAVirtualVG *) bte_ptr->get_cubit_attrib(CA_VIRTUAL_VG);
112 : :
113 : : // if that other CAPVG's written flag is set, it's an old one from a
114 : : // previous write and needs to be reset
115 : : if (other_CAVVG->has_written() == CUBIT_TRUE) {
116 : : other_CAVVG->reset();
117 : : other_CAVVG->has_written(CUBIT_FALSE);
118 : : }
119 : :
120 : : // now put virtual geometry-specific data on the attribute
121 : : ParasitePoint *vvertex = CAST_TO(vge, ParasitePoint);
122 : : ParasiteCurve *vcurve = CAST_TO(vge, ParasiteCurve);
123 : : if (vvertex != NULL) {
124 : : // put uids and position on ca
125 : : other_CAVVG->add_vvertex(vvertex);
126 : : other_CAVVG->delete_attrib(CUBIT_FALSE);
127 : : }
128 : :
129 : : else if (vcurve != NULL) {
130 : : other_CAVVG->add_vcurve(vcurve);
131 : : other_CAVVG->delete_attrib(CUBIT_FALSE);
132 : : }
133 : :
134 : : else {
135 : : PRINT_ERROR("Shouldn't get here in CAVirtualVG::update.\n");
136 : : return CUBIT_FAILURE;
137 : : }
138 : : }
139 : :
140 : : hasUpdated = CUBIT_TRUE;
141 : : if (numVV == 0 && numVV == 0) delete_attrib(CUBIT_TRUE);
142 : :
143 : : return CUBIT_SUCCESS;
144 : : */
145 : :
146 : 10348 : delete_attrib(CUBIT_TRUE);
147 : 10348 : return CUBIT_SUCCESS;
148 : : }
149 : :
150 : :
151 : 0 : CubitStatus CAVirtualVG::reset()
152 : : {
153 : : //- reset info; called from CAU and also from update!
154 : 0 : numVV = 0;
155 : 0 : numVC = 0;
156 : : //- the number of virtual points and curves contained in this attr
157 : :
158 : 0 : vgUIDs.clean_out();
159 : : //- unique ids of virtual points and curves contained in this attr
160 : :
161 : 0 : posVector.clean_out();
162 : : //- position vectors for virtual curves
163 : :
164 : 0 : numVCPoints.clean_out();
165 : : //- for each virtual curve, the number of virtual points in that curve
166 : :
167 : 0 : return CUBIT_SUCCESS;
168 : : }
169 : :
170 : 10348 : CubitSimpleAttrib CAVirtualVG::cubit_simple_attrib()
171 : : {
172 : : // generate a simple attribute containing the data in this CA
173 [ + - ]: 10348 : std::vector<CubitString> cs_list;
174 [ + - ][ + - ]: 20696 : std::vector<double> d_list;
175 [ + - ][ + - ]: 20696 : std::vector<int> i_list;
176 : :
177 : : // first the string
178 [ + - ][ + - ]: 10348 : cs_list.push_back(att_internal_name());
[ + - ][ + - ]
179 : :
180 : : // now the integers
181 : : // numVV, numVC
182 [ + - ]: 10348 : i_list.push_back(numVV);
183 [ + - ]: 10348 : i_list.push_back(numVC);
184 : :
185 : : // vgUIDs
186 : : int i;
187 [ + - ]: 10348 : vgUIDs.reset();
188 [ + - ][ - + ]: 10348 : for (i = vgUIDs.size(); i > 0; i--)
189 [ # # ][ # # ]: 0 : i_list.push_back(vgUIDs.get_and_step());
190 : :
191 : : // numVCPoints
192 [ + - ]: 10348 : numVCPoints.reset();
193 [ + - ][ - + ]: 10348 : for (i = numVCPoints.size(); i > 0; i--)
194 [ # # ][ # # ]: 0 : i_list.push_back(numVCPoints.get_and_step());
195 : :
196 : : // now the doubles
197 [ + - ]: 10348 : posVector.reset();
198 [ + - ][ - + ]: 10348 : for (i = posVector.size(); i > 0; i--) {
199 [ # # ][ # # ]: 0 : d_list.push_back(posVector.get()->x());
[ # # ]
200 [ # # ][ # # ]: 0 : d_list.push_back(posVector.get()->y());
[ # # ]
201 [ # # ][ # # ]: 0 : d_list.push_back(posVector.get_and_step()->z());
[ # # ]
202 : : }
203 : :
204 [ + - ][ + - ]: 20696 : return CubitSimpleAttrib(&cs_list, &d_list, &i_list);
205 : : }
206 : :
207 : 0 : CubitStatus CAVirtualVG::actuate()
208 : : {
209 : : // actuate this CA
210 : : /*
211 : : // first, actuate the points, with this CA's owner as their owners
212 : : int i, j;
213 : : vgUIDs.reset();
214 : : posVector.reset();
215 : :
216 : : DLIList<int> leftover_uids, leftover_vcpoints;
217 : : DLIList<CubitVector*> leftover_posvector;
218 : : int leftover_vvs = 0, leftover_vcs = 0;
219 : :
220 : : DLIList<ParasitePoint*> vpoint_list;
221 : : for (i = 0; i < numVV; i++) {
222 : : CubitVector pos_vec(*posVector.get_and_step());
223 : : // make the virtual vertex
224 : : BasicTopologyEntity *bte_ptr = CAST_TO(attrib_owner(), BasicTopologyEntity);
225 : : RefVertex *new_vertex =
226 : : VirtualGeometryEngine::instance()->create_VirtualVertex(pos_vec, bte_ptr);
227 : : // add a unique id to it, for referencing later
228 : : TDUniqueId *uid_ptr = new TDUniqueId(new_vertex, vgUIDs.get());
229 : : CADeferredAttrib::owner_created( new_vertex, vgUIDs.get_and_step() );
230 : :
231 : : if (new_vertex == NULL) {
232 : : PRINT_WARNING("Problems making new vertex with uid = %d.\n", vgUIDs.prev());
233 : : leftover_uids.append(vgUIDs.prev());
234 : : leftover_posvector.append(posVector.prev());
235 : : leftover_vvs++;
236 : : }
237 : : }
238 : :
239 : : // now actuate CAVVG's on lower order entities
240 : : DLIList<RefEntity*> children;
241 : : attrib_owner()->get_child_ref_entities(children);
242 : : for (i = children.size(); i > 0; i--) {
243 : : children.get_and_step()->actuate_cubit_attrib(CA_VIRTUAL_VG);
244 : : }
245 : :
246 : : // now handle creating virtual curves
247 : : numVCPoints.reset();
248 : : DLIList<RefEdge*> vcurve_list;
249 : : for (i = 0; i < numVC; i++) {
250 : : // start by grabbing all the stuff off the attribute's lists
251 : :
252 : : int start_uid = vgUIDs.get_and_step(),
253 : : end_uid = vgUIDs.get_and_step();
254 : :
255 : : // now get the intermediate points; these should all be virtual, and should
256 : : // be in this entity's virtual point list
257 : : DLIList<CubitVector*> vec_list;
258 : : // get the number of virtual points in the list
259 : : int num_points = numVCPoints.get_and_step();
260 : : for (j = 0; j < num_points; j++)
261 : : vec_list.append(posVector.get_and_step());
262 : :
263 : : int virtual_curve_uid = vgUIDs.get_and_step();
264 : :
265 : : // the first two are start and end points, and may not be virtual
266 : : ToolDataUser *tdu = TDUniqueId::find_td_unique_id(start_uid);
267 : : RefVertex *start_vertex = CAST_TO(tdu, RefVertex);
268 : : tdu = TDUniqueId::find_td_unique_id(end_uid);
269 : : RefVertex *end_vertex = CAST_TO(tdu, RefVertex);
270 : :
271 : : if (!start_vertex || !end_vertex) {
272 : : PRINT_DEBUG_90("Couldn't restore virtual curve with uid = %d.\n",
273 : : virtual_curve_uid);
274 : : // cache leftover data for restoring later
275 : : leftover_uids.append(start_uid);
276 : : leftover_uids.append(end_uid);
277 : : leftover_uids.append(virtual_curve_uid);
278 : : leftover_vcpoints.append(num_points);
279 : : leftover_posvector += vec_list;
280 : : leftover_vcs++;
281 : : continue;
282 : : }
283 : :
284 : : // make the virtual curve
285 : : RefEdge *virtual_edge =
286 : : VirtualGeometryEngine::instance()->create_VirtualEdge(start_vertex,
287 : : end_vertex,
288 : : vec_list);
289 : : if (!virtual_edge) {
290 : : PRINT_DEBUG_90("Couldn't restore virtual curve with uid = %d.\n",
291 : : virtual_curve_uid);
292 : : // cache leftover data for restoring later
293 : : leftover_uids.append(start_uid);
294 : : leftover_uids.append(end_uid);
295 : : leftover_uids.append(virtual_curve_uid);
296 : : leftover_vcpoints.append(num_points);
297 : : leftover_posvector += vec_list;
298 : : leftover_vcs++;
299 : : continue;
300 : : }
301 : :
302 : : ParasiteEntity* curve =
303 : : dynamic_cast<ParasiteEntity*>(virtual_edge->get_geometry_entity_ptr());
304 : : assert(curve != NULL);
305 : : curve->bind_to( dynamic_cast<BasicTopologyEntity*>(attrib_owner())
306 : : ->get_geometry_entity_ptr());
307 : :
308 : : // save the curve's unique id
309 : : TDUniqueId *uid_ptr = new TDUniqueId(virtual_edge, virtual_curve_uid);
310 : :
311 : : CADeferredAttrib::owner_created( virtual_edge, virtual_curve_uid );
312 : : //virtual_edge->actuate_cubit_attrib(CA_VIRTUAL_VG);
313 : : //virtual_edge->actuate_cubit_attrib(CA_PARTITION_VG);
314 : : }
315 : :
316 : : if (0 == leftover_vvs && 0 == leftover_vcs)
317 : : hasActuated = CUBIT_TRUE;
318 : : else {
319 : : // have some leftover data - reset data in this attribute
320 : : numVV = leftover_vvs;
321 : : numVC = leftover_vcs;
322 : : vgUIDs = leftover_uids;
323 : : numVCPoints = leftover_vcpoints;
324 : : posVector = leftover_posvector;
325 : : hasActuated = CUBIT_FALSE;
326 : :
327 : : // now add this attribute to the unactuated list in CADA
328 : : CADeferredAttrib::add_unactuated_ca(this);
329 : : }
330 : :
331 : : // we're done
332 : : return (CUBIT_FALSE == hasActuated ?
333 : : CUBIT_FAILURE : CUBIT_SUCCESS);
334 : 0 : */ return CUBIT_FAILURE;
335 [ + - ][ + - ]: 6364 : }
336 : :
337 : : /*
338 : : void CAVirtualVG::add_vvertex(ParasitePoint *vpoint)
339 : : {
340 : :
341 : : TopologyEntity *vpoint_topo_entity = vpoint->topology_entity();
342 : : RefVertex *owning_vertex = CAST_TO(vpoint_topo_entity, RefVertex);
343 : : assert(owning_vertex != 0);
344 : : int vvertex_uid = TDUniqueId::get_unique_id(owning_vertex);
345 : :
346 : : //- adds data for this vpoint to this CA
347 : : numVV++;
348 : : vgUIDs.insert_first(vvertex_uid);
349 : : posVector.insert_first(new CubitVector(vpoint->coordinates()));
350 : : }
351 : : */
352 : : /*
353 : : void CAVirtualVG::add_vcurve(ParasiteCurve *vcurve)
354 : : {
355 : : // need to get list of vpoint uids defining the virtual curve
356 : : // the owner should be a RefEdge
357 : : TopologyEntity *vcurve_topo_entity = vcurve->topology_entity();
358 : : RefEdge *virtual_edge = CAST_TO(vcurve_topo_entity, RefEdge);
359 : : assert(virtual_edge != 0);
360 : :
361 : : // first get start and end points, and their uids
362 : : DLIList<int> uid_list;
363 : : RefVertex *temp_vertex = virtual_edge->start_vertex();
364 : : int start_uid = TDUniqueId::get_unique_id(temp_vertex);
365 : : vgUIDs.append(start_uid);
366 : : temp_vertex = virtual_edge->end_vertex();
367 : : int end_uid = TDUniqueId::get_unique_id(temp_vertex);
368 : : vgUIDs.append(end_uid);
369 : :
370 : : // now get the other points and their uids
371 : : DLIList<ParasitePoint*> vpoint_list;
372 : : vcurve->getSegments(vpoint_list);
373 : : vpoint_list.reset();
374 : :
375 : : for (int i = vpoint_list.size(); i > 0; i--) {
376 : : ParasitePoint *temp_point = vpoint_list.get_and_step();
377 : : posVector.append(new CubitVector(temp_point->coordinates()));
378 : : }
379 : :
380 : : int owner_uid = TDUniqueId::get_unique_id(virtual_edge);
381 : :
382 : : //- adds data for this vcurve to this CA
383 : : vgUIDs.append(owner_uid);
384 : : numVCPoints.append(vpoint_list.size());
385 : : numVC++;
386 : : }
387 : :
388 : : */
389 : :
|
