EnSight 2025 R2

test_dvs_client

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

Connect with Ansys