Post-processing tools 2024 R2

Changelog

Last update: 16.07.2025

What's new in 2024 R2

  • Cache store infrastructure changes - Single Writer/Multiple Reader support
    • The cache store, for both the supported HDF5 and Flatfile caches, has been upgraded so that the data are split per update number. This introduces the support for the Single Writer, Multiple Reader case where data can be accessed while the DVS servers are still writing data. Furthermore, it is possible to delete corrupted updates without losing the whole DVS data stored. Old datasets get a database migration in case of appending new data, if the cache is HDF5. Reading only does not trigger a database migration but backward compatibility loading is fully supported. The flatfile cache infrastructure has been changed to allow in the future support of new compression algorithms.
  • Memory management improvements
    • A memory data pool has been introduced to significantly improve the memory management, avoiding data duplication. This applies to both the cache and in-situ scenarios. Currently this is limited only to the larger objects like coordinates and connectivity data. For the next release it is planned to be extended to all the objects available.
  • Rigid Body Motion support
    • A Python/C/C++ API has been introduced to send and store rigid body motion data that can be used when loading in EnSight to pre-apply rigid body motion to the geometry. Future work is planned to apply the rigid body motion directly in the library so to take advantage of the feature even outside of EnSight.
  • Reader API support for the in-situ case
    • The C++ and Python reader API now fully support the in-situ case. Specifically, each DVS Server can now create DVS Query objects to retrieve data and optionally apply filters.
  • Port allocation improvements The support for the random ports allocation, to be used for the transport connection between the DVS Server and Client objects, has been improved. A C/C++/Python API has been introduced on the DVS Server objects to retrieve the port number after the allocation. This is particularly significant in EnSight where also a Python API has been introduced to pre-allocate the ports and to retrieve them afterawrds without the need of loading a DVS file.

What's new in 2024 R1

  • 64-bit Integer support
    • It is now possible to send and read 64-bit integers through the DVS interfaces. It is so now possible, for instance, to send 64-bit Element and Node IDs, but the support is extended to any other entity, like variables for example. The 64-bit Integer support is also available for the DVS Reader API and the Merge Utility.
  • Python Reader API
    • The existing C++ Reader API is now available in Python through a wrapper API. The API is available using importing the dynamic_visualization_store module, with specific interfaces to create DVS Query objects, similarly to what is done using the C++ APIs (See DVS Reader).
  • (Beta) C/C++/Python API for copying data from a previous timestep
    • A new API is available to copy data from a previous timestep. It is so possible to avoid resending large data like mesh/connectivity if already available. The APIs can be called at any time during the begin_update/end_update sequences, since it is actually executed only when the timestep is being completed by the DynamicDataReader instance.

What's new in 2023 R2

  • (Beta) 64-bit Integer support
    • Initial support to store and load 64-bit integers in DVS is now available. The user can now send 64-bit integers values for entities like variables, node/element IDs and others. The support for the DVS reader API and the Merge utility is in progress.
  • Notable robustness updates and bug fixes
    • The gRPC libraries have been upgraded to version 1.46.5.1, commonly used by other Ansys products.
    • The use of std::regex has been replaced with fnmatch for better compatibility with other Ansys products.
    • It is now possible to send empty variable updates, if needed.
    • The delete_item API was reporting errors in the InSitu case. This has been fixed.

What's new in 2023 R1

  • Static libraries
    • There are now static libraries built and located in the static/{arch} directories for Windows and Linux
  • Dataset metadata API
  • EnSight DVS Reader Element Filtering
  • Manual server control
  • Merged Reader API and Client API libraries into one library named libdvsapi
    • The old libraries for libdvsclient and libdvsreader are now removed
  • Merge Utility
    • The dvs_utility app now can merge a dataset from one cache into another. The main use for this is to merge data from a restart run into the original dataset. Because of this it right now finds the earliest timestep in the dataset it is merging from and removes all timesteps >= to it from the dataset it is merging to. This is available via dvs_utility.exe -merge {from Cache URI} {to Cache URI}.
  • Delete Item API change
    • Delete item calls now take an update number similar to the begin_update calls. This is to have delete item calls act more like a timestep update so they are asynchronous and happen in lock step with completed timesteps. The update number should be in the same "update timeline" as the begin_update calls (eg begin_update (update 0), begin_update (update 1), delete_item (update 2), begin_update (update 3))
    • See dvs_delete_item(), DVS::IClient::delete_item()
  • Ability to modify existing timesteps
    • It is now possible to modify existing timesteps in a DVS cache. Previously this was only available when running in situ. To do this a begin_update call is made (with a monotonically increasing update number) and a time value that matches a previously sent time. When the update has completed across all ranks it will be merged into the current timestep. It is important to note that the update is merged in and does not overwrite the previously sent data. So only changes are needed to be sent. So if a part mesh has been completely removed an empty update_nodes call must be made. Changes to the coordinates will automatically remove all nodal/element variables for that part. Changes to the connectivity will automatically remove all elemental variables for that part.
  • Reader API fully released
    • The Reader API (See DVS Reader) has gone through much more extensive usage and testing.
  • UTF8 Support Fixed
    • The DVS library was improperly handling UTF8 strings. The initial intent was that all strings sent to DVS were UTF8. However with a lack of testing in that area that did not work correctly. As of version 1.2 UTF8 support should be working.

What's new in 2022 R2

  • DVS Reader API
    • There is now a full external C++ Reader API available (See DVS Reader)
  • New logger example
    • Added a LoggerVerbose class in logger_verbose.h as an example of logging based on verbosity instead of flags. The flag method wasn't really working well so we will be moving to using verbosity on the client and server in future versions to make logging more consistent.
  • Logging
    • Added a lot more logging into the server to diagnose potential problems with a DVS Server. Set the server option "VERBOSE" to 0-3 (0 being none or 3 being max).
  • Notable Bug fixes
    • Server logging verbosity was broken in 2022 R1, this has been fixed so setting server verbosity should start outputting more information.

What's new in 2022 R1

  • Versioning
    • There is now a dynamic_visualization_store_version.h file which has a DVS_CURRENT_API_VERSION defined in it. It follows the normal semantic versioning convention of X.Y.Z where any changes to Z are deemed compatible with the previous version but a change in X or Y is not.
    • This same versioning is built into the gRPC API as well and an error of DVS_VERSION_MISMATCH or DVS_VERSION_UNKNOWN will be returned if there is an issue.
    • To find the version the library was built with a user can call dvs_get_version() or DVS::IClient::get_version(). The python version is available via the "version" attribute on the module.
  • Code Restructuring
    • A lot of code refactoring is ongoing to support the DVS Reader API, the code is beginning to be split into include and src directories. This work will be finished next release so that all headers needed to be included for use of the libraries will be within the include directory.
  • DVS Reader API
    • An alpha version of the DVS Reader API has been implemented. This can be access via the include/dvs_query_interface.h header file. Example usage of the API can be seen in the test_dvs_reader.cpp. Full documentation will be added when the API is complete in 2022R2. Currently you can only open a dataset and read all of the part/plot/variable definitions and some basic information. Actual access to data will be exposed in the full release.
  • Deletion Item API
    • A user can now call the delete item API to remove a single or collection of timesteps from the dataset after initialization. See dvs_delete_item_api for more information.
  • DVS File Location Server Options
    • A user can now specify a different location for the .dvs files to be created for datasets that is separate from the cache location. See Server Options for more information.

What's new in 2021 R1

What's new in 2020 R2

  • Major API Overhaul
    • In getting ready for releasing the API for other teams to use we have gone ahead and redone much of the API to facilitate future changes. Please refer to documentation for new usage.
  • Official API Name
    • We made an official name for the API of Dynamic Visualization Store (DVS) as we are starting to officially roll this out to external applications. This affects both the C/C++ and Python APIs as we renamed the namespaces to match the new name, renamed headers, libraries and classes. The details of which are described below.
    • Note: All files in the EnSight install now located in CEI/ensightXXX/src/readers/dvs where XXX is version 211 or greater.
  • Major Client/Server connection API paradigm changed. Now you need to always create at least a shell server for the client to connect to. This change is to make API calls the same no matter what type of communication you are using, whether it be grpc or direct method calls (null protocol) currently or MPI etc. in the future.
    • C API: Call the new dvs_server_create() (see docs) with a uri, which returns the created server_id as a param, calling dvs_server_start() if running the server locally, then use dvs_connect() passing in that server_id to connect to it.
      • If the server is being locally started you can call dvs_server_start() with the server_id, server_number and local_ranks count to start it running in a separate thread. Otherwise it will just act as an interface for the dvs client to communicate with.
      • Note: If a server is started it MUST be started before connecting with a client.
    • C++ API: Create a server instance DVS::CREATE_SERVER_INSTANCE() (see docs) with a uri. If running the server locally call DVS::IServer::startup() on the instance. Then pass that server instance into the DVS::CREATE_CLIENT_INSTANCE() call to connect to that server.
      • If the server is being locally started you can call DVS::IServer::startup() on the server to begin running it in a separate thread.
      • Note: If a server is started it MUST be started before connecting with a client.
  • C API Changes
  • C++ API Changes
  • Python API Changes
    • Package now named dynamic_visualization_store (file dynamic_visualization_store.pyd)
    • Example usage in test_dvs_client_simple.py
  • C/C++ Clients
  • New protocol available for use. It uses what we are calling the NULL transport. Meaning it doesn't use the network to transport data the data goes directly over method calls within this process. Previously all dvs servers used network communication via grpc, now it is possible to go directly to a dvs server without needing a network connection, letting you directly write into the DVS cache if needed.
  • DVS File Changes
    • Files read by EnSight now use the .dvs extension instead of .edd
    • Keyword option GRPC_SERVER_PORT_BASE renamed to SERVER_PORT_BASE
    • Keyword option GRPC_SERVER_PORT_MULT renamed to SERVER_PORT_MULT
  • Cache Changes
    • When using a cache a .dvs file will be auto created in the root cache folder named based on the dataset name which can be loaded by EnSight
    • Multiple datasets can now be stored and loaded from the same cache
    • Basic queries are enabled for .dvs files to allow the selection of specific datasets, parts, plots, and variables. See the Cache URIs section for more info.
    • Disk caches now use sqlite databases for metadata for both hdf5:// disk:// caches.
    • Case and part constants now stored in cache

Connect with Ansys