Post-processing tools 2024 R1

test_dvs_python_reader_api

Last update: 16.07.2025
Go to the documentation of this file.
1
2
3
6
7# @cond Suppress Doxygen Warnings
8
9
10import dynamic_visualization_store as dvs
11import argparse
12
13parser = argparse.ArgumentParser()
14parser.add_argument("-c", "--cache_uri", help="Provide valid cache uri to read")
15
16args = parser.parse_args()
17cache_uri = args.cache_uri
18
19
20query = dvs.create_query_instance()
21
22
24
25
27
28
29
30print("\n***\n cache_uri = ", cache_uri, "\n***")
31query.add_uri(cache_uri)
32
33dataset_query = query.filter("/dataset.name/eq/dvsnode")
34print("\n***\nSub Query Test\n***")
35numdatasets = dataset_query.get_num_datasets()
36print("\n Number of datasets = ", numdatasets)
37for d in range(numdatasets):
38 dataset = query.get_dataset(d)
39 #print(dir(datasetobj))
40 dataset_name = dataset.get_name()
41 dataset_unit_system = dataset.get_unit_system()
42 print(" Dataset Name: ", dataset_name)
43 print(" Unit System: ", dataset_unit_system)
44 num_ranks = dataset.get_num_ranks()
45 print(" Number of ranks: ", num_ranks)
46 ranks = dataset.get_ranks()
47 for r in range(num_ranks):
48 print(" Rank: ", ranks[r])
49 num_chunks = dataset.get_num_chunks_per_rank()
50 print(" Number of chunks per rank: ", num_chunks)
51 chunks = dataset.get_chunks_per_rank()
52 for c in range(num_chunks):
53 print(" Chunk: ", chunks[c])
54 num_parts = dataset.get_num_parts()
55 print(" Num Parts: ", num_parts)
56 for p in range(num_parts):
57 part = dataset.get_part(p)
58 print(" Part Name: ", part.get_name())
59 num_plots = dataset.get_num_plots()
60 print(" Number of plots: ", num_plots)
61 for p in range(num_plots):
62 plot = dataset.get_plot(p)
63 print(" Plot: ", plot.get_name())
64 num_vars = dataset.get_num_variables()
65 print(" Num variables: ", num_vars)
66 for v in range(num_vars):
67 var = dataset.get_variable(v)
68 print(" Var Name: ", var.get_name())
69part_query = dataset_query.filter("/part.name/eq/volume-volume")
70num_mesh_chunks = part_query.get_num_mesh_chunks()
71print(" Num mesh chunks = ", num_mesh_chunks)
72
73for m in range(num_mesh_chunks):
74 mesh_chunk = part_query.get_mesh_chunk(m)
75 #print(dir(mesh_chunk))
76 if isinstance(mesh_chunk, dvs.IMeshChunkObject):
77 mesh_type = mesh_chunk.get_type()
78 part = mesh_chunk.get_object()
79 time = mesh_chunk.get_time()
80 rank = mesh_chunk.get_rank()
81 chunk = mesh_chunk.get_chunk()
82 coord_hash = mesh_chunk.get_hash()
83 coord_size = 0
84 coord_interleaved = list()
85 x_coords = list()
86 y_coords = list()
87 z_coords = list()
88 local_ijk_min = list()
89 local_ijk_max = list()
90 global_ijk_max = list()
91 # Parallele MeshType
92 origin = list()
93 dir_vec_i = list()
94 dir_vec_j = list()
95 dir_vec_k = list()
96 ivals = list()
97 jvals = list()
98 kvals = list()
99 print("\n***\n Mesh Chunk: ", m, "\n***")
100 print(" Type:{0}, Part:{1}, Rank:{2}, Chunk:{3}, Time:{4}, Hash:{5}".format(mesh_type, part.get_name(), rank, chunk, time, coord_hash))
101 if mesh_type == dvs.MESHCHUNK_UNSTRUCTURED:
102 # Get tuple containing x,y,z coords list
103 result = mesh_chunk.get_coords()
104 coord_size, x_list, y_list, z_list = result
105 x_coords = list(x_list)
106 y_coords = list(y_list)
107 z_coords = list(z_list)
108 print(" \nFirst 3 coordinates out of : ", coord_size)
109 for c in range(3):
110 print(" X: {0}, Y: {1}, Z: {2}".format(x_coords[c], y_coords[c], z_coords[c]))
111 # Get interleaved coords
112 coord_interleaved = mesh_chunk.get_coords_interleaved()
113 coord_size, coords = coord_interleaved
114 print(" \n No. Interleaved coordinates :", coord_size)
115 elif mesh_type == dvs.MESHCHUNK_CURVILIEAR:
116 # Get Tuple containing localIJKMin, localIJKMax, globalIJKMax, x_coords, y_coords, z_coords
117 coords = mesh_chunk.get_coords_curv()
118 coord_size, local_ijk_min_list, local_ijk_max_list, global_ijk_max_list, x_coords_list, y_coords_list, z_coords_list = coords
119 print(" \nCurvilinear coordinates component size :", coord_size)
120 local_ijk_min = list(local_ijk_min_list)
121 local_ijk_max = list(local_ijk_max_list)
122 global_ijk_max = list(global_ijk_max)
123 x_coords = list(x_coords_list)
124 y_coords = list(y_coords_list)
125 z_coords = list(z_coords_list)
126 # Get Interleaved Coordinates
127 coords = mesh_chunk.get_coords_curv_interleaved()
128 coord_size, local_ijk_min_list, local_ijk_max_list, global_ijk_max_list, coords_interleaved_list = coords
129 print(" \nNo. cuvilinear coordinates : ", coord_size)
130 local_ijk_min = list(local_ijk_min_list)
131 local_ijk_max = list(local_ijk_max_list)
132 global_ijk_max = list(global_ijk_max)
133 coord_interleaved = list(coords_interleaved_list)
134 elif mesh_type == dvs.MESHCHUNK_PARALLELEPIPED:
135 # Get Tuple
136 # origin, dir_vec_i, dir_vec_j, dir_vec_k, local_ijk_max, local_ijk_min, global_ijk_max, ivals, jvals, kvals
137 coords = mesh_chunk.get_coords_parallele()
138 origin_list, dir_vec_i_list, dir_vec_j_list, dir_vec_k_list, local_ijk_max_list, local_ijk_min_list, global_ijk_max_list, ivals_list, jvals_list, kvals_list = coords
139 origin = list(origin_list)
140 dir_vec_i = list(dir_vec_i_list)
141 dir_vec_j = list(dir_vec_j_list)
142 dir_vec_k = list(dir_vec_k_list)
143 local_ijk_max = list(local_ijk_max_list)
144 local_ijk_min = list(local_ijk_min_list)
145 global_ijk_max = list(global_ijk_max_list)
146 ivals = list(ivals_list)
147 jvals = list(jvals_list)
148 kvals = list(kvals_list)
149 print(" Origin : ", origin)
150 print(" DirVecI: ", dir_vec_i)
151 print(" DirVecJ: ", dir_vec_j)
152 print(" DirVecK: ", dir_vec_k)
153 print(" LocalIJKMax : ", local_ijk_max)
154 print(" LocalIJKMin : ", local_ijk_min)
155 print(" GlobalIJKMax: ", global_ijk_max)
156
157 num_nodal_vars = mesh_chunk.get_num_variables()
158 print("\n Num Nodal Var: ", num_nodal_vars)
159 for nv in range(num_nodal_vars):
160 var = mesh_chunk.get_variable(nv)
161 #print(dir(var))
162 if isinstance(var, dvs.IVarObject):
163 var_loc = var.get_var_location()
164 var_name = var.get_name()
165 if var_loc == dvs.LOCATION_NODE:
166 # Get Hash by var_index
167 #nodal_var_hash_size_by_index = mesh_chunk.get_var_hash_size_by_var_index(nv)
168 #nodal_var_hash_size_by_def = mesh_chunk.get_var_hash_size_by_var_def(var)
169 #nodal_var_hash_by_index = mesh_chunk.get_var_hash_by_var_index(nv, nodal_var_hash_size_by_index)
170 #nodal_var_hash_by_def = mesh_chunk.get_var_hash_by_var_def(var, nodal_var_hash_size_by_def)
171 #if nodal_var_hash_by_index:
172 # print("Nodal VAR Hash by Index: ", nodal_var_hash_by_index)
173 #if nodal_var_hash_by_index != nodal_var_hash_by_def:
174 # print("Nodal var hash by var index is different that Nodal var hash by def")
175 result = mesh_chunk.get_variable_data(nv)
176 num_values, var_values = result
177 print(" Var Name: {0}, Nodal values: {1}, Mesh Chunk: {2}".format(var_name, num_values, m))
178 print(" First 10 Values: ")
179 for n in range(10):
180 print(" ", var_values[n])
181 # Element Blocks
182 num_elem_blocks = mesh_chunk.get_num_element_blocks()
183 print("\n Num Element Blocks: ", num_elem_blocks)
184
185 element_block_types = mesh_chunk.get_element_block_types()
186 for et in element_block_types:
187 elem_block = mesh_chunk.get_element_block_by_type(et)
188 num_elements = 0
189 conn_size = 0
190 faces_per_elem_size = 0
191 nodes_per_face_size = 0
192 indices_size = 0
193 if isinstance(elem_block, dvs.IElemBlockObject):
194 match elem_block.get_element_type():
195 case dvs.ELEMTYPE_TETRAHEDRON | dvs.ELEMTYPE_TRIANGLE | dvs.ELEMTYPE_QUADRANGLE | dvs.ELEMTYPE_HEXAHEDRON:
196 num_elements = elem_block.get_num_elements()
197 result = elem_block.get_connectivity()
198 connsize, connectivity = result
199 print(" Element Type: Standard")
200 print(" Connectivity Size: ", connsize)
201 for s in range(10):
202 print(" ",connectivity[s])
203 case dvs.ELEMTYPE_N_SIDED_POLYGON | dvs.ELEMTYPE_N_SIDED_POLYGON_GHOST:
204 print(" Element Type : ", elem_block.get_element_type())
205 num_elements = elem_block.get_num_elements()
206 print(" Num Elements : ", num_elements)
207 connectivity = elem_block.get_connectivity_polygon()
208 nodes_per_polygon_size, nodes_per_polygon_list, indices_size, indices_list = connectivity
209 print(" Nodes per Polygon Size: ", nodes_per_polygon_size)
210 print(" Polygon Indices Size : ", indices_size)
211 nodes_per_polygon = list(nodes_per_polygon_list)
212 polygon_indices = list(indices_list)
213 #print(" Nodes Per Polygon: ")
214 #for np in nodes_per_polygon:
215 # print(" ", np)
216 #print(" Polygon Indices : ")
217 #for pi in polygon_indices:
218 # print(" ", pi)
219 case dvs.ELEMTYPE_CONVEX_POLYHEDRON | dvs.ELEMTYPE_CONVEX_POLYHEDRON_GHOST:
220 num_element = elem_block.get_num_elements()
221 print(" Element Type: POLYHEDRON", "Number of elements: ", num_element)
222 # Get connectivity Polyhedral
223 conn_polyhedral = elem_block.get_connectivity_polyhedral()
224 faces_per_elem_size, faces_per_elem_list, nodes_per_face_size, nodes_per_face_list, indices_size, conn_indices_list = conn_polyhedral
225 print(" Faces Per Elem Size :",faces_per_elem_size)
226 print(" Nodes Per Face Size :",nodes_per_face_size)
227 print(" Conn Indices Size :",indices_size)
228 faces_per_elem = list(faces_per_elem_list)
229 nodes_per_face = list(nodes_per_face_list)
230 conn_indices = list(conn_indices_list)
231 #print(" Faces Per Elem: ")
232 #for fp in faces_per_elem:
233 # print(" ", fp)
234 #print(" Nodes Per Face: ")
235 #for nf in nodes_per_face:
236 # print(" ", nf)
237 #print(" Conn Indices : ")
238 #for ci in conn_indices:
239 # print(" ", ci)
240 case dvs.ELEMTYPE_STRUCTURED:
241 num_elements = elem_block.get_num_elements()
242 nodes_per_elem = elem_block.get_nodes_per_element()
243 print(" Structured Element: Type:{0}, NPE:{1}".format(elem_block.get_element_type(), nodes_per_elem))
244 case dvs.ELEMTYPE_UNDEFINED | dvs.ELEMTYPE_UNDEFINED_PARALLELEPIPED | dvs.ELEMTYPE_UNDEFINED_CURVILINEAR:
245 print(" Undefined element type found")
246 case _:
247 print(" Default Element Type")
248 num_elements = elem_block.get_num_elements()
249 nodes_per_elem = elem_block.get_nodes_per_elem()
250 # Get Connectivity List
251 result = elem_block.get_connectivity()
252 connsize, connectivity = result
253 #print(" Print Connectivity: ")
254 #for i in connectivity:
255 # print(" ", i)
256print("\n***\nSub Queries Finished\n***")
257
258
259numtimesteps = query.get_num_timesteps()
260print("\n***\n Num timesteps = ", numtimesteps, "\n***")
261# Get timestep objects
262timesteps = query.get_timesteps()
263for time in timesteps:
264 print(" Time = ", time)
265
266
267numranks = query.get_num_ranks()
268print("\n***\n Number of Ranks: ", numranks, "\n***")
269#Get the unique ranks
270ranks = query.get_ranks()
271for rank in ranks:
272 print(" Rank : ", rank)
273
274
275numchunks_per_rank = query.get_num_chunks_per_rank()
276print("\n***\n Num Chunks Per Rank = ", numchunks_per_rank, "\n***")
277#Get chunks per rank
278#global_chunk_max = [None]*numchunks_per_rank
279global_chunks = query.get_chunks_per_rank()
280for chunk in global_chunks:
281 print(" Chunk: ", chunk)
282
283
284numparts = query.get_num_parts()
285print("\n***\n Number of parts = ", numparts, "\n***")
286for np in range(numparts):
287 part = query.get_part(np)
288 print(" Part {0}:{1} ".format(np+1, part.get_name()))
289
290
291numplots = query.get_num_plots()
292print("\n***\n NumPlots = ", numplots, "\n***")
293for pl in range(numplots):
294 plot = query.get_plot(pl)
295 print(" Plot {0}:{1}".format(pl+1, plot.get_name()))
296
297
298num_vars = query.get_num_variables()
299if num_vars > 0:
300 for nv in range(num_vars):
301 var = query.get_variable(nv)
302 var_name = var.get_name()
303 if isinstance(var, dvs.IVarObject) and var.get_var_location() == dvs.LOCATION_CASE:
304 print(" CASE Variable : ", var.get_name())
305 dataset = query.get_dataset()
306 dataset_name = dataset.get_name()
307 num_values = var.get_component_count_per_value()
308 for time in timesteps:
309 var_values = dataset.get_variable_data(dataset, var, time)
310 print("\nDataset:{0}, Var{1}, Time:{2}, Value{3}".format(dataset_name, var_name, time, var_values(0)))
311
312
313numvars = query.get_num_variables()
314#print("\n***\n Number of vars = ", numvars, "\n***")
315for v in range(numvars):
316 #Get IVar Object
317 varobj = query.get_variable(v)
318 #print(dir(varobj))
319 var_name = varobj.get_name()
320 var_location = varobj.get_var_location()
321 if isinstance(var, dvs.IVarObject) and var_location == dvs.LOCATION_PART:
322 dataset = varobj.get_dataset()
323 dataset_name = dataset.get_name()
324 numparts = dataset.get_num_parts()
325 num_vals = varobj.get_component_count_per_value()
326 for time in timesteps:
327 for p in range(numparts):
328 part = dataset.get_part(p)
329 part_name = part.get_name()
330 var_values = query.get_variable_data(part, varobj, time)
331 print("\n Dataset:{0}, Part{1}, Var{2}, Time:{3}, Value{4}".format(dataset_name, part_name, var_name, time, var_values(0)))
332
333
334print("\n--------------------------------")
335print(" Listing All Datasets for Query")
336print("\n--------------------------------")
337numdatasets = query.get_num_datasets()
338print("\n Number of datasets = ", numdatasets)
339
340for d in range(numdatasets):
341 dataset = query.get_dataset(d)
342 #print(dir(datasetobj))
343 dataset_name = dataset.get_name()
344 dataset_unit_system = dataset.get_unit_system()
345 print(" Dataset Name: ", dataset_name)
346 print(" Unit System: ", dataset_unit_system)
347 num_ranks = dataset.get_num_ranks()
348 print(" Number of ranks: ", num_ranks)
349 ranks = dataset.get_ranks()
350 for r in range(num_ranks):
351 print(" Rank: ", ranks[r])
352 num_chunks = dataset.get_num_chunks_per_rank()
353 print(" Number of chunks per rank: ", num_chunks)
354 chunks = dataset.get_chunks_per_rank()
355 for c in range(num_chunks):
356 print(" Chunk: ", chunks[c])
357 num_parts = dataset.get_num_parts()
358 print(" Num Parts: ", num_parts)
359 for p in range(num_parts):
360 part = dataset.get_part(p)
361 metadata = part.get_metadata()
362 print(" Metadata:", metadata)
363 print(" Part Name: ", part.get_name())
364 num_plots = dataset.get_num_plots()
365 print(" Number of plots: ", num_plots)
366 for p in range(num_plots):
367 plot = dataset.get_plot(p)
368 metadata = plot.get_metadata()
369 print(" Metadata", metadata)
370 print(" Plot: ", plot.get_name())
371 num_vars = dataset.get_num_variables()
372 print(" Num variables: ", num_vars)
373 for v in range(num_vars):
374 var = dataset.get_variable(v)
375 metadata = var.get_metadata()
376 print(" Metadata: ", metadata)
377 print(" Var Name: ", var.get_name())
378
379
380
381
382print("------------------------------------")
383print(" Listing All Mesh Chunks for Query")
384print("------------------------------------")
385num_mesh_chunks = query.get_num_mesh_chunks()
386print(" Num mesh chunks = ", num_mesh_chunks)
387
388for m in range(num_mesh_chunks):
389 mesh_chunk = query.get_mesh_chunk(m)
390 #print(dir(mesh_chunk))
391 if isinstance(mesh_chunk, dvs.IMeshChunkObject):
392 mesh_type = mesh_chunk.get_type()
393 part = mesh_chunk.get_object()
394 time = mesh_chunk.get_time()
395 rank = mesh_chunk.get_rank()
396 chunk = mesh_chunk.get_chunk()
397 coord_hash = mesh_chunk.get_hash()
398 coord_size = 0
399 coord_interleaved = list()
400 x_coords = list()
401 y_coords = list()
402 z_coords = list()
403 local_ijk_min = list()
404 local_ijk_max = list()
405 global_ijk_max = list()
406 # Parallele MeshType
407 origin = list()
408 dir_vec_i = list()
409 dir_vec_j = list()
410 dir_vec_k = list()
411 ivals = list()
412 jvals = list()
413 kvals = list()
414 print("\n***\n Mesh Chunk: ", m, "\n***")
415 print(" Type:{0}, Part:{1}, Rank:{2}, Chunk:{3}, Time:{4}, Hash:{5}".format(mesh_type, part.get_name(), rank, chunk, time, coord_hash))
416 if mesh_type == dvs.MESHCHUNK_UNSTRUCTURED:
417 # Get tuple containing x,y,z coords list
418 result = mesh_chunk.get_coords()
419 coord_size, x_list, y_list, z_list = result
420 x_coords = list(x_list)
421 y_coords = list(y_list)
422 z_coords = list(z_list)
423 print(" \nFirst 3 coordinates out of : ", coord_size)
424 for c in range(3):
425 print(" X: {0}, Y: {1}, Z: {2}".format(x_coords[c], y_coords[c], z_coords[c]))
426 # Get interleaved coords
427 coord_interleaved = mesh_chunk.get_coords_interleaved()
428 coord_size, coords = coord_interleaved
429 print(" \n No. Interleaved coordinates :", coord_size)
430 elif mesh_type == dvs.MESHCHUNK_CURVILIEAR:
431 # Get Tuple containing localIJKMin, localIJKMax, globalIJKMax, x_coords, y_coords, z_coords
432 coords = mesh_chunk.get_coords_curv()
433 coord_size, local_ijk_min_list, local_ijk_max_list, global_ijk_max_list, x_coords_list, y_coords_list, z_coords_list = coords
434 print(" \nCurvilinear coordinates component size :", coord_size)
435 local_ijk_min = list(local_ijk_min_list)
436 local_ijk_max = list(local_ijk_max_list)
437 global_ijk_max = list(global_ijk_max)
438 x_coords = list(x_coords_list)
439 y_coords = list(y_coords_list)
440 z_coords = list(z_coords_list)
441 # Get Interleaved Coordinates
442 coords = mesh_chunk.get_coords_curv()
443 print(" \nNo. cuvilinear coordinates : ", coord_size)
444 coord_size, local_ijk_min_list, local_ijk_max_list, global_ijk_max_list, coords_interleaved_list = coords
445 local_ijk_min = list(local_ijk_min_list)
446 local_ijk_max = list(local_ijk_max_list)
447 global_ijk_max = list(global_ijk_max)
448 coord_interleaved = list(coords_interleaved_list)
449 elif mesh_type == dvs.MESHCHUNK_PARALLELEPIPED:
450 # Get Tuple
451 # origin, dir_vec_i, dir_vec_j, dir_vec_k, local_ijk_max, local_ijk_min, global_ijk_max, ivals, jvals, kvals
452 coords = mesh_chunk.get_coords_parallele()
453 origin_list, dir_vec_i_list, dir_vec_j_list, dir_vec_k_list, local_ijk_max_list, local_ijk_min_list, global_ijk_max_list, ivals_list, jvals_list, kvals_list = coords
454 origin = list(origin_list)
455 dir_vec_i = list(dir_vec_i_list)
456 dir_vec_j = list(dir_vec_j_list)
457 dir_vec_k = list(dir_vec_k_list)
458 local_ijk_max = list(local_ijk_max_list)
459 local_ijk_min = list(local_ijk_min_list)
460 global_ijk_max = list(global_ijk_max_list)
461 ivals = list(ivals_list)
462 jvals = list(jvals_list)
463 kvals = list()
464 print(" Origin : ", origin)
465 print(" DirVecI: ", dir_vec_i)
466 print(" DirVecJ: ", dir_vec_j)
467 print(" DirVecK: ", dir_vec_k)
468 print(" LocalIJKMax : ", local_ijk_max)
469 print(" LocalIJKMin : ", local_ijk_min)
470 print(" GlobalIJKMax: ", global_ijk_max)
471
472 num_nodal_vars = mesh_chunk.get_num_variables()
473 print("\n Num Nodal Var: ", num_nodal_vars)
474 for nv in range(num_nodal_vars):
475 var = mesh_chunk.get_variable(nv)
476 #print(dir(var))
477 if isinstance(var, dvs.IVarObject):
478 var_loc = var.get_var_location()
479 var_name = var.get_name()
480 if var_loc == dvs.LOCATION_NODE:
481 # Get Hash by var_index
482 #nodal_var_hash_size_by_def = mesh_chunk.get_var_hash(var)
483 #if nodal_var_hash_size_by_def:
484 # print("Nodal VAR Hash by Def: ", nodal_var_hash_size_by_def)
485 result = mesh_chunk.get_variable_data(nv)
486 num_values, var_values = result
487 print(" Var Name: {0}, Nodal values: {1}, Mesh Chunk: {2}".format(var_name, num_values, m))
488 print(" First 10 Values: ")
489 for n in range(10):
490 print(" ", var_values[n])
491 # Element Blocks
492 num_elem_blocks = mesh_chunk.get_num_element_blocks()
493 print("\n Num Element Blocks: ", num_elem_blocks)
494
495 element_block_types = mesh_chunk.get_element_block_types()
496 for et in element_block_types:
497 elem_block = mesh_chunk.get_element_block_by_type(et)
498 num_elements = 0
499 conn_size = 0
500 faces_per_elem_size = 0
501 nodes_per_face_size = 0
502 indices_size = 0
503 if isinstance(elem_block, dvs.IElemBlockObject):
504 match elem_block.get_element_type():
505 case dvs.ELEMTYPE_TETRAHEDRON | dvs.ELEMTYPE_TRIANGLE | dvs.ELEMTYPE_QUADRANGLE | dvs.ELEMTYPE_HEXAHEDRON:
506 num_elements = elem_block.get_num_elements()
507 result = elem_block.get_connectivity()
508 connsize, connectivity = result
509 print(" Element Type: ", elem_block.get_element_type())
510 print(" Connectivity Size: ", connsize)
511 for s in range(10):
512 print(" ",connectivity[s])
513 case dvs.ELEMTYPE_N_SIDED_POLYGON | dvs.ELEMTYPE_N_SIDED_POLYGON_GHOST:
514 print(" Element Type : ", elem_block.get_element_type())
515 num_elements = elem_block.get_num_elements()
516 print(" Num Elements : ", num_elements)
517 connectivity = elem_block.get_connectivity_polygon()
518 nodes_per_polygon_size, nodes_per_polygon_list, indices_size, indices_list = connectivity
519 print(" Nodes per Polygon Size: ", nodes_per_polygon_size)
520 print(" Polygon Indices Size : ", indices_size)
521 nodes_per_polygon = list(nodes_per_polygon_list)
522 polygon_indices = list(indices_list)
523 #print(" Nodes Per Polygon: ")
524 #for np in nodes_per_polygon:
525 # print(" ", np)
526 #print(" Polygon Indices : ")
527 #for pi in polygon_indices:
528 # print(" ", pi)
529 case dvs.ELEMTYPE_CONVEX_POLYHEDRON | dvs.ELEMTYPE_CONVEX_POLYHEDRON_GHOST:
530 num_element = elem_block.get_num_elements()
531 print(" Element Type: ",elem_block.get_element_type())
532 print(" Number of elements: ", num_element)
533 # Get connectivity Polyhedral
534 conn_polyhedral = elem_block.get_connectivity_polyhedral()
535 faces_per_elem_size, faces_per_elem_list, nodes_per_face_size, nodes_per_face_list, indices_size, conn_indices_list = conn_polyhedral
536 print(" Faces Per Elem Size :",faces_per_elem_size)
537 print(" Nodes Per Face Size :",nodes_per_face_size)
538 print(" Conn Indices Size :",indices_size)
539 faces_per_elem = list(faces_per_elem_list)
540 nodes_per_face = list(nodes_per_face_list)
541 conn_indices = list(conn_indices_list)
542 #print(" Faces Per Elem: ")
543 #for fp in faces_per_elem:
544 # print(" ", fp)
545 #print(" Nodes Per Face: ")
546 #for nf in nodes_per_face:
547 # print(" ", nf)
548 #print(" Conn Indices : ")
549 #for ci in conn_indices:
550 # print(" ", ci)
551 case dvs.ELEMTYPE_STRUCTURED:
552 num_elements = elem_block.get_num_elements()
553 nodes_per_elem = elem_block.get_nodes_per_element()
554 print(" Structured Element: Type:{0}, NPE:{1}".format(elem_block.get_element_type(), nodes_per_elem))
555 case dvs.ELEMTYPE_UNDEFINED | dvs.ELEMTYPE_UNDEFINED_PARALLELEPIPED | dvs.ELEMTYPE_UNDEFINED_CURVILINEAR:
556 print(" Undefined element type found")
557 case _:
558 print(" Default Element Type")
559 num_elements = elem_block.get_num_elements()
560 nodes_per_elem = elem_block.get_nodes_per_elem()
561 # Get Connectivity List
562 result = elem_block.get_connectivity()
563 connsize, connectivity = result
564 #print(" Print Connectivity: ")
565 #for i in connectivity:
566 # print(" ", i)
567
568print("\n-----------------------------------")
569print(" Listing All Plot Chunks for Query")
570print("-------------------------------------")
571num_plot_chunks = query.get_num_plot_chunks()
572for np in range(num_plot_chunks):
573 plot = query.get_plot_chunk(np)
574 if isinstance(plot, dvs.IPlotChunkObject):
575 plot_def = plot.get_object()
576 plot_name = plot_def.get_name()
577 time = plot.get_time()
578 rank = plot.get_rank()
579 plot_hash = plot.get_hash()
580 print(" Plot Name: ", plot_name)
581 plot_data = plot.get_data()
582 x_values, y_values = plot_data
583 print(" Plot Hash: ", plot_hash)
584 print(" X Values: ")
585 for x in x_values:
586 print(" ", x)
587 print(" Y Values: ")
588 for y in y_values:
589 print(" ", y)
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605

Connect with Ansys