Post-processing tools 2025 R1

test_dvs_client

Last update: 16.07.2025
Go to the documentation of this file.
1/* *************************************************************
2 * Copyright 2017-2024 ANSYS, Inc.
3 * All Rights Reserved.
4 *
5 * Restricted Rights Legend
6 *
7 * Use, duplication, or disclosure of this
8 * software and its documentation by the
9 * Government is subject to restrictions as
10 * set forth in subdivision [(b)(3)(ii)] of
11 * the Rights in Technical Data and Computer
12 * Software clause at 52.227-7013.
13 * *************************************************************
14 */
15
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27#include <stdint.h>
28#include <stdarg.h>
29
30#include "dynamic_visualization_store_api.h"
31#include "dynamic_visualization_store_enums.h"
32#include "test_dynamic_data.h"
33
34#ifdef _WIN32
35#include <Windows.h>
36#else
37#include <unistd.h>
38#endif
39
40#ifndef M_PI
41# define M_PI 3.141592653589793238462643383279502884
42#endif
43
44static void logging_function(void* user_data, const char* message)
45{
46 fprintf(stderr, message);
47}
48
56int main(int argc, char** argv)
57{
58 uint32_t port = 50055;
59 uint32_t msec_delay = 0;
60 char host[512] = {0};
61 strcpy(host, "127.0.0.1");
62 char protocol[10] = {0};
63 strcpy(protocol, "grpc");
64 uint32_t width = 50;
65 uint32_t height = 50;
66 uint32_t depth = 50;
67 uint32_t max_timesteps = 10;
68 uint32_t current_rank = 0;
69 uint32_t total_ranks = 1;
70 uint8_t create_ghosts = 1;
71 uint8_t block_for_server = 1;
72 uint8_t block_for_reinit = 1;
73 uint32_t starting_timestep = 0;
74 uint32_t dedup = 1;
75 uint32_t send_structured_parts = 0;
76 char dataset_id[255] = {0};
77 strcpy(dataset_id, "Test-C-API");
78 char secret[255] = {0};
79 uint32_t plot_rank = 0;
80 uint32_t server_number = 0;
81 uint32_t server_verbosity = 0;
82 uint32_t local_ranks = 0;
83 uint32_t all_defs = 0;
84 char cache_uri[512] = {0};
85 uint32_t log_all = 0;
86 uint32_t debug_wait = 0;
87 uint32_t start_server = 0;
88 uint32_t test_reinit = 0;
89 uint32_t reinit_parts = 0;
90 uint32_t reinit_plots = 0;
91 uint32_t reinit_vars = 0;
92 uint32_t time_period = 0;
93 uint32_t test_iblanking = 0;
94 char dvs_file_loc[1024] = {0};
95 uint32_t test_delete = 0;
96 uint32_t rm_int64 = 0;
97 uint32_t generate_rbm = 0;
98
99 uint32_t i = 1;
100 while (i < argc)
101 {
102 if ((strcmp(argv[i], "-p") == 0 ) && (i < argc - 1))
103 {
104 i++;
105 port = atoi(argv[i]);
106 }
107 else if ((strcmp(argv[i], "-h") == 0) && (i < argc - 1))
108 {
109 i++;
110 strncpy(host, argv[i], sizeof(host)-1);
111 }
112 else if ((strcmp(argv[i], "-protocol") == 0) && (i < argc - 1))
113 {
114 i++;
115 strncpy(protocol, argv[i], sizeof(protocol)-1);
116 if (strcmp(protocol, "grpc") != 0 && strcmp(protocol, "null") != 0 )
117 {
118 fprintf(stderr, "protocol: %s invalid\n", protocol);
119 exit(1);
120 }
121 }
122 else if ((strcmp(argv[i], "-d") == 0) && (i < argc - 1))
123 {
124 i++;
125 msec_delay = atoi(argv[i]);
126 }
127 else if ((strcmp(argv[i], "-s") == 0) && (i < argc - 3))
128 {
129 i++;
130 width = atoi(argv[i++]);
131 height = atoi(argv[i++]);
132 depth = atoi(argv[i]);
133 }
134 else if ((strcmp(argv[i], "-t") == 0) && (i < argc - 1))
135 {
136 i++;
137 max_timesteps = atoi(argv[i]);
138 }
139 else if ((strcmp(argv[i], "-r") == 0) && (i < argc - 2))
140 {
141 i++;
142 current_rank = atoi(argv[i++]);
143 total_ranks = atoi(argv[i]);
144 }
145 else if (strcmp(argv[i], "-noghost") == 0)
146 {
147 create_ghosts = 0;
148 }
149 else if (strcmp(argv[i], "-nowait") == 0)
150 {
151 block_for_server = 0;
152 }
153 else if(strcmp(argv[i], "-generate_rbm") == 0){
154 generate_rbm = 1;
155 }
156 else if ((strcmp(argv[i], "-start") == 0) && (i < argc - 1))
157 {
158 i++;
159 starting_timestep = atoi(argv[i]);
160 }
161 else if (strcmp(argv[i], "-nodedup") == 0)
162 {
163 dedup = 0;
164 }
165 else if (strcmp(argv[i], "-id") == 0)
166 {
167 i++;
168 memset(dataset_id, 0, 255);
169 strncpy(dataset_id, argv[i], sizeof(dataset_id)-1);
170 }
171 else if (strcmp(argv[i], "-secret") == 0)
172 {
173 i++;
174 strncpy(secret, argv[i], sizeof(secret)-1);
175 }
176 else if (strcmp(argv[i], "-structured") == 0)
177 {
178 send_structured_parts = 1;
179 }
180 else if (strcmp(argv[i], "-iblank") == 0)
181 {
182 test_iblanking = 1;
183 }
184 else if (strcmp(argv[i], "-plot_rank") == 0)
185 {
186 i++;
187 plot_rank = atoi(argv[i]);
188 }
189 else if (strcmp(argv[i], "-server") == 0 && (i < argc - 3))
190 {
191 i++;
192 start_server = 1;
193 server_number = atoi(argv[i++]);
194 local_ranks = atoi(argv[i++]);
195 server_verbosity = atoi(argv[i]);
196 }
197 else if (strcmp(argv[i], "-cache_uri") == 0)
198 {
199 i++;
200 strncpy(cache_uri, argv[i], sizeof(cache_uri)-1);
201 }
202 else if (strcmp(argv[i], "-all_defs") == 0)
203 {
204 all_defs = 1;
205 }
206 else if (strcmp(argv[i], "-log_all") == 0)
207 {
208 log_all = 1;
209 }
210 else if (strcmp(argv[i], "-debug_wait") == 0)
211 {
212 i++;
213 debug_wait = atoi(argv[i]);
214 }
215 else if (strcmp(argv[i], "-reinit_vars") == 0)
216 {
217 test_reinit = 1;
218 reinit_vars = 1;
219 }
220 else if (strcmp(argv[i], "-reinit_parts") == 0)
221 {
222 test_reinit = 1;
223 reinit_parts = 1;
224 }
225 else if (strcmp(argv[i], "-reinit_plots") == 0)
226 {
227 test_reinit = 1;
228 reinit_plots = 1;
229 }
230 else if (strcmp(argv[i], "-reinit_all") == 0)
231 {
232 test_reinit = 1;
233 reinit_parts = 1;
234 reinit_vars = 1;
235 reinit_plots = 1;
236 }
237 else if (strcmp(argv[i], "-time_period") == 0)
238 {
239 i++;
240 time_period = atoi(argv[i]);
241 }
242 else if (strcmp(argv[i], "-dvs_file") == 0)
243 {
244 i++;
245 strncpy(dvs_file_loc, argv[i], sizeof(dvs_file_loc)-1);
246 }
247 else if (strcmp(argv[i], "-test_delete") == 0)
248 {
249 test_delete = 1;
250 }
251 else if (strcmp(argv[i], "-rm_int64") == 0)
252 {
253 rm_int64 = 1;
254 }
255 else
256 {
257 fprintf(stderr, "Unknown option: %s\n", argv[i]);
258 fprintf(stderr, "Usage: %s [-p port] [-h host] [-d msec_delay] [-t num_timesteps] [-s dx dy dz] [-noghost] [-nowait] [-start t]\n", argv[0]);
259 fprintf(stderr, "Options:\n");
260 fprintf(stderr, " -t timesteps Number of timesteps to generate. Default: %u\n", max_timesteps);
261 fprintf(stderr, " -p port Server port to connect to. Default: %u\n", port);
262 fprintf(stderr, " -h host Server hostname to connect to. Default: %s\n", host);
263 fprintf(stderr, " -protocol str Server protocol. I.E. grpc or null. Default: grpc");
264 fprintf(stderr, " -d delay Number of milliseconds to delay between timestep pushes. Default: %u\n", msec_delay);
265 fprintf(stderr, " -s dx dy dz Size of 3D hex grid (width height depth) Default: %u %u %u\n", width, height, depth);
266 fprintf(stderr, " -r x y Rank information x=current rank (0 based), y=total number of ranks. Default: %u %u\n", current_rank, total_ranks);
267 fprintf(stderr, " -noghost Do not create ghost elements\n");
268 fprintf(stderr, " -nowait Do not wait for server to be available\n");
269 fprintf(stderr, " -start t Begin timesteps with timestep Default: %u\n", starting_timestep);
270 fprintf(stderr, " -nodedup Do not de-duplicate data on the client side Default: deduplicate\n");
271 fprintf(stderr, " -id string Set an id/name for the dataset Default: TestID\n");
272 fprintf(stderr, " -secret string Shared secret to use when talking with server Default: no shared secret\n");
273 fprintf(stderr, " -structured Turn on sending structured part data Default: Don't send structured part data\n");
274 fprintf(stderr, " -plot_rank Set the rank which should send plot data to EnSight (zero based) Default: %u\n", plot_rank);
275 fprintf(stderr, " -server n r v Start a server using server number [n], expecting [r] local ranks for DVS connections to connect to with verbosity [v]. Local Rank Min/Max: 1/1000\n");
276 fprintf(stderr, " -cache_uri str The URI for the server to use for the cache. Default: No cache\n");
277 fprintf(stderr, " -all_defs Send all part/var definitions no matter the current rank. Default: No\n");
278 fprintf(stderr, " -log_all Print out all client logging information\n. Default: No client logs");
279 fprintf(stderr, " -debug_wait ms Wait for [ms] for debugging\n");
280 fprintf(stderr, " -reinit_vars Test reinit vars\n");
281 fprintf(stderr, " -reinit_parts Test reinit parts\n");
282 fprintf(stderr, " -reinit_plots Test reinit plots\n");
283 fprintf(stderr, " -reinit_all Test all reinit\n");
284 fprintf(stderr, " -time_period p Set modulus for time value to test timestep overwrite\n");
285 fprintf(stderr, " -dvs_file str Set a location for the dvs files to be created Default :./\n");
286 fprintf(stderr, " -test_delete Test deleting all timesteps before each update Default: Do not test\n");
287 fprintf(stderr, " -rm_int64 Eliminate int64");
288 fprintf(stderr, " -generate_rbm Generate test rigid body motion");
289 exit(1);
290 }
291 i++;
292 }
293
294 if (debug_wait > 0)
295 {
296 #ifdef _WIN32
297 Sleep(debug_wait);
298 #else
299 usleep(debug_wait*1000);
300 #endif
301 }
302
303 fprintf(stderr, "Current Library Version: %s\n", dvs_get_version());
304 char uri[512] = {0};
305 sprintf(uri, "%s://%s:%u", protocol, host, port);
306 fprintf(stderr, "Connecting to: %s\n", uri);
307 fprintf(stderr, "Timestep delay: %u\n", msec_delay);
308
309 uint32_t send_vars = 1;
310 uint32_t send_elems = 1;
311 uint32_t send_hex_elems = 1;
312 uint32_t send_nfaced_elems = 1;
313 uint32_t send_pnt_elems = 1;
314 uint32_t send_tri_quad_elems = 1;
315 uint32_t send_nsided_elems = 0;
316 uint32_t send_plots = 1;
317
318 enum dvs_client_flags flags;
319 if (block_for_server) flags |= BLOCK_FOR_SERVER;
320 if (dedup) flags |= DEDUP;
321 if (block_for_reinit) flags |= BEGIN_INIT_WAIT_ON_REINIT;
322
323 fprintf(stderr, "Client Flags: Blocking: %d, Dedup: %u\n", (BLOCK_FOR_SERVER & flags) > 0, (DEDUP & flags) > 0);
324
325 int32_t server_id = -1;
326 dvs_server_create(uri, &server_id);
327 if (start_server)
328 {
329 //The below calls are only needed if creating the server locally in this process
330 char temp[10];
331 snprintf(temp, 10, "%u", server_verbosity);
332 dvs_server_set_option(server_id, "VERBOSE",temp);
333 if (strlen(cache_uri) > 0) dvs_server_set_option(server_id, "CACHE_URI",cache_uri);
334 if (strlen(dvs_file_loc) > 0) dvs_server_set_option(server_id, "DVS_FILE_LOCATION", dvs_file_loc);
335 if (strlen(secret) > 0) dvs_server_set_option(server_id, "SERVER_SECURITY_SECRET", secret);
336 //Non-default values to make sure they are being set
337 dvs_server_set_option(server_id, "GRPC_MAX_NUM_RETRIES", "2");
338 dvs_server_set_option(server_id, "GRPC_BACKOFF_MIN_MS", "120");
339 dvs_server_set_option(server_id, "GRPC_BACKOFF_MAX_MS", "300");
340 dvs_server_set_option(server_id, "GRPC_BACKOFF_LINEAR_MS", "150");
341 dvs_server_start(server_id, server_number, local_ranks);
342 dvs_ret err = DVS_NONE;
343 uint32_t uri_size = 0;
344 err = dvs_server_get_uri(server_id, NULL, &uri_size);
345 if (err == DVS_NONE && uri_size > 0){
346 char* my_uri = (char*)malloc (uri_size * sizeof(char));
347 dvs_server_get_uri(server_id, my_uri, &uri_size);
348 fprintf(stderr, "The URI for the server is: %s\n", my_uri);
349 free(my_uri);
350 }
351 else{
352 fprintf(stderr, "Error getting the server URI\n");
353 exit(1);
354 }
355 }
356 int32_t session_id = -1;
357 if (dvs_connect(server_id, flags, secret, &session_id) != 0)
358 {
359 fprintf(stderr, "Error making connection to server\n");
360 exit(1);
361 }
362
363 enum dvs_log_flags log_flags = log_all == 0 ? LOG_UPDATE_BEG_END : LOG_ALL;
364 dvs_register_log_func(session_id, NULL, &logging_function, log_flags);
365
366 {
367 if (part_info_num != 7 || var_info_num != 9)
368 {
369 fprintf(stderr, "This pseudo client code relies on part infos == 7 and var infos == 9, needs modified otherwise\n");
370 exit(1);
371 }
372
373 struct TestDynamicData test;
374 test_dynamic_data_init(&test, 0, current_rank, total_ranks);
375 dvs_begin_init(session_id, dataset_id, test.current_rank, test.total_ranks, test.num_chunks);
376 dvs_set_unit_system(session_id, test.unit_system);
377 dvs_add_metadata(session_id, test.metadata_keys, test.metadata_vals, test.metadata_num_pairs);
378
379 //TODO: Have this done in only the 0th rank once merging definitions is finished
380 if (send_plots && current_rank == plot_rank) dvs_add_plot_info(session_id, test.plots, plot_info_num);
381
382 if ((total_ranks == 1) || (total_ranks == 2) || all_defs != 0)
383 {
384 //If one rank or two ranks and first rank send everything (tests second rank having no definitions)
385 if (current_rank == 0 || all_defs != 0)
386 {
387 dvs_add_part_info(session_id, test.parts, part_info_num);
388 dvs_add_var_info(session_id, test.vars, var_info_num);
389 }
390 }
391 else if (total_ranks == 3)
392 {
393 //If 3 ranks splitup definition data between first 2 ranks
394 //the last rank will not have any (will receive data from others)
395 if (current_rank == 0)
396 {
397 //Send part 0
398 dvs_add_part_info(session_id, test.parts, 1);
399 //Send vars 0->1
400 dvs_add_var_info(session_id, test.vars, 2);
401 }
402 else if (current_rank == 1)
403 {
404 //Send parts 1->2
405 dvs_add_part_info(session_id, &test.parts[1], part_info_num-1);
406 //Send vars 2->5
407 dvs_add_var_info(session_id, &test.vars[2], var_info_num - 2);
408 }
409 //Third rank will have empty definitions which should be filled in
410 }
411 else if (total_ranks > 3)
412 {
413 //If more than 3 ranks splitup data between first 3 ranks
414 //other 3 ranks will not have any (will receive data from others)
415 if (current_rank == 0)
416 {
417 //Send part 0
418 dvs_add_part_info(session_id, test.parts, 1);
419 //Send vars 0->1
420 dvs_add_var_info(session_id, test.vars, 2);
421 }
422 else if (current_rank == 1)
423 {
424 //Send part 1
425 dvs_add_part_info(session_id, &test.parts[1], 1);
426 //Send parts 2->3
427 dvs_add_var_info(session_id, &test.vars[2], 2);
428 }
429 else if (current_rank == 2)
430 {
431 //Send part 2
432 dvs_add_part_info(session_id, &test.parts[2], part_info_num-2);
433 //Send parts 4->5
434 dvs_add_var_info(session_id, &test.vars[4], var_info_num - 4);
435 }
436 }
437 else
438 {
439 //Situation not currently handled exit out
440 fprintf(stderr, "Bad Initialization of Ranks\n");
441 exit(1);
442 }
443
444 {
445 uint32_t num_part_info = dvs_get_num_part_info(session_id);
446 for (uint32_t i = 0; i < num_part_info; i++)
447 {
448 const struct dvs_part_info* part_info = dvs_get_part_info(session_id, i);
449 if (part_info) fprintf(stderr, "Part: %s ID: %u\n", part_info->_name, part_info->_id);
450 }
451
452 uint32_t num_var_info = dvs_get_num_var_info(session_id);
453 for (uint32_t i = 0; i < num_var_info; i++)
454 {
455 const struct dvs_var_info* var_info = dvs_get_var_info(session_id, i);
456 if (var_info) fprintf(stderr, "Var: %s ID: %u\n", var_info->_name, var_info->_id);
457 }
458
459 uint32_t num_plot_info = dvs_get_num_plot_info(session_id);
460 for (uint32_t i = 0; i < num_plot_info; i++)
461 {
462 const struct dvs_plot_info* plot_info = dvs_get_plot_info(session_id, i);
463 if (plot_info) fprintf(stderr, "Plot: %s ID: %u\n", plot_info->_name, plot_info->_id);
464 }
465 }
466
467 dvs_end_init(session_id);
468 }
469
470 uint32_t update_num = 0;
471
472 for (uint32_t i = starting_timestep; i < max_timesteps; i++)
473 {
474 if (i > 1 + starting_timestep && msec_delay)
475 {
476 #ifdef _WIN32
477 Sleep(msec_delay);
478 #else
479 usleep(msec_delay*1000);
480 #endif
481 }
482 if (test_delete && i != starting_timestep) {
483 fprintf(stderr, "Rank: %i of %i Deleting Item\n", (current_rank+1), total_ranks);
484 dvs_delete_item(session_id, update_num++, current_rank, "/timestep.time/gte/0.0");
485 }
486 fprintf(stderr, "Rank: %i of %i Sending Timestep: %i of %i\n", (current_rank), total_ranks, (i), max_timesteps-1);
487
488 struct TestDynamicData test;
489 test_dynamic_data_init(&test, i, current_rank, total_ranks);
490 test.ghosts = create_ghosts;
491 test_dynamic_data_create_mesh_and_elements(&test, width, height, depth);
492
493 float solution_time = test.time;
494 if (time_period > 0) {
495 solution_time = (float)(i%time_period);
496 }
497 dvs_begin_update(session_id, update_num++, current_rank, test.current_chunk, solution_time);
498
499 if (send_structured_parts)
500 {
501 dvs_update_nodes_parallelepiped
502 (
503 session_id,
504 test.parts[5]._id,
505 test.pp_global_ijk_max,
506 test.pp_local_ijk_min,
507 test.pp_local_ijk_max,
508 test.pp_origin,
509 test.pp_unit_vec_i,
510 test.pp_unit_vec_j,
511 test.pp_unit_vec_k,
512 test.pp_i_vals,
513 test.pp_j_vals,
514 test.pp_k_vals
515 );
516
517 dvs_update_nodes_curvilinear
518 (
519 session_id,
520 test.parts[6]._id,
521 test.curv_global_ijk_max,
522 test.curv_local_ijk_min,
523 test.curv_local_ijk_max,
524 test.curv_x_vals,
525 test.curv_y_vals,
526 test.curv_z_vals
527 );
528 }
529
530 if (send_hex_elems) dvs_update_nodes(session_id, test.parts[0]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
531 if (send_pnt_elems) dvs_update_nodes(session_id, test.parts[1]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
532 if (send_nfaced_elems) dvs_update_nodes(session_id, test.parts[2]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
533 if (send_tri_quad_elems) dvs_update_nodes(session_id, test.parts[3]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
534 if (send_nsided_elems) dvs_update_nodes(session_id, test.parts[4]._id, test.polymesh_x_coords, test.polymesh_y_coords, test.polymesh_z_coords, test.polymesh_coords_size);
535
536 if (send_elems)
537 {
538 if (send_hex_elems)
539 {
540 dvs_update_elements(session_id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_coords, test.mesh_hex_elem_coords_size);
541 if (test.mesh_hex_ghost_elem_coords_size > 0)
542 {
543 dvs_update_elements(session_id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_coords, test.mesh_hex_ghost_elem_coords_size);
544 }
545 }
546
547 if (send_nfaced_elems)
548 {
549 dvs_update_elements_polyhedral
550 (
551 session_id,
552 test.parts[2]._id,
553 CONVEX_POLYHEDRON,
554 test.mesh_nfaced_hex_elem_faces_per_elem,
555 test.mesh_nfaced_hex_elem_faces_per_elem_size,
556 test.mesh_nfaced_hex_elem_nodes_per_face,
557 test.mesh_nfaced_hex_elem_nodes_per_face_size,
558 test.mesh_nfaced_hex_elem_coords,
559 test.mesh_nfaced_hex_elem_coords_size
560 );
561 if (test.mesh_nfaced_hex_ghost_elem_coords_size > 0)
562 {
563 dvs_update_elements_polyhedral
564 (
565 session_id,
566 test.parts[2]._id,
567 CONVEX_POLYHEDRON_GHOST,
568 test.mesh_nfaced_hex_ghost_elem_faces_per_elem,
569 test.mesh_nfaced_hex_ghost_elem_faces_per_elem_size,
570 test.mesh_nfaced_hex_ghost_elem_nodes_per_face,
571 test.mesh_nfaced_hex_ghost_elem_nodes_per_face_size,
572 test.mesh_nfaced_hex_ghost_elem_coords,
573 test.mesh_nfaced_hex_ghost_elem_coords_size
574 );
575 }
576 }
577
578 if (send_nsided_elems && current_rank == 0)
579 {
580 //Only send if current rank is 0 as we aren't
581 //splitting this part up based on rank
582 dvs_update_elements_polygon
583 (
584 session_id,
585 test.parts[4]._id,
586 N_SIDED_POLYGON,
587 test.polymesh_elem_nodes_per_face,
588 test.polymesh_elem_nodes_per_face_size,
589 test.polymesh_elem_nodes,
590 test.polymesh_elem_nodes_size
591 );
592 }
593
594 if (send_pnt_elems) dvs_update_elements(session_id, test.parts[1]._id, PNT, test.mesh_point_elem_coords, test.mesh_point_elem_coords_size);
595
596 if (send_tri_quad_elems)
597 {
598 dvs_update_elements(session_id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_coords, test.mesh_quad_elem_coords_size);
599 dvs_update_elements(session_id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_coords, test.mesh_tri_elem_coords_size);
600 }
601 }
602
603 if (send_vars)
604 {
605 //Case vars not working correctly with DVS
606 dvs_update_var_case_scalar(session_id, test.vars[6]._id, test.case_var_value);
607 dvs_update_var_part_scalar(session_id, test.vars[4]._id, test.parts[0]._id, test.part_scalar[0]);
608 dvs_update_var_part_scalar(session_id, test.vars[4]._id, test.parts[1]._id, test.part_scalar[1]);
609 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_var_scalar, test.mesh_hex_elem_var_scalar_size);
610 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_var_rank_scalar, test.mesh_hex_elem_var_rank_scalar_size);
611
612 //N-FACED Elements use the same elemental vars for now as hex elements
613 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[2]._id, CONVEX_POLYHEDRON, test.mesh_hex_elem_var_scalar, test.mesh_hex_elem_var_scalar_size);
614 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[2]._id, CONVEX_POLYHEDRON, test.mesh_hex_elem_var_rank_scalar, test.mesh_hex_elem_var_rank_scalar_size);
615
616 if (send_structured_parts)
617 {
618 dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[5]._id, STRUCTURED, test.structured_elem_var_scalar, test.structured_elem_var_scalar_size);
619 dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[5]._id, STRUCTURED, test.structured_elem_var_scalar_rank, test.structured_elem_var_scalar_rank_size);
620
621 dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[6]._id, STRUCTURED, test.structured_elem_var_scalar, test.structured_elem_var_scalar_size);
622 dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[6]._id, STRUCTURED, test.structured_elem_var_scalar_rank, test.structured_elem_var_scalar_rank_size);
623
624 if (test.structured_elem_ghosts_size > 0)
625 {
626 dvs_update_var_element_scalar(session_id, DVS_STRUCTURED_GHOST_ELEMENTS, test.parts[5]._id, STRUCTURED, test.structured_elem_ghosts, test.structured_elem_ghosts_size);
627 dvs_update_var_element_scalar(session_id, DVS_STRUCTURED_GHOST_ELEMENTS, test.parts[6]._id, STRUCTURED, test.structured_elem_ghosts, test.structured_elem_ghosts_size);
628 }
629 }
630
631 if (test.mesh_hex_ghost_elem_var_scalar_size > 0)
632 {
633 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_var_scalar, test.mesh_hex_ghost_elem_var_scalar_size);
634 //N-FACED Elements use the same elemental vars for now as hex elements
635 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[2]._id, CONVEX_POLYHEDRON_GHOST, test.mesh_hex_ghost_elem_var_scalar, test.mesh_hex_ghost_elem_var_scalar_size);
636 }
637 if (test.mesh_hex_ghost_elem_var_rank_scalar_size > 0)
638 {
639 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_var_rank_scalar, test.mesh_hex_ghost_elem_var_rank_scalar_size);
640 //N-FACED Elements use the same elemental vars for now as hex elements
641 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[2]._id, CONVEX_POLYHEDRON_GHOST, test.mesh_hex_ghost_elem_var_rank_scalar, test.mesh_hex_ghost_elem_var_rank_scalar_size);
642 }
643
644 if (send_pnt_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[1]._id, PNT, test.mesh_point_elem_var_rank_scalar, test.mesh_point_elem_var_rank_scalar_size);
645
646 if (send_nfaced_elems) dvs_update_var_element_vector(session_id, test.vars[3]._id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_var_vector, test.mesh_hex_elem_var_vector_size);
647 if (test.mesh_hex_ghost_elem_var_vector_size > 0)
648 {
649 if (send_nfaced_elems) dvs_update_var_element_vector(session_id, test.vars[3]._id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_var_vector, test.mesh_hex_ghost_elem_var_vector_size);
650 }
651
652 if (send_tri_quad_elems)
653 {
654 dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_var_scalar, test.mesh_quad_elem_var_scalar_size);
655 dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_var_rank_scalar, test.mesh_quad_elem_var_rank_scalar_size);
656 if(!rm_int64) {
657 // Update Elem IDs as scalar variable
658 dvs_update_var_element_scalar_int64(session_id, test.vars[7]._id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_var_scalar_int64, test.mesh_quad_elem_var_scalar_int64_size);
659 // Update IDs of elements
660 dvs_update_var_element_scalar_int64(session_id, DVS_ELEMENT_ID, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_var_scalar_int64, test.mesh_quad_elem_var_scalar_int64_size);
661 }
662 dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_var_scalar, test.mesh_tri_elem_var_scalar_size);
663 dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_var_rank_scalar, test.mesh_tri_elem_var_rank_scalar_size);
664 if(!rm_int64) {
665 // Update Elem IDs as scalar variable
666 dvs_update_var_element_scalar_int64(session_id, test.vars[7]._id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_var_scalar_int64, test.mesh_tri_elem_var_scalar_int64_size);
667 // Update IDs of elements
668 dvs_update_var_element_scalar_int64(session_id, DVS_ELEMENT_ID, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_var_scalar_int64, test.mesh_tri_elem_var_scalar_int64_size);
669 }
670 }
671
672 dvs_update_var_node_scalar(session_id, test.vars[0]._id, test.parts[0]._id, test.mesh_node_var_scalar, test.mesh_node_var_scalar_size);
673 dvs_update_var_node_vector(session_id, test.vars[1]._id, test.parts[0]._id, test.mesh_node_var_vector, test.mesh_node_var_vector_size);
674 dvs_update_var_node_scalar(session_id, test.vars[0]._id, test.parts[2]._id, test.mesh_node_var_scalar, test.mesh_node_var_scalar_size);
675 dvs_update_var_node_vector(session_id, test.vars[1]._id, test.parts[2]._id, test.mesh_node_var_vector, test.mesh_node_var_vector_size);
676 if(!rm_int64) {
677 // Update assigned nodal ids as scalar using 64bit api
678 dvs_update_var_node_scalar_int64(session_id, test.vars[8]._id, test.parts[0]._id, test.mesh_node_var_scalar_int64, test.mesh_node_var_scalar_int64_size);
679 dvs_update_var_node_scalar_int64(session_id, test.vars[8]._id, test.parts[2]._id, test.mesh_node_var_scalar_int64, test.mesh_node_var_scalar_int64_size);
680 // Update assigned nodal ids as NODE ID variable (DVS_NODE_ID)
681 // Note that the number of values and IDs are still INT32 as EnSight can't handle 64bit values
682 dvs_update_var_node_scalar_int64(session_id, DVS_NODE_ID, test.parts[0]._id, test.mesh_node_var_scalar_int64, test.mesh_node_var_scalar_int64_size);
683 dvs_update_var_node_scalar_int64(session_id, DVS_NODE_ID, test.parts[2]._id, test.mesh_node_var_scalar_int64, test.mesh_node_var_scalar_int64_size);
684 }
685
686 if (send_structured_parts)
687 {
688 dvs_update_var_node_scalar(session_id, test.vars[0]._id, test.parts[5]._id, test.structured_nodal_scalar, test.structured_nodal_scalar_size);
689 dvs_update_var_node_scalar(session_id, test.vars[0]._id, test.parts[6]._id, test.structured_nodal_scalar, test.structured_nodal_scalar_size);
690 if (test_iblanking)
691 {
692 dvs_update_var_node_scalar(session_id, DVS_STRUCTURED_IBLANKED_NODES, test.parts[5]._id, test.structured_nodal_iblanked, test.structured_nodal_iblanked_size);
693 dvs_update_var_node_scalar(session_id, DVS_STRUCTURED_IBLANKED_NODES, test.parts[6]._id, test.structured_nodal_iblanked, test.structured_nodal_iblanked_size);
694 }
695 }
696 }
697
698 if (send_plots && current_rank == plot_rank)
699 {
700 dvs_update_plot(session_id, test.plots[0]._id, test.plot_x_values[0], test.plot_y_values[0], test.plot_num_values);
701 dvs_update_plot(session_id, test.plots[1]._id, test.plot_x_values[1], test.plot_y_values[1], test.plot_num_values);
702 dvs_update_plot(session_id, test.plots[2]._id, test.plot_x_values[2], test.plot_y_values[2], test.plot_num_values);
703 }
704
705 if (generate_rbm){
706 float axisStart[3] = {0, 0, -1};
707 float axisEnd[3] = {0, 0, 1};
708 float relative_rotation_angle = M_PI * update_num / 10;
709 float displacement[3] = {0.3*update_num, 0.3*update_num, 0.3*update_num};
710 float quaternion[4];
711 dvs_convert_rotation_to_quaternion(session_id, axisStart, axisEnd, relative_rotation_angle, quaternion);
712
713 dvs_add_part_rigid_body_motion(
714 session_id,
715 update_num,
716 test.parts[0]._id,
717 quaternion,
718 displacement,
719 NULL
720 );
721 }
722
723 dvs_end_update(session_id);
724
725 test_dynamic_data_free(&test);
726 }
727
728 //Can do 1 timestep at a time with previous changes now
729 int reinit_num_timesteps = 1;
730 if (test_reinit)
731 {
732 for (uint32_t reinit_iter = 0; reinit_iter < 3; reinit_iter++)
733 {
734 fprintf(stderr, "Rank: %i beginning reinit iter: %i\n", current_rank, reinit_iter);
735 struct TestDynamicData test;
736 test_dynamic_data_init(&test, 0, current_rank, total_ranks);
737 dvs_begin_init(session_id, dataset_id, test.current_rank, test.total_ranks, test.num_chunks);
738 dvs_set_unit_system(session_id, test.unit_system);
739 //TODO: Have this done in only the 0th rank once merging definitions is finished
740 if (send_plots && current_rank == plot_rank) dvs_add_plot_info(session_id, test.plots, plot_info_num);
741 if (send_plots && current_rank == plot_rank && reinit_plots) dvs_add_plot_info(session_id, test.reinit_plots, reinit_iter+1);
742
743 if (reinit_parts) dvs_add_part_info(session_id, test.reinit_parts, reinit_iter+1);
744
745 if ((total_ranks == 1) || (total_ranks == 2) || all_defs != 0)
746 {
747 //If one rank or two ranks and first rank send everything (tests second rank having no definitions)
748 if (current_rank == 0 || all_defs != 0)
749 {
750 dvs_add_part_info(session_id, test.parts, part_info_num);
751 //Don't send the last var as it is to test re-initializing
752 dvs_add_var_info(session_id, test.vars, var_info_num);
753
754 if (reinit_vars) dvs_add_var_info(session_id, test.reinit_case_vars, reinit_iter+1);
755 if (send_vars && reinit_vars) dvs_add_var_info(session_id, test.reinit_part_vars, reinit_iter+1);
756 if (send_vars && reinit_vars) dvs_add_var_info(session_id, test.reinit_vars, reinit_iter+1);
757 }
758 }
759 else if (total_ranks == 3)
760 {
761 //If 3 ranks splitup definition data between first 2 ranks
762 //the last rank will not have any (will receive data from others)
763 if (current_rank == 0)
764 {
765 //Send part 0
766 dvs_add_part_info(session_id, test.parts, 1);
767 //Send vars 0->1
768 dvs_add_var_info(session_id, test.vars, 2);
769
770 if (reinit_vars) dvs_add_var_info(session_id, test.reinit_case_vars, 1);
771 if (send_vars && reinit_vars) dvs_add_var_info(session_id, test.reinit_vars, reinit_iter+1);
772 }
773 else if (current_rank == 1)
774 {
775 //Send parts 1->2
776 dvs_add_part_info(session_id, &test.parts[1], 4);
777 //Send vars 2->5
778 dvs_add_var_info(session_id, &test.vars[2], var_info_num - 1);
779
780 if (reinit_vars) dvs_add_var_info(session_id, test.reinit_case_vars, reinit_iter+2);
781 if (send_vars && reinit_vars) dvs_add_var_info(session_id, test.reinit_part_vars, reinit_iter+1);
782 }
783 //Third rank will have empty definitions which should be filled in
784 }
785 else if (total_ranks > 3)
786 {
787 //If more than 3 ranks splitup data between first 3 ranks
788 //other 3 ranks will not have any (will receive data from others)
789 if (current_rank == 0)
790 {
791 //Send part 0
792 dvs_add_part_info(session_id, test.parts, 1);
793 //Send vars 0->1
794 dvs_add_var_info(session_id, test.vars, 2);
795
796 if (send_vars && reinit_vars && reinit_iter >= 0) dvs_add_var_info(session_id, &test.reinit_part_vars[0], 1);
797 if (send_vars && reinit_vars) dvs_add_var_info(session_id, test.reinit_vars, reinit_iter+1);
798 }
799 else if (current_rank == 1)
800 {
801 //Send part 1
802 dvs_add_part_info(session_id, &test.parts[1], 1);
803 //Send parts 2->3
804 dvs_add_var_info(session_id, &test.vars[2], 2);
805
806 if (send_vars && reinit_vars && reinit_iter >= 1) dvs_add_var_info(session_id, &test.reinit_part_vars[1], 1);
807 }
808 else if (current_rank == 2)
809 {
810 //Send part 2
811 dvs_add_part_info(session_id, &test.parts[2], 3);
812 //Send parts 4->5
813 dvs_add_var_info(session_id, &test.vars[4], var_info_num - 1);
814
815 if (reinit_vars) dvs_add_var_info(session_id, test.reinit_case_vars, reinit_iter+1);
816 if (send_vars && reinit_vars && reinit_iter >= 2) dvs_add_var_info(session_id, &test.reinit_part_vars[2], 1);
817 }
818 }
819 else
820 {
821 //Situation not currently handled exit out
822 fprintf(stderr, "Bad Initialization of Ranks\n");
823 exit(1);
824 }
825
826 dvs_end_init(session_id);
827 //Push 2 more timesteps
828 for (uint32_t i = max_timesteps + (reinit_iter * reinit_num_timesteps); i < max_timesteps + ((reinit_iter+1) * reinit_num_timesteps); i++)
829 {
830 if (i > 1 + starting_timestep && msec_delay)
831 {
832 #ifdef _WIN32
833 Sleep(msec_delay);
834 #else
835 usleep(msec_delay*1000);
836 #endif
837 }
838 fprintf
839 (
840 stderr, "Rank: %i of %i Sending Timestep: %i of %i, Reinit: %i\n",
841 (current_rank),
842 total_ranks,
843 i,
844 max_timesteps + ((reinit_iter+1) * reinit_num_timesteps)-1,
845 reinit_iter
846 );
847
848 struct TestDynamicData test;
849 test_dynamic_data_init(&test, i, current_rank, total_ranks);
850 test.ghosts = create_ghosts;
851 test_dynamic_data_create_mesh_and_elements(&test, width, height, depth);
852
853 dvs_begin_update(session_id, update_num++, current_rank, test.current_chunk, test.time);
854
855 if (send_hex_elems) dvs_update_nodes(session_id, test.parts[0]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
856 if (send_pnt_elems) dvs_update_nodes(session_id, test.parts[1]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
857 if (send_nfaced_elems) dvs_update_nodes(session_id, test.parts[2]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
858 if (send_tri_quad_elems) dvs_update_nodes(session_id, test.parts[3]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
859 if (send_nsided_elems) dvs_update_nodes(session_id, test.parts[4]._id, test.polymesh_x_coords, test.polymesh_y_coords, test.polymesh_z_coords, test.polymesh_coords_size);
860
861 if (send_elems)
862 {
863 if (send_hex_elems)
864 {
865 dvs_update_elements(session_id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_coords, test.mesh_hex_elem_coords_size);
866 if (test.mesh_hex_ghost_elem_coords_size > 0)
867 {
868 dvs_update_elements(session_id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_coords, test.mesh_hex_ghost_elem_coords_size);
869 }
870 }
871
872 if (send_nfaced_elems)
873 {
874 dvs_update_elements_polyhedral
875 (
876 session_id,
877 test.parts[2]._id,
878 CONVEX_POLYHEDRON,
879 test.mesh_nfaced_hex_elem_faces_per_elem,
880 test.mesh_nfaced_hex_elem_faces_per_elem_size,
881 test.mesh_nfaced_hex_elem_nodes_per_face,
882 test.mesh_nfaced_hex_elem_nodes_per_face_size,
883 test.mesh_nfaced_hex_elem_coords,
884 test.mesh_nfaced_hex_elem_coords_size
885 );
886 if (test.mesh_nfaced_hex_ghost_elem_coords_size > 0)
887 {
888 dvs_update_elements_polyhedral
889 (
890 session_id,
891 test.parts[2]._id,
892 CONVEX_POLYHEDRON_GHOST,
893 test.mesh_nfaced_hex_ghost_elem_faces_per_elem,
894 test.mesh_nfaced_hex_ghost_elem_faces_per_elem_size,
895 test.mesh_nfaced_hex_ghost_elem_nodes_per_face,
896 test.mesh_nfaced_hex_ghost_elem_nodes_per_face_size,
897 test.mesh_nfaced_hex_ghost_elem_coords,
898 test.mesh_nfaced_hex_ghost_elem_coords_size
899 );
900 }
901 }
902
903 if (send_nsided_elems && current_rank == 0)
904 {
905 //Only send if current rank is 0 as we aren't
906 //splitting this part up based on rank
907 dvs_update_elements_polygon
908 (
909 session_id,
910 test.parts[4]._id,
911 N_SIDED_POLYGON,
912 test.polymesh_elem_nodes_per_face,
913 test.polymesh_elem_nodes_per_face_size,
914 test.polymesh_elem_nodes,
915 test.polymesh_elem_nodes_size
916 );
917 }
918
919 if (send_pnt_elems) dvs_update_elements(session_id, test.parts[1]._id, PNT, test.mesh_point_elem_coords, test.mesh_point_elem_coords_size);
920
921 if (send_tri_quad_elems)
922 {
923 dvs_update_elements(session_id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_coords, test.mesh_quad_elem_coords_size);
924 dvs_update_elements(session_id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_coords, test.mesh_tri_elem_coords_size);
925 }
926 }
927
928 if (send_vars)
929 {
930 //Case vars not working correctly with DVS
931 dvs_update_var_case_scalar(session_id, test.vars[6]._id, test.case_var_value);
932 if (reinit_vars && reinit_iter >= 0) dvs_update_var_case_scalar(session_id, test.reinit_case_vars[0]._id, (test.case_var_value*-1.f));
933 if (reinit_vars && reinit_iter >= 1) dvs_update_var_case_scalar(session_id, test.reinit_case_vars[1]._id, (test.case_var_value*-1.f)-10.f);
934 if (reinit_vars && reinit_iter >= 2) dvs_update_var_case_scalar(session_id, test.reinit_case_vars[2]._id, (test.case_var_value*-1.f)-20.f);
935 dvs_update_var_part_scalar(session_id, test.vars[4]._id, test.parts[0]._id, test.part_scalar[0]);
936 dvs_update_var_part_scalar(session_id, test.vars[4]._id, test.parts[1]._id, test.part_scalar[1]);
937 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_var_scalar, test.mesh_hex_elem_var_scalar_size);
938 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_var_rank_scalar, test.mesh_hex_elem_var_rank_scalar_size);
939
940 //N-FACED Elements use the same elemental vars for now as hex elements
941 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[2]._id, CONVEX_POLYHEDRON, test.mesh_hex_elem_var_scalar, test.mesh_hex_elem_var_scalar_size);
942 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[2]._id, CONVEX_POLYHEDRON, test.mesh_hex_elem_var_rank_scalar, test.mesh_hex_elem_var_rank_scalar_size);
943
944 if (test.mesh_hex_ghost_elem_var_scalar_size > 0)
945 {
946 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_var_scalar, test.mesh_hex_ghost_elem_var_scalar_size);
947 //N-FACED Elements use the same elemental vars for now as hex elements
948 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[2]._id, CONVEX_POLYHEDRON_GHOST, test.mesh_hex_ghost_elem_var_scalar, test.mesh_hex_ghost_elem_var_scalar_size);
949 }
950 if (test.mesh_hex_ghost_elem_var_rank_scalar_size > 0)
951 {
952 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_var_rank_scalar, test.mesh_hex_ghost_elem_var_rank_scalar_size);
953 //N-FACED Elements use the same elemental vars for now as hex elements
954 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[2]._id, CONVEX_POLYHEDRON_GHOST, test.mesh_hex_ghost_elem_var_rank_scalar, test.mesh_hex_ghost_elem_var_rank_scalar_size);
955 }
956
957 if (send_pnt_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[1]._id, PNT, test.mesh_point_elem_var_rank_scalar, test.mesh_point_elem_var_rank_scalar_size);
958
959 if (send_nfaced_elems) dvs_update_var_element_vector(session_id, test.vars[3]._id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_var_vector, test.mesh_hex_elem_var_vector_size);
960 if (test.mesh_hex_ghost_elem_var_vector_size > 0)
961 {
962 if (send_nfaced_elems) dvs_update_var_element_vector(session_id, test.vars[3]._id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_var_vector, test.mesh_hex_ghost_elem_var_vector_size);
963 }
964
965 if (send_tri_quad_elems)
966 {
967 dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_var_scalar, test.mesh_quad_elem_var_scalar_size);
968 dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_var_rank_scalar, test.mesh_quad_elem_var_rank_scalar_size);
969 if(!rm_int64) {
970 // Update Elem IDs as scalar variable
971 dvs_update_var_element_scalar_int64(session_id, test.vars[7]._id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_var_scalar_int64, test.mesh_quad_elem_var_scalar_int64_size);
972 // Update IDs of elements
973 dvs_update_var_element_scalar_int64(session_id, DVS_ELEMENT_ID, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_var_scalar_int64, test.mesh_quad_elem_var_scalar_int64_size);
974 }
975 dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_var_scalar, test.mesh_tri_elem_var_scalar_size);
976 dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_var_rank_scalar, test.mesh_tri_elem_var_rank_scalar_size);
977
978 if(!rm_int64) {
979 // Update Elem IDs as scalar variable
980 dvs_update_var_element_scalar_int64(session_id, test.vars[7]._id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_var_scalar_int64, test.mesh_tri_elem_var_scalar_int64_size);
981 // Update IDs of elements
982 dvs_update_var_element_scalar_int64(session_id, DVS_ELEMENT_ID, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_var_scalar_int64, test.mesh_tri_elem_var_scalar_int64_size);
983 }
984 }
985
986 dvs_update_var_node_scalar(session_id, test.vars[0]._id, test.parts[0]._id, test.mesh_node_var_scalar, test.mesh_node_var_scalar_size);
987 dvs_update_var_node_vector(session_id, test.vars[1]._id, test.parts[0]._id, test.mesh_node_var_vector, test.mesh_node_var_vector_size);
988 dvs_update_var_node_scalar(session_id, test.vars[0]._id, test.parts[2]._id, test.mesh_node_var_scalar, test.mesh_node_var_scalar_size);
989 dvs_update_var_node_vector(session_id, test.vars[1]._id, test.parts[2]._id, test.mesh_node_var_vector, test.mesh_node_var_vector_size);
990 if(!rm_int64) {
991 // Update assigned nodal ids as scalar using 64bit api
992 dvs_update_var_node_scalar_int64(session_id, test.vars[8]._id, test.parts[0]._id, test.mesh_node_var_scalar_int64, test.mesh_node_var_scalar_int64_size);
993 dvs_update_var_node_scalar_int64(session_id, test.vars[8]._id, test.parts[2]._id, test.mesh_node_var_scalar_int64, test.mesh_node_var_scalar_int64_size);
994 // Update assigned nodal ids as NODE ID variable (DVS_NODE_ID4)
995 // Note that the number of values and IDs are still INT32 as EnSight can't handle 64bit values
996 dvs_update_var_node_scalar_int64(session_id, DVS_NODE_ID, test.parts[0]._id, test.mesh_node_var_scalar_int64, test.mesh_node_var_scalar_int64_size);
997 dvs_update_var_node_scalar_int64(session_id, DVS_NODE_ID, test.parts[2]._id, test.mesh_node_var_scalar_int64, test.mesh_node_var_scalar_int64_size);
998 }
999 }
1000
1001 if (send_plots && current_rank == plot_rank)
1002 {
1003 dvs_update_plot(session_id, test.plots[0]._id, test.plot_x_values[0], test.plot_y_values[0], test.plot_num_values);
1004 dvs_update_plot(session_id, test.plots[1]._id, test.plot_x_values[1], test.plot_y_values[1], test.plot_num_values);
1005 dvs_update_plot(session_id, test.plots[2]._id, test.plot_x_values[2], test.plot_y_values[2], test.plot_num_values);
1006 if (reinit_plots && reinit_iter >= 0) dvs_update_plot(session_id, test.reinit_plots[0]._id, test.plot_x_values[0], test.plot_y_values[0], test.plot_num_values);
1007 if (reinit_plots && reinit_iter >= 1) dvs_update_plot(session_id, test.reinit_plots[1]._id, test.plot_x_values[1], test.plot_y_values[1], test.plot_num_values);
1008 if (reinit_plots && reinit_iter >= 2) dvs_update_plot(session_id, test.reinit_plots[2]._id, test.plot_x_values[2], test.plot_y_values[2], test.plot_num_values);
1009 }
1010 dvs_end_update(session_id);
1011
1012 test_dynamic_data_free(&test);
1013 }
1014 }
1015 }
1016
1017 //Don't look below here, thar be dragons (this whole thing needs moved to python)
1018 /*
1019 if (test_reinit)
1020 {
1021 reinit_num_timesteps = 1;
1022 uint32_t current_part_id = 1000;
1023 uint32_t current_plot_id = 2000;
1024 uint32_t current_var_id = 3000;
1025 for (uint32_t reinit_iter = 3; reinit_iter < 50; reinit_iter++)
1026 {
1027 fprintf(stderr, "Rank: %i beginning reinit iter: %i\n", current_rank, reinit_iter);
1028 struct TestDynamicData test;
1029 test_dynamic_data_init(&test, 0, current_rank, total_ranks);
1030 dvs_begin_init(session_id, dataset_id, test.current_rank, test.total_ranks, test.num_chunks);
1031 dvs_set_unit_system(session_id, test.unit_system);
1032
1033 if (send_plots && current_rank == plot_rank && reinit_plots)
1034 {
1035 struct dvs_plot_info plot_info;
1036 memset(&plot_info, 0, sizeof(plot_info));
1037 plot_info._id = current_plot_id++;
1038 char plot_name[1000];
1039 sprintf(plot_name, "Reinit-Plot-%u\0", current_plot_id-1);
1040 plot_info._name = strdup(plot_name);
1041
1042 dvs_add_plot_info(session_id, &plot_info, 1);
1043 free(plot_info._name);
1044 }
1045
1046 if (reinit_parts)
1047 {
1048 struct dvs_part_info part_info;
1049 memset(&part_info, 0, sizeof(part_info));
1050 part_info._id = current_part_id++;
1051 char part_name[1000];
1052 sprintf(part_name, "Reinit-Part-%u\0", current_part_id-1);
1053 part_info._name = strdup(part_name);
1054 dvs_add_part_info(session_id, &part_info, 1);
1055 free(part_info._name);
1056 }
1057
1058 if (reinit_vars)
1059 {
1060 struct dvs_var_info var_info;
1061 memset(&var_info, 0, sizeof(var_info));
1062
1063 var_info._id = current_var_id++;
1064 char var_name[1000];
1065 sprintf(var_name, "Reinit-Var-%u\0", current_var_id-1);
1066 var_info._name = strdup(var_name);
1067 var_info._location = NODE;
1068 var_info._type = SCALAR;
1069 dvs_add_var_info(session_id, &var_info, 1);
1070 free(var_info._name);
1071 }
1072
1073 dvs_end_init(session_id);
1074 //Push 2 more timesteps
1075 for (uint32_t i = max_timesteps + (reinit_iter * reinit_num_timesteps); i < max_timesteps + ((reinit_iter+1) * reinit_num_timesteps); i++)
1076 {
1077 if (i > 1 + starting_timestep && msec_delay)
1078 {
1079 #ifdef _WIN32
1080 Sleep(msec_delay);
1081 #else
1082 usleep(msec_delay*1000);
1083 #endif
1084 }
1085 fprintf
1086 (
1087 stderr, "Rank: %i of %i Sending Timestep: %i of %i, Reinit: %i\n",
1088 (current_rank),
1089 total_ranks,
1090 i,
1091 max_timesteps + ((reinit_iter+1) * reinit_num_timesteps)-1,
1092 reinit_iter
1093 );
1094
1095 struct TestDynamicData test;
1096 test_dynamic_data_init(&test, i, current_rank, total_ranks);
1097 test.ghosts = create_ghosts;
1098 test_dynamic_data_create_mesh_and_elements(&test, width, height, depth);
1099
1100 dvs_begin_update(session_id, update_num++, current_rank, test.current_chunk, test.time);
1101
1102 if (send_hex_elems) dvs_update_nodes(session_id, test.parts[0]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
1103 if (send_pnt_elems) dvs_update_nodes(session_id, test.parts[1]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
1104 if (send_nfaced_elems) dvs_update_nodes(session_id, test.parts[2]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
1105 if (send_tri_quad_elems) dvs_update_nodes(session_id, test.parts[3]._id, test.mesh_x_coords, test.mesh_y_coords, test.mesh_z_coords, test.mesh_coords_size);
1106 if (send_nsided_elems) dvs_update_nodes(session_id, test.parts[4]._id, test.polymesh_x_coords, test.polymesh_y_coords, test.polymesh_z_coords, test.polymesh_coords_size);
1107
1108 if (send_elems)
1109 {
1110 if (send_hex_elems)
1111 {
1112 dvs_update_elements(session_id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_coords, test.mesh_hex_elem_coords_size);
1113 if (test.mesh_hex_ghost_elem_coords_size > 0)
1114 {
1115 dvs_update_elements(session_id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_coords, test.mesh_hex_ghost_elem_coords_size);
1116 }
1117 }
1118
1119 if (send_nfaced_elems)
1120 {
1121 dvs_update_elements_polyhedral
1122 (
1123 session_id,
1124 test.parts[2]._id,
1125 CONVEX_POLYHEDRON,
1126 test.mesh_nfaced_hex_elem_faces_per_elem,
1127 test.mesh_nfaced_hex_elem_faces_per_elem_size,
1128 test.mesh_nfaced_hex_elem_nodes_per_face,
1129 test.mesh_nfaced_hex_elem_nodes_per_face_size,
1130 test.mesh_nfaced_hex_elem_coords,
1131 test.mesh_nfaced_hex_elem_coords_size
1132 );
1133 if (test.mesh_nfaced_hex_ghost_elem_coords_size > 0)
1134 {
1135 dvs_update_elements_polyhedral
1136 (
1137 session_id,
1138 test.parts[2]._id,
1139 CONVEX_POLYHEDRON_GHOST,
1140 test.mesh_nfaced_hex_ghost_elem_faces_per_elem,
1141 test.mesh_nfaced_hex_ghost_elem_faces_per_elem_size,
1142 test.mesh_nfaced_hex_ghost_elem_nodes_per_face,
1143 test.mesh_nfaced_hex_ghost_elem_nodes_per_face_size,
1144 test.mesh_nfaced_hex_ghost_elem_coords,
1145 test.mesh_nfaced_hex_ghost_elem_coords_size
1146 );
1147 }
1148 }
1149
1150 if (send_nsided_elems && current_rank == 0)
1151 {
1152 //Only send if current rank is 0 as we aren't
1153 //splitting this part up based on rank
1154 dvs_update_elements_polygon
1155 (
1156 session_id,
1157 test.parts[4]._id,
1158 N_SIDED_POLYGON,
1159 test.polymesh_elem_nodes_per_face,
1160 test.polymesh_elem_nodes_per_face_size,
1161 test.polymesh_elem_nodes,
1162 test.polymesh_elem_nodes_size
1163 );
1164 }
1165
1166 if (send_pnt_elems) dvs_update_elements(session_id, test.parts[1]._id, PNT, test.mesh_point_elem_coords, test.mesh_point_elem_coords_size);
1167
1168 if (send_tri_quad_elems)
1169 {
1170 dvs_update_elements(session_id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_coords, test.mesh_quad_elem_coords_size);
1171 dvs_update_elements(session_id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_coords, test.mesh_tri_elem_coords_size);
1172 }
1173 }
1174
1175 if (send_vars)
1176 {
1177 //Case vars not working correctly with DVS
1178 if (send_case_vars) dvs_update_var_case_scalar(session_id, test.vars[6]._id, test.case_var_value);
1179 if (send_case_vars && reinit_vars && reinit_iter >= 0) dvs_update_var_case_scalar(session_id, test.reinit_case_vars[0]._id, (test.case_var_value*-1.f));
1180 if (send_case_vars && reinit_vars && reinit_iter >= 1) dvs_update_var_case_scalar(session_id, test.reinit_case_vars[1]._id, (test.case_var_value*-1.f)-10.f);
1181 if (send_case_vars && reinit_vars && reinit_iter >= 2) dvs_update_var_case_scalar(session_id, test.reinit_case_vars[2]._id, (test.case_var_value*-1.f)-20.f);
1182 dvs_update_var_part_scalar(session_id, test.vars[4]._id, test.parts[0]._id, test.part_scalar[0]);
1183 dvs_update_var_part_scalar(session_id, test.vars[4]._id, test.parts[1]._id, test.part_scalar[1]);
1184 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_var_scalar, test.mesh_hex_elem_var_scalar_size);
1185 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_var_rank_scalar, test.mesh_hex_elem_var_rank_scalar_size);
1186
1187 //N-FACED Elements use the same elemental vars for now as hex elements
1188 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[2]._id, CONVEX_POLYHEDRON, test.mesh_hex_elem_var_scalar, test.mesh_hex_elem_var_scalar_size);
1189 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[2]._id, CONVEX_POLYHEDRON, test.mesh_hex_elem_var_rank_scalar, test.mesh_hex_elem_var_rank_scalar_size);
1190
1191 if (test.mesh_hex_ghost_elem_var_scalar_size > 0)
1192 {
1193 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_var_scalar, test.mesh_hex_ghost_elem_var_scalar_size);
1194 //N-FACED Elements use the same elemental vars for now as hex elements
1195 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[2]._id, CONVEX_POLYHEDRON_GHOST, test.mesh_hex_ghost_elem_var_scalar, test.mesh_hex_ghost_elem_var_scalar_size);
1196 }
1197 if (test.mesh_hex_ghost_elem_var_rank_scalar_size > 0)
1198 {
1199 if (send_hex_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_var_rank_scalar, test.mesh_hex_ghost_elem_var_rank_scalar_size);
1200 //N-FACED Elements use the same elemental vars for now as hex elements
1201 if (send_nfaced_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[2]._id, CONVEX_POLYHEDRON_GHOST, test.mesh_hex_ghost_elem_var_rank_scalar, test.mesh_hex_ghost_elem_var_rank_scalar_size);
1202 }
1203
1204 if (send_pnt_elems) dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[1]._id, PNT, test.mesh_point_elem_var_rank_scalar, test.mesh_point_elem_var_rank_scalar_size);
1205
1206 if (send_nfaced_elems) dvs_update_var_element_vector(session_id, test.vars[3]._id, test.parts[0]._id, HEXAHEDRON, test.mesh_hex_elem_var_vector, test.mesh_hex_elem_var_vector_size);
1207 if (test.mesh_hex_ghost_elem_var_vector_size > 0)
1208 {
1209 if (send_nfaced_elems) dvs_update_var_element_vector(session_id, test.vars[3]._id, test.parts[0]._id, HEXAHEDRON_GHOST, test.mesh_hex_ghost_elem_var_vector, test.mesh_hex_ghost_elem_var_vector_size);
1210 }
1211
1212 if (send_tri_quad_elems)
1213 {
1214 dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_var_scalar, test.mesh_quad_elem_var_scalar_size);
1215 dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[3]._id, QUADRANGLE, test.mesh_quad_elem_var_rank_scalar, test.mesh_quad_elem_var_rank_scalar_size);
1216 dvs_update_var_element_scalar(session_id, test.vars[2]._id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_var_scalar, test.mesh_tri_elem_var_scalar_size);
1217 dvs_update_var_element_scalar(session_id, test.vars[5]._id, test.parts[3]._id, TRIANGLE, test.mesh_tri_elem_var_rank_scalar, test.mesh_tri_elem_var_rank_scalar_size);
1218 }
1219
1220 dvs_update_var_node_scalar(session_id, test.vars[0]._id, test.parts[0]._id, test.mesh_node_var_scalar, test.mesh_node_var_scalar_size);
1221 dvs_update_var_node_vector(session_id, test.vars[1]._id, test.parts[0]._id, test.mesh_node_var_vector, test.mesh_node_var_vector_size);
1222 dvs_update_var_node_scalar(session_id, test.vars[0]._id, test.parts[2]._id, test.mesh_node_var_scalar, test.mesh_node_var_scalar_size);
1223 dvs_update_var_node_vector(session_id, test.vars[1]._id, test.parts[2]._id, test.mesh_node_var_vector, test.mesh_node_var_vector_size);
1224 }
1225
1226 if (send_plots && current_rank == plot_rank)
1227 {
1228 dvs_update_plot(session_id, test.plots[0]._id, test.plot_x_values[0], test.plot_y_values[0], test.plot_num_values);
1229 dvs_update_plot(session_id, test.plots[1]._id, test.plot_x_values[1], test.plot_y_values[1], test.plot_num_values);
1230 dvs_update_plot(session_id, test.plots[2]._id, test.plot_x_values[2], test.plot_y_values[2], test.plot_num_values);
1231 if (reinit_plots && reinit_iter >= 0) dvs_update_plot(session_id, test.reinit_plots[0]._id, test.plot_x_values[0], test.plot_y_values[0], test.plot_num_values);
1232 if (reinit_plots && reinit_iter >= 1) dvs_update_plot(session_id, test.reinit_plots[1]._id, test.plot_x_values[1], test.plot_y_values[1], test.plot_num_values);
1233 if (reinit_plots && reinit_iter >= 2) dvs_update_plot(session_id, test.reinit_plots[2]._id, test.plot_x_values[2], test.plot_y_values[2], test.plot_num_values);
1234 }
1235 dvs_end_update(session_id);
1236
1237 test_dynamic_data_free(&test);
1238 }
1239 }
1240 }*/
1241 dvs_print_stats(session_id);
1242 if (start_server)
1243 {
1244 //If we started our own server wait for the pending timesteps to clear before tearing everything down
1245 //in case it was writing stuff.
1246
1247 //Not waiting isn't a problem but if we had another process connecting to this
1248 //process' server and sending data we might lose the last timestep since it won't be
1249 //fully complete and we would not have written it yet.
1250 uint32_t num_pending = 1;
1251 uint32_t num_complete = 0;
1252 while (num_pending > 0) {
1253 dvs_ret error = dvs_server_timestep_count(server_id, &num_pending, &num_complete);
1254 if (error != DVS_NONE) break;
1255 // Avoid burning up a CPU waiting for the I/O to complete
1256 const uint32_t temp_delay_ms = 50;
1257#ifdef _WIN32
1258 Sleep(temp_delay_ms);
1259#else
1260 usleep(temp_delay_ms * 1000);
1261#endif
1262 }
1263 }
1264 dvs_shutdown();
1265 return 0;
1266}
dynamic_visualization_store_api.h
C API for using Dynamic Visualization Store.
dvs_update_var_element_scalar_int64
DVS_DLL_EXPORT dvs_ret dvs_update_var_element_scalar_int64(int32_t session_id, uint32_t var_id, uint32_t part_id, enum dvs_element_type type, const int64_t *scalars, uint32_t num_vals)
Update a field of int64 scalars on elements.
dvs_update_elements
DVS_DLL_EXPORT dvs_ret dvs_update_elements(int32_t session_id, uint32_t part_id, enum dvs_element_type type, const uint32_t *indices, uint32_t num_indices)
Update elements for a specific part and element type.
dvs_server_create
DVS_DLL_EXPORT dvs_ret dvs_server_create(const char *server_uri, int32_t *server_id)
Create a Dynamic Visualization Store server instance for the client to connect.
dvs_add_var_info
DVS_DLL_EXPORT dvs_ret dvs_add_var_info(int32_t session_id, const struct dvs_var_info *vars, uint32_t num_vars)
Add var info for simulation.
dvs_update_nodes_parallelepiped
DVS_DLL_EXPORT dvs_ret dvs_update_nodes_parallelepiped(int32_t session_id, uint32_t part_id, const uint32_t global_ijk_max[3], const uint32_t local_ijk_min[3], const uint32_t local_ijk_max[3], const float origin[3], const float dir_i[3], const float dir_j[3], const float dir_k[3], const float *i_vals, const float *j_vals, const float *k_vals)
Update the nodes for a parallelepiped structured part.
dvs_server_get_uri
DVS_DLL_EXPORT dvs_ret dvs_server_get_uri(int32_t server_id, char *uri, uint32_t *size)
Return the URI of the requested server.
dvs_set_unit_system
DVS_DLL_EXPORT dvs_ret dvs_set_unit_system(int32_t session_id, const char *system)
Set a unit system (optional but recommended)
dvs_convert_rotation_to_quaternion
DVS_DLL_EXPORT dvs_ret dvs_convert_rotation_to_quaternion(int32_t session_id, const float *axis_start, const float *axis_end, float relative_rotation_angle, float *quaternion)
Utility API to convert a rigid body rotation described by the rotation axis and the angle of rotation...
dvs_print_stats
DVS_DLL_EXPORT dvs_ret dvs_print_stats(int32_t session_id)
This will be deprecated, just placeholder for printing out stats that the client is collecting for pr...
dvs_begin_init
DVS_DLL_EXPORT dvs_ret dvs_begin_init(int32_t session_id, const char *dataset_name, uint32_t current_rank, uint32_t total_ranks, uint32_t num_chunks)
begin setup of rank
dvs_update_plot
DVS_DLL_EXPORT dvs_ret dvs_update_plot(int32_t session_id, uint32_t plot_id, const float *x_values, const float *y_values, uint32_t num_values)
Update the data for a plot.
dvs_add_part_info
DVS_DLL_EXPORT dvs_ret dvs_add_part_info(int32_t session_id, const struct dvs_part_info *parts, uint32_t num_parts)
Add part info for simulation.
dvs_delete_item
DVS_DLL_EXPORT dvs_ret dvs_delete_item(int32_t session_id, uint32_t update_num, uint32_t rank, const char *filter)
Delete an item.
dvs_get_num_part_info
DVS_DLL_EXPORT uint32_t dvs_get_num_part_info(int32_t session_id)
Get the number of dvs_part_info objects for this client session.
dvs_get_part_info
DVS_DLL_EXPORT const struct dvs_part_info * dvs_get_part_info(int32_t session_id, uint32_t index)
Get the dvs_part_info object for this index.
dvs_update_elements_polygon
DVS_DLL_EXPORT dvs_ret dvs_update_elements_polygon(int32_t session_id, uint32_t part_id, enum dvs_element_type type, const uint32_t *nodes_per_polygon, uint32_t nodes_per_polygon_size, const uint32_t *indices, uint32_t indices_size)
Update N-SIDED elements.
dvs_update_var_node_scalar_int64
DVS_DLL_EXPORT dvs_ret dvs_update_var_node_scalar_int64(int32_t session_id, uint32_t var_id, uint32_t part_id, const int64_t *scalars, uint32_t num_vals)
Update a field of int64 scalars on nodes.
dvs_update_nodes
DVS_DLL_EXPORT dvs_ret dvs_update_nodes(int32_t session_id, uint32_t part_id, const float *x, const float *y, const float *z, uint32_t num_values)
Update nodes for a specific part.
dvs_shutdown
DVS_DLL_EXPORT void dvs_shutdown()
Shuts down the api, performing any necessary cleanup, also calls dvs_server_shutdown_all() if any ser...
dvs_update_var_part_scalar
DVS_DLL_EXPORT dvs_ret dvs_update_var_part_scalar(int32_t session_id, uint32_t var_id, uint32_t part_id, float scalar)
Update value of part scalar.
dvs_get_var_info
DVS_DLL_EXPORT const struct dvs_var_info * dvs_get_var_info(int32_t session_id, uint32_t index)
Get the dvs_var_info object for this index.
dvs_update_var_node_vector
DVS_DLL_EXPORT dvs_ret dvs_update_var_node_vector(int32_t session_id, uint32_t var_id, uint32_t part_id, const float *values, uint32_t num_values)
Update a field of vectors on nodes.
dvs_get_num_plot_info
DVS_DLL_EXPORT uint32_t dvs_get_num_plot_info(int32_t session_id)
Get the number of dvs_plot_info objects for this client session.
dvs_server_start
DVS_DLL_EXPORT dvs_ret dvs_server_start(int32_t server_id, uint32_t server_number, uint32_t local_ranks)
Start a Dynamic Visualization Store server in a separate thread to receive data from solver node.
dvs_begin_update
DVS_DLL_EXPORT dvs_ret dvs_begin_update(int32_t session_id, uint32_t update_num, uint32_t rank, uint32_t chunk, float time)
Method to begin an update.
dvs_update_var_element_scalar
DVS_DLL_EXPORT dvs_ret dvs_update_var_element_scalar(int32_t session_id, uint32_t var_id, uint32_t part_id, enum dvs_element_type type, const float *scalars, uint32_t num_vals)
Update a field of scalars on elements.
dvs_add_part_rigid_body_motion
DVS_DLL_EXPORT dvs_ret dvs_add_part_rigid_body_motion(int32_t session_id, uint32_t update_num, uint32_t part_id, const float *quaternion, const float *displacement, const float *cg_offset)
Add rigid body motion data to a specific part for a specific update. Any non-needed input can be set ...
dvs_get_version
DVS_DLL_EXPORT const char * dvs_get_version()
Get the current version of the built library.
dvs_connect
DVS_DLL_EXPORT dvs_ret dvs_connect(int32_t server_id, enum dvs_client_flags flags, const char *secret, int32_t *session_id)
Connect to dvs server.
dvs_get_plot_info
DVS_DLL_EXPORT const struct dvs_plot_info * dvs_get_plot_info(int32_t session_id, uint32_t index)
Get the dvs_plot_info object for this index.
dvs_end_init
DVS_DLL_EXPORT dvs_ret dvs_end_init(int32_t session_id)
end the initialization of the rank
dvs_add_metadata
DVS_DLL_EXPORT dvs_ret dvs_add_metadata(int32_t session_id, const char *const metadata_keys[], const char *const metadata_vals[], uint32_t num_metadata_pairs)
Add metadata for the current dataset.
dvs_get_num_var_info
DVS_DLL_EXPORT uint32_t dvs_get_num_var_info(int32_t session_id)
Get the number of dvs_var_info objects for this client session.
dvs_update_var_case_scalar
DVS_DLL_EXPORT dvs_ret dvs_update_var_case_scalar(int32_t session_id, uint32_t var_id, float scalar)
Update value of case scalar.
dvs_server_timestep_count
DVS_DLL_EXPORT dvs_ret dvs_server_timestep_count(int32_t server_id, uint32_t *num_pending, uint32_t *num_complete)
Query a Dynamic Visualization Store server as to the number of timesteps it contains.
dvs_register_log_func
DVS_DLL_EXPORT dvs_ret dvs_register_log_func(int32_t session_id, void *user_data, dvs_log_func func, enum dvs_log_flags flags)
Register logging function for client to call (optional but recommended)
dvs_end_update
DVS_DLL_EXPORT dvs_ret dvs_end_update(int32_t session_id)
Call to end the update for this timestep/rank/chunk.
dvs_server_set_option
DVS_DLL_EXPORT dvs_ret dvs_server_set_option(int32_t server_id, const char *key, const char *value)
Add an option to the server.
dvs_update_var_node_scalar
DVS_DLL_EXPORT dvs_ret dvs_update_var_node_scalar(int32_t session_id, uint32_t var_id, uint32_t part_id, const float *scalars, uint32_t num_vals)
Update a field of scalars on nodes.
dvs_update_var_element_vector
DVS_DLL_EXPORT dvs_ret dvs_update_var_element_vector(int32_t session_id, uint32_t var_id, uint32_t part_id, enum dvs_element_type type, const float *values, uint32_t num_values)
Update a field of vectors on elements.
dvs_update_nodes_curvilinear
DVS_DLL_EXPORT dvs_ret dvs_update_nodes_curvilinear(int32_t session_id, uint32_t part_id, const uint32_t global_ijk_max[3], const uint32_t local_ijk_min[3], const uint32_t local_ijk_max[3], const float *x_vals, const float *y_vals, const float *z_vals)
Update the nodes for a curvilinear structured part.
dvs_add_plot_info
DVS_DLL_EXPORT dvs_ret dvs_add_plot_info(int32_t session_id, const struct dvs_plot_info *plots, uint32_t num_plots)
Add plot info for simulation.
dvs_update_elements_polyhedral
DVS_DLL_EXPORT dvs_ret dvs_update_elements_polyhedral(int32_t session_id, uint32_t part_id, enum dvs_element_type type, const uint32_t *faces_per_element, uint32_t faces_per_element_size, const uint32_t *nodes_per_face, uint32_t nodes_per_face_size, const uint32_t *indices, uint32_t indices_size)
Update N-FACED Elements.
dynamic_visualization_store_enums.h
Contains enums used in C/C++ API.
DVS_NODE_ID
#define DVS_NODE_ID
Definition dynamic_visualization_store_enums.h:119
DVS_ELEMENT_ID
#define DVS_ELEMENT_ID
Definition dynamic_visualization_store_enums.h:121
DVS_STRUCTURED_GHOST_ELEMENTS
#define DVS_STRUCTURED_GHOST_ELEMENTS
Definition dynamic_visualization_store_enums.h:117
dvs_log_flags
dvs_log_flags
Flags to control logging filters.
Definition dynamic_visualization_store_enums.h:67
LOG_UPDATE_BEG_END
@ LOG_UPDATE_BEG_END
Log messages related to begin and end of updates.
Definition dynamic_visualization_store_enums.h:71
LOG_ALL
@ LOG_ALL
Log all messages.
Definition dynamic_visualization_store_enums.h:72
DVS_STRUCTURED_IBLANKED_NODES
#define DVS_STRUCTURED_IBLANKED_NODES
Definition dynamic_visualization_store_enums.h:115
dvs_client_flags
dvs_client_flags
Flags for specific server setup.
Definition dynamic_visualization_store_enums.h:55
DEDUP
@ DEDUP
Do not send duplicate data to server.
Definition dynamic_visualization_store_enums.h:58
BEGIN_INIT_WAIT_ON_REINIT
@ BEGIN_INIT_WAIT_ON_REINIT
Blocking wait on reinitialization to complete before reinitializing again.
Definition dynamic_visualization_store_enums.h:59
BLOCK_FOR_SERVER
@ BLOCK_FOR_SERVER
Clients should block for servers to be initialized before sending data.
Definition dynamic_visualization_store_enums.h:57
dvs_ret
int32_t dvs_ret
Return value of methods, TODO.
Definition dynamic_visualization_store_error_codes.h:32
DVS_NONE
#define DVS_NONE
No detected error has occurred.
Definition dynamic_visualization_store_error_codes.h:103
dvs_part_info
Struct holding information for a part's definition.
Definition dynamic_visualization_store_api.h:77
dvs_part_info::_name
char * _name
UTF-8 Compatible name of part [null terminated], max name length visible in GUI == 79,...
Definition dynamic_visualization_store_api.h:79
dvs_part_info::_id
uint32_t _id
Unique identifier for part, MUST BE > 0.
Definition dynamic_visualization_store_api.h:78
dvs_plot_info
Struct holding information for a plot's definition.
Definition dynamic_visualization_store_api.h:109
dvs_plot_info::_name
char * _name
UTF-8 Compatible name for plot, must be unique from other plot names.
Definition dynamic_visualization_store_api.h:111
dvs_plot_info::_id
uint32_t _id
Unique id for plot.
Definition dynamic_visualization_store_api.h:110
dvs_var_info
Struct holding information for a variable's definiton.
Definition dynamic_visualization_store_api.h:92
dvs_var_info::_id
uint32_t _id
Unique id for variable.
Definition dynamic_visualization_store_api.h:93
dvs_var_info::_name
char * _name
UTF-8 Compatible name of variable [null terminated], max name length visible in the GUI == 49,...
Definition dynamic_visualization_store_api.h:94
main
int main(int argc, char **argv)
Main method of test client application.
Definition test_dvs_client.c:56

Connect with Ansys