diff --git a/README.md b/README.md index 46b1b5a8c2..7da168b7d6 100644 --- a/README.md +++ b/README.md @@ -2,57 +2,317 @@ # tv => task visualizer -The task visualizer takes as input JSON files that describe work as a -series of phases and subphases that contain tasks for each rank, -communications, and other user-defined fields (such as memory -usage). Documentation on the JSON format can be found [in vt's -documentation](https://darma-tasking.github.io/docs/html/node-lb-data.html) -and the JSON schema validator is located [in the -repository](https://github.com/DARMA-tasking/vt/blob/develop/scripts/JSON_data_files_validator.py). - -The task visualizer, using this input, produces Exodus meshes to +`vt-tv` provides visualizations of the work-to-rank mappings, communications, and memory usage of an application. + +Jump to: +- [Overview](#overview) +- [Getting Started](#getting-started) +- [Installation and Usage](#installation-and-usage) +- [Design Information](#design-information) + +## Overview + +Specifically, the task visualizer takes in JSON files that describe work as a series of phases and subphases +that contain 1) tasks for each rank, 2) communications, and 3) other user-defined fields (such as memory usage). + +Using such input data, the task visualizer produces Exodus meshes to describe the ranks and objects over time, which can be visualized using Paraview. Additionally, the task visualizer can produce PNGs directly using a VTK workflow to render a visualization of ranks and -tasks over phases. +tasks over phases (as seen below). ![Example Output PNG](./docs/example-output-image.png) -## Building the Python bindings +## Getting Started -### Requirements +You need the following dependencies: -In order to build the python bindings, make sure you have a Python `3.8` or `3.9` environment, with the `nanobind` package installed. You can install `nanobind` with `pip`: +1. A C++ compiler that supports C++17 +2. [`cmake`](https://cmake.org/cmake/help/latest/) >= 3.17 +3. [`VTK`](https://docs.vtk.org/en/latest/index.html) (build instructions [here](https://gitlab.kitware.com/vtk/vtk/-/blob/master/Documentation/docs/build_instructions/build.md)) -```bash -pip install nanobind +Begin by cloning `vt-tv`: + +``` +git clone https://github.com/DARMA-tasking/vt-tv.git +``` + +_From now on, we will assume that the `vt-tv` source is located in `${VTTV_SOURCE_DIR}`._ + +## Installation and Usage + +`vt-tv` can be installed as either a standalone C++ app or as a Python module. Instructions for both cases are included in the dropdowns below. + +
+Standalone + +### 1. Build + +For the simplest build, run from `${VTTV_SOURCE_DIR}`: + +``` +VTK_DIR=/path/to/vtk/build ./build.sh +``` + +To build and run tests, add the `--tests-run` flag: + +``` +VTK_DIR=/path/to/vtk/build ./build.sh --tests-run +``` + +More documentation for `build.sh` can be found within the script itself, including examples. + +Alternatively, for an interactive build process, run: + +``` +./interactive_build.sh ``` -You must have a C++ compiler that supports C++17, and `cmake` >= 3.17. +_From now on, we will assume that the `vt-tv` build is in `${VTTV_BUILD_DIR}`._ -Finally, you must have a (C++) [VTK](https://vtk.org/) build available on your system. We recommend building from source, and the currently tested version is `9.3.0`. You can find instructions for building VTK [here](https://gitlab.kitware.com/vtk/vtk/-/blob/master/Documentation/docs/build_instructions/build.md). +--- -### Building +### 2. Usage -To build the python bindings, you must specify in the `VTK_DIR` environment variable the path to the VTK build directory: +`vt-tv` requires two inputs: + +1. One or more JSON data files +2. A YAML configuration file (which contains the path to the JSON data files) + +The basic call to `vt-tv` is: ```bash -export VTK_DIR=/path/to/vtk/build +${VTTV_BUILD_DIR}/apps/vt_standalone -c path/to/config +``` + +_**IMPORTANT:** The_ `path/to/config` _argument should be relative to_ `${VTTV_SOURCE_DIR}` _(see example below)._ + +#### YAML Input + +A YAML configuration exemplar can be found in `${VTTV_SOURCE_DIR}/config/conf.yaml`. To use it, run + +```bash +${VTTV_BUILD_DIR}/apps/vt_standalone -c config/conf.yaml +``` + +#### JSON Data Files + +Sample JSON data files are provided in `${VTTV_SOURCE_DIR}/tests/unit/lb_test_data`. + +Information regarding the JSON format can be found in vt's [documentation](https://darma-tasking.github.io/docs/html/node-lb-data.html); the JSON schema validator is located in the vt [repo](https://github.com/DARMA-tasking/vt/blob/develop/scripts/JSON_data_files_validator.py). + +Additionally, DARMA-tasking's Load Balancing Analysis Framework (LBAF) provides a Python script ([lbsJSONDataFilesMaker.py](https://github.com/DARMA-tasking/LB-analysis-framework/blob/develop/src/lbaf/Utils/lbsJSONDataFilesMaker.py)) that may be used to generate JSON data files. + + +
+
+Python Module + +### Dependencies + +In addition to the basic `vt-tv` dependencies listed above, you also need: + +1. A Python version between 3.8 - 3.11 +2. [`nanobind`](https://nanobind.readthedocs.io/en/latest/), which can be installed with: + +```sh +pip install nanobind ``` +### 1. Install -Then, to install python-environment-wide the binded `vt-tv` python module, run: +First, specify the location of your `VTK` build (see above) with: ```bash -pip install +export VTK_DIR=/path/to/vtk/build ``` -**Optional** -To specify the number of parallel jobs to use during the build, you can set the `VT_TV_CMAKE_JOBS` environment variable: +Optional: To specify the number of parallel jobs to use during the build, you can set the `VT_TV_CMAKE_JOBS` environment variable: ```bash export VT_TV_CMAKE_JOBS=8 ``` -> [!NOTE] -> Behind the scenes, the usual `cmake` and `make` commands are run. Depending on your system, this can cause the install process to be lengthy as it will be compiling the entire `vt-tv` library. +Then install the binded `vt-tv` Python module with: + +```bash +pip install ${VTTV_SOURCE_DIR} +``` + +_Note: Behind the scenes, the usual `cmake` and `make` commands are run. Depending on your system, this can cause the install process to be lengthy as it will be compiling the entire `vt-tv` library._ + +--- + +### 2. Usage + +Import the `vt-tv` module into your project using: + +```python +import vttv +``` + +The only function you need is `vttv.tvFromJson`, which has the following (C++) function signature: + +```cpp +void tvFromJson( + const std::vector& input_json_per_rank_list, + const std::string& input_yaml_params_str, + uint64_t num_ranks +) +``` + +The parameters are: +- `input_json_per_rank_list`: A list of the input JSON data strings (one string per rank). In the C++ standalone app, this equates to the input JSON data files. +- `input_yaml_params_str`: The visualization and output configuration data, formatted as a dictionary but exported as a string (see example below). This equates to the standalone app's input YAML configuration file. +- `num_ranks`: The number of ranks to be visualized by `vt-tv`. + +As an example, here is the (emptied) code used by the [`Load Balancing Analysis Framework`](https://github.com/DARMA-tasking/LB-analysis-framework) to call `vt-tv`: + +```python +import vttv + +# Populate with the JSON data from each rank +ranks_json_str = [] + +# Populate with the desired configuration parameters +vttv_params = { + "x_ranks": , + "y_ranks": , + "z_ranks": , + "object_jitter": , + "rank_qoi": , + "object_qoi": , + "save_meshes": , + "force_continuous_object_qoi": , + "output_visualization_dir": , + "output_visualization_file_stem": +} + +# Populate with number of ranks used in the current problem +num_ranks = + +# Call vt-tv +vttv.tvFromJson(ranks_json_str, str(vttv_params), num_ranks) +``` +
+ +## Design Information + +### 1. Quantities of Interest + +`vt-tv` visualizes various Quantities of Interest (QOI) as requested by the user in the YAML configuration file: + +```yaml +visualization: + # Other parameters... + rank_qoi: + object_qoi: +``` + +While `vt-tv` natively supports a variety of QOI, such as the `load`, `id`, or `volume` of ranks and objects[^1], we also support user-defined QOI, called `attributes`. + +
+Rank Attributes + +
+ +Rank `attributes` are defined in the `metadata` field of the JSON data files. For example: + +```json +{ + "metadata": { + "rank": 0, + "attributes": { + "max_memory_usage": 8.0e+9 + } + } +} +``` +In this example, the user defines `max_memory_usage` as a rank attribute. This can then be specified as a `rank_qoi` in the YAML configuration file. + +
+
+Object Attributes + +
+ +Object `attributes` are defined in the `tasks` field of the JSON data files. For example: + +```json +{ + "phases": [ + { + "id": 0, + "tasks": [ + { + "entity": { + "home": 0, + "id": 0, + "migratable": true, + "type": "object" + }, + "node": 0, + "resource": "cpu", + "time": 2.0, + "attributes": { + "home_rank": 0, + "shared_bytes": 10000.0, + "shared_id": 0 + } + }, + ] + } + ] +} +``` + +In this case, the user has defined `home_rank`, `shared_bytes` and `shared_id` as potential QOI. + +In the YAML configuration file passed to `vt-tv`, they may specify any of these as their `object_qoi`. + +
+ +### 2. General Structure + +`vt-tv` is designed according to the following hierarchy: + +```mermaid +graph TD; + Info-->ObjectInfo; + Info-->Rank; + Rank-->PhaseWork; + PhaseWork-->ObjectWork; + ObjectWork-->ObjectCommunicator +``` + +Further information on each class, including methods and member variables, can be found in the documentation. + +#### 1. Navigating the Hierarchy + +Users should interact mainly with the overarching `Info` class, which contains functions that drill down the hierarchy to get the desired information. + +For example, an instance of `Info` holds getters to all object and rank QOI (including user_defined attributes): + +```cpp +auto rank_qoi = info.getRankQOIAtPhase(rank_id, phase_id, qoi_string); +auto obj_qoi = info.getObjectQOIAtPhase(obj_id, phase_id, qoi_string); +``` +where the `qoi_string` is the name of the desired QOI, like "load" or "id". This string can also be a user-defined attribute, as described above. + +#### 2. ObjectInfo vs. ObjectWork + +There are two classes that hold object data: `ObjectInfo` and `ObjectWork`. + +`ObjectInfo` holds information about a given object across all ranks and phases. This includes: +- the ID +- the home rank (where the object originated) +- whether the object is migratable or sentinel (stays on the same rank) + +`ObjectWork` holds information about an object that may vary as it changes rank or phase, such as: +- the attributes +- the communications + +> [!TIP] +> As discussed above, users should utilize the getters present in `Info` rather than directly calling these classes. + +[^1]: For a list of all natively-supported QOI for ranks and objects, see [`src/vt-tv/api/info.h`](https://github.com/DARMA-tasking/vt-tv/blob/master/src/vt-tv/api/info.h). \ No newline at end of file diff --git a/build.sh b/build.sh index b4c3f72c05..a645bd3d4f 100755 --- a/build.sh +++ b/build.sh @@ -40,7 +40,6 @@ VT_TV_COVERAGE_ENABLED=$(on_off ${VT_TV_COVERAGE_ENABLED:-OFF}) VT_TV_CLEAN=$(on_off ${VT_TV_CLEAN:-ON}) VT_TV_PYTHON_BINDINGS_ENABLED=$(on_off ${VT_TV_PYTHON_BINDINGS_ENABLED:-OFF}) VT_TV_WERROR_ENABLED=$(on_off ${VT_TV_WERROR_ENABLED:-OFF}) -VT_TV_XVFB_ENABLED=$(on_off ${VT_TV_XVFB_ENABLED:-OFF}) # >> Run tests settings VT_TV_RUN_TESTS=$(on_off ${VT_TV_RUN_TESTS:-OFF}) VT_TV_RUN_TESTS_FILTER=${VT_TV_RUN_TESTS_FILTER:-""} @@ -77,8 +76,6 @@ help() { -r --tests-run=[bool] Run unit tests (and build coverage report if coverage is enabled) (VT_TV_RUN_TESTS=$VT_TV_RUN_TESTS) -f --tests-run-filter=[str] Filter unit test to run. (VT_TV_RUN_TESTS_FILTER=$VT_TV_RUN_TESTS_FILTER) - -x --xvfb=[bool] Use X Virtual Frame Buffer instead of default for rendering (VT_TV_XVFB_ENABLED=$VT_TV_XVFB_ENABLED) - -h --help Show help and default option values. Examples: @@ -126,7 +123,6 @@ while getopts btch-: OPT; do # allow -b -t -c -h, and --long_attr=value" r | tests-run ) VT_TV_RUN_TESTS=$(on_off $OPTARG) ;; f | tests-run-filter) VT_TV_RUN_TESTS_FILTER="$OPTARG" ;; k | vtk-dir ) VTK_DIR=$(realpath "$OPTARG") ;; - x | xvfb ) VT_TV_XVFB_ENABLED=$(on_off $OPTARG) ;; h | help ) help ;; \? ) exit 2 ;; # bad short option (error reported via getopts) @@ -146,7 +142,6 @@ echo VT_TV_PYTHON_BINDINGS_ENABLED=$VT_TV_PYTHON_BINDINGS_ENABLED echo VT_TV_RUN_TESTS=$VT_TV_RUN_TESTS echo VT_TV_TESTS_ENABLED=$VT_TV_TESTS_ENABLED echo VT_TV_TEST_REPORT=$VT_TV_TEST_REPORT -echo VT_TV_XVFB_ENABLED=$VT_TV_XVFB_ENABLED echo VT_TV_RUN_TESTS_FILTER=$VT_TV_RUN_TESTS_FILTER echo VT_TV_COVERAGE_ENABLED=$VT_TV_COVERAGE_ENABLED echo VT_TV_COVERAGE_REPORT=$VT_TV_COVERAGE_REPORT @@ -213,21 +208,10 @@ if [[ "$VT_TV_RUN_TESTS" == "ON" ]]; then gtest_cmd="\"$VT_TV_BUILD_DIR/tests/unit/AllTests\" $GTEST_OPTIONS" echo "Run GTest..." - - CURRENT_DISPLAY=$(echo $DISPLAY) - if [[ "$VT_TV_RUN_TESTS" == "ON" ]]; then - export DISPLAY=:99.0 - Xvfb :99 -screen 0 1024x768x24 -nolisten tcp > /dev/null 2>&1 & - sleep 1s - fi eval "$gtest_cmd" || true - if [[ "$VT_TV_RUN_TESTS" == "ON" ]]; then - pkill Xvfb - export DISPLAY=$CURRENT_DISPLAY - rm -rf /tmp/.X11-unix/X99 - fi echo "Tests done." + popd fi diff --git a/docs/vt-tv-uml.png b/docs/vt-tv-uml.png new file mode 100644 index 0000000000..7a39c5523e Binary files /dev/null and b/docs/vt-tv-uml.png differ diff --git a/interactive_build.sh b/interactive_build.sh new file mode 100755 index 0000000000..9f2988e4e2 --- /dev/null +++ b/interactive_build.sh @@ -0,0 +1,110 @@ +#!/bin/bash + +echo "Welcome to the vt-tv Build Setup!" + +# Function to prompt for a directory until a valid one is given +prompt_for_dir() { + local prompt_message="$1" + local default_val="$2" + local dir_choice + while true; do + read -p "${prompt_message} ${default_val:+[default (Enter): ${default_val}]}: " dir_choice + # If the user input is empty and a default value is provided, use it + if [[ -z "${dir_choice}" && -n "${default_val}" ]]; then + echo "${default_val}" + return + # If the user input is a valid directory, use it + elif [[ -d "${dir_choice}" ]]; then + echo "${dir_choice}" + return + else + # This message should be displayed for invalid directories + echo >&2 "Invalid directory. Please enter a valid path." + fi + done +} + +# Function for yes/no prompts +prompt_for_yes_no() { + local prompt_message="$1" + local yn_choice + while true; do + read -p "${prompt_message} (y/n): " yn_choice + case "${yn_choice}" in + y|Y) echo "y"; return;; + n|N) echo "n"; return;; + *) echo "Please enter 'y' for yes or 'n' for no.";; + esac + done +} + +# Function to prompt for a number +prompt_for_number() { + local prompt_message="$1" + local num_choice + while true; do + read -p "${prompt_message}: " num_choice + if [[ "$num_choice" =~ ^[1-9][0-9]*$ || -z "$num_choice" ]]; then + echo "${num_choice}" + return + else + echo "Invalid input. Please enter a positive integer." + fi + done +} + +# Prompt for the source directory +PROJECT_DIR=$(prompt_for_dir "Enter the vt-tv source directory" "$(pwd)") +# Prompt for the build directory +BUILD_DIR=$(prompt_for_dir "Enter the build directory" "${PROJECT_DIR}/build") + +# Ask about VTK directory +USE_VTK_DIR=$(prompt_for_yes_no "Do you have a precompiled VTK directory?") +if [[ "${USE_VTK_DIR}" == "y" ]]; then + VTK_DIR=$(prompt_for_dir "Enter the VTK build directory" "") +fi + +# Ask about number of jobs for make +JOBS=$(prompt_for_number "Enter the number of jobs/threads for make (leave empty for system default)") + +# Ask if they want to install +INSTALL_CHOICE=$(prompt_for_yes_no "Do you want to install the project after building?") +if [[ "${INSTALL_CHOICE}" == "y" ]]; then + INSTALL_DIR=$(prompt_for_dir "Enter the vt-tv install directory" "${PROJECT_DIR}/install") +fi + +# Start the build process +mkdir -p "${BUILD_DIR}" +cd "${BUILD_DIR}" + +cmake_opts=() + +if [[ -n "${VTK_DIR}" ]]; then + cmake_opts+=("-DVTK_DIR=${VTK_DIR}") +fi +if [[ -n "${INSTALL_DIR}" ]]; then + cmake_opts+=("-DCMAKE_INSTALL_PREFIX=${INSTALL_DIR}") +fi + +cmake "${cmake_opts[@]}" "${PROJECT_DIR}" + +if [[ $? -ne 0 ]]; then + echo "Error: CMake configuration failed!" + exit 1 +fi + +if [[ -n "${JOBS}" ]]; then + make -j "${JOBS}" +else + make +fi + +if [[ "${INSTALL_CHOICE}" == "y" ]]; then + make install + if [[ $? -ne 0 ]]; then + echo "Error: Installation failed!" + exit 1 + fi +fi + +echo "vt-tv built successfully!" diff --git a/src/vt-tv/api/info.h b/src/vt-tv/api/info.h index 57c5a425d3..e17e2e7707 100644 --- a/src/vt-tv/api/info.h +++ b/src/vt-tv/api/info.h @@ -229,7 +229,7 @@ struct Info { * \brief Returns a getter to a specified object QOI */ std::function - getObjectQoiGetter(const std::string& object_qoi) const { + getObjectQOIGetter(const std::string& object_qoi) const { std::function qoi_getter; if (object_qoi == "load") { qoi_getter = [&](ObjectWork obj) { @@ -320,9 +320,9 @@ struct Info { * * \return the object QOI */ - double getObjectQoi( + double getObjectQOIAtPhase( ElementIDType obj_id, PhaseType phase, std::string obj_qoi) const { - auto qoi_getter = getObjectQoiGetter(obj_qoi); + auto qoi_getter = getObjectQOIGetter(obj_qoi); auto const& objects = this->getPhaseObjects(phase); auto const& obj = objects.at(obj_id); return qoi_getter(obj); diff --git a/src/vt-tv/render/render.cc b/src/vt-tv/render/render.cc index f50e5bf9ba..b9cd2b692d 100644 --- a/src/vt-tv/render/render.cc +++ b/src/vt-tv/render/render.cc @@ -106,8 +106,8 @@ Render::Render(Info in_info) jitter_dims_.insert(std::make_pair(objectID, jitterDims)); } - object_qoi_range_ = this->computeObjectQoiRange_(); - rank_qoi_range_ = this->computeRankQoiRange_(); + object_qoi_range_ = this->computeObjectQOIRange_(); + rank_qoi_range_ = this->computeRankQOIRange_(); object_volume_max_ = this->computeMaxObjectVolume_(); object_load_max_ = this->info_.getMaxLoad(); }; @@ -174,8 +174,8 @@ Render::Render( jitter_dims_.insert(std::make_pair(objectID, jitterDims)); } - object_qoi_range_ = this->computeObjectQoiRange_(); - rank_qoi_range_ = this->computeRankQoiRange_(); + object_qoi_range_ = this->computeObjectQOIRange_(); + rank_qoi_range_ = this->computeRankQOIRange_(); object_volume_max_ = this->computeMaxObjectVolume_(); object_load_max_ = this->info_.getMaxLoad(); }; @@ -186,7 +186,7 @@ double Render::computeMaxObjectVolume_() { } std::variant, std::set>> -Render::computeObjectQoiRange_() { +Render::computeObjectQOIRange_() { // Initialize object QOI range attributes double oq_max = -1 * std::numeric_limits::infinity(); double oq_min = std::numeric_limits::infinity(); @@ -194,10 +194,10 @@ Render::computeObjectQoiRange_() { std::set> oq_all; // Update the QOI range - auto updateQoiRange = [&](auto const& objects, PhaseType phase) { + auto updateQOIRange = [&](auto const& objects, PhaseType phase) { for (auto const& [obj_id, obj_work] : objects) { // Update maximum object qoi - oq = info_.getObjectQoi(obj_id, phase, this->object_qoi_); + oq = info_.getObjectQOIAtPhase(obj_id, phase, this->object_qoi_); if (!continuous_object_qoi_) { // Allow for integer categorical QOI (i.e. rank_id) if (oq == static_cast(oq)) { @@ -220,11 +220,11 @@ Render::computeObjectQoiRange_() { // Iterate over all ranks if (selected_phase_ != std::numeric_limits::max()) { auto const& objects = this->info_.getPhaseObjects(selected_phase_); - updateQoiRange(objects, selected_phase_); + updateQOIRange(objects, selected_phase_); } else { for (PhaseType phase = 0; phase < this->n_phases_; phase++) { auto const& objects = this->info_.getPhaseObjects(phase); - updateQoiRange(objects, phase); + updateQOIRange(objects, phase); } } @@ -240,7 +240,7 @@ Render::computeObjectQoiRange_() { } } -std::pair Render::computeRankQoiRange_() { +std::pair Render::computeRankQOIRange_() { // Initialize rank QOI range attributes double rq_max = -1 * std::numeric_limits::infinity(); double rq_min = std::numeric_limits::infinity(); @@ -284,7 +284,7 @@ std::pair Render::computeRankQoiRange_() { return std::make_pair(rq_min, rq_max); } -double Render::computeRankQoiAverage_(PhaseType phase, std::string qoi) { +double Render::computeRankQOIAverage_(PhaseType phase, std::string qoi) { // Initialize rank QOI range attributes double rq_sum = 0.0; auto const& rank_loads_at_phase = @@ -463,7 +463,7 @@ vtkNew Render::createObjectMesh_(PhaseType phase) { // Set object attributes ElementIDType obj_id = objectWork.getID(); - auto oq = this->info_.getObjectQoi(obj_id, phase, this->object_qoi_); + auto oq = this->info_.getObjectQOIAtPhase(obj_id, phase, this->object_qoi_); q_arr->SetTuple1(point_index, oq); b_arr->SetTuple1(point_index, migratable); if (this->object_qoi_ != "load") { diff --git a/src/vt-tv/render/render.h b/src/vt-tv/render/render.h index 2bff924605..73aaed5d10 100644 --- a/src/vt-tv/render/render.h +++ b/src/vt-tv/render/render.h @@ -160,14 +160,14 @@ struct Render { * \return object qoi range */ std::variant, std::set>> - computeObjectQoiRange_(); + computeObjectQOIRange_(); /** * \brief Compute range of rank qoi. * * \return rank qoi range */ - std::pair computeRankQoiRange_(); + std::pair computeRankQOIRange_(); /** * \brief Compute average of rank qoi. @@ -176,7 +176,7 @@ struct Render { * * \return rank qoi range */ - double computeRankQoiAverage_(PhaseType phase, std::string qoi); + double computeRankQOIAverage_(PhaseType phase, std::string qoi); /** * \brief Create mapping of objects in ranks diff --git a/tests/unit/api/test_info.cc b/tests/unit/api/test_info.cc index bb061f9e76..3b68ee0425 100644 --- a/tests/unit/api/test_info.cc +++ b/tests/unit/api/test_info.cc @@ -115,7 +115,7 @@ TEST_P(InfoTest, test_get_rank_ids) { } /** - * Test Info:getObjectQoiGetter + * Test Info:getObjectQOIGetter */ TEST_P(InfoTest, test_get_object_qoi_getter) { InfoTestParam const& param = GetParam(); @@ -131,7 +131,7 @@ TEST_P(InfoTest, test_get_object_qoi_getter) { "rank_id", "non-existent"}); for (auto const& qoi : qoi_list) { - auto qoi_getter = info.getObjectQoiGetter(qoi); + auto qoi_getter = info.getObjectQOIGetter(qoi); } } @@ -390,7 +390,7 @@ TEST_F(InfoTest, test_get_max_volume) { } /** - * Test Info:getObjectQoi + * Test Info:getObjectQOIAtPhase */ TEST_F(InfoTest, test_get_object_qoi) { ObjectWork object_0 = ObjectWork(0, 2.0, {}, {}, {}); @@ -409,9 +409,9 @@ TEST_F(InfoTest, test_get_object_qoi) { "non-existent"}); for (auto const& qoi : qoi_list) { if (qoi == "non-existent") { - EXPECT_THROW(info.getObjectQoi(0, 0, qoi), std::runtime_error); + EXPECT_THROW(info.getObjectQOIAtPhase(0, 0, qoi), std::runtime_error); } else { - ASSERT_NO_THROW(info.getObjectQoi(0, 0, qoi)); + ASSERT_NO_THROW(info.getObjectQOIAtPhase(0, 0, qoi)); } } }