Post-processing tools 2024 R1

test_dvs_client

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

Connect with Ansys