diff --git a/CMake/testing/VTKmTestWrappers.cmake b/CMake/testing/VTKmTestWrappers.cmake index 9895839fe716589c9224ba8bac93313274fdd5fd..3e4b063cf6d0fc94990c6067c5c4012d35de287f 100644 --- a/CMake/testing/VTKmTestWrappers.cmake +++ b/CMake/testing/VTKmTestWrappers.cmake @@ -129,7 +129,7 @@ function(vtkm_unit_tests) set_property(TARGET ${test_prog} PROPERTY LIBRARY_OUTPUT_DIRECTORY ${VTKm_LIBRARY_OUTPUT_PATH}) set_property(TARGET ${test_prog} PROPERTY RUNTIME_OUTPUT_DIRECTORY ${VTKm_EXECUTABLE_OUTPUT_PATH}) - target_link_libraries(${test_prog} PRIVATE vtkm_cont ${VTKm_UT_LIBRARIES}) + target_link_libraries(${test_prog} PRIVATE vtkm_cont vtkm_test_data_generator ${VTKm_UT_LIBRARIES}) foreach(index RANGE per_device_command_line_arguments) if(per_device_command_line_arguments STREQUAL "") diff --git a/benchmarking/CMakeLists.txt b/benchmarking/CMakeLists.txt index bc86212df5b18588e09abcb196386c0cba1b2d7b..cec40c013b9b7c0fd46a88507b60fa9a589bad96 100644 --- a/benchmarking/CMakeLists.txt +++ b/benchmarking/CMakeLists.txt @@ -43,5 +43,5 @@ foreach (benchmark ${benchmarks}) endforeach () if(TARGET vtkm_rendering) - add_benchmark(NAME BenchmarkRayTracing FILE BenchmarkRayTracing.cxx LIBS vtkm_rendering) + add_benchmark(NAME BenchmarkRayTracing FILE BenchmarkRayTracing.cxx LIBS vtkm_rendering vtkm_test_data_generator) endif() diff --git a/examples/clipping/CMakeLists.txt b/examples/clipping/CMakeLists.txt index be7c72315088d955576a37247d4e6a320ce3972b..a34152e314cc4a86cdc4f63346239a5037ebaf33 100644 --- a/examples/clipping/CMakeLists.txt +++ b/examples/clipping/CMakeLists.txt @@ -14,7 +14,7 @@ project(Clipping CXX) find_package(VTKm REQUIRED QUIET) add_executable(Clipping Clipping.cxx) -target_link_libraries(Clipping PRIVATE vtkm_filter) +target_link_libraries(Clipping PRIVATE vtkm_filter vtkm_test_data_generator) vtkm_add_target_information(Clipping MODIFY_CUDA_FLAGS diff --git a/examples/demo/CMakeLists.txt b/examples/demo/CMakeLists.txt index 1d64afb0d5fb1b0e6dbed369f722092d3c07e885..e5be2c96a3cc6437cf909626e61a72b856319b1e 100644 --- a/examples/demo/CMakeLists.txt +++ b/examples/demo/CMakeLists.txt @@ -15,7 +15,7 @@ find_package(VTKm REQUIRED QUIET) if(TARGET vtkm_rendering) add_executable(Demo Demo.cxx) - target_link_libraries(Demo PRIVATE vtkm_rendering) + target_link_libraries(Demo PRIVATE vtkm_rendering vtkm_test_data_generator) vtkm_add_target_information(Demo MODIFY_CUDA_FLAGS DEVICE_SOURCES Demo.cxx) diff --git a/examples/hello_worklet/CMakeLists.txt b/examples/hello_worklet/CMakeLists.txt index fdc63c893bc3471f4d0b338404846894657c7f4c..1e33e36e0ed5583e5e65e841aacf7d748b6f8939 100644 --- a/examples/hello_worklet/CMakeLists.txt +++ b/examples/hello_worklet/CMakeLists.txt @@ -14,7 +14,7 @@ project(HelloWorklet CXX) find_package(VTKm REQUIRED QUIET) add_executable(HelloWorklet HelloWorklet.cxx) -target_link_libraries(HelloWorklet PRIVATE vtkm_filter) +target_link_libraries(HelloWorklet PRIVATE vtkm_filter vtkm_test_data_generator) vtkm_add_target_information(HelloWorklet MODIFY_CUDA_FLAGS diff --git a/examples/tetrahedra/CMakeLists.txt b/examples/tetrahedra/CMakeLists.txt index 6b5bbb781d955ecaef33fb37cc9ecc04dc31e6d2..5b1a4e7c6c39e79141caede95e74aec5051b7590 100644 --- a/examples/tetrahedra/CMakeLists.txt +++ b/examples/tetrahedra/CMakeLists.txt @@ -14,14 +14,14 @@ project(Tetrahedra CXX) find_package(VTKm REQUIRED QUIET) add_executable(Tetrahedralize Tetrahedralize.cxx) -target_link_libraries(Tetrahedralize PRIVATE vtkm_filter) +target_link_libraries(Tetrahedralize PRIVATE vtkm_filter vtkm_test_data_generator) vtkm_add_target_information(Tetrahedralize MODIFY_CUDA_FLAGS DEVICE_SOURCES Tetrahedralize.cxx) add_executable(Triangulate Triangulate.cxx) -target_link_libraries(Triangulate PRIVATE vtkm_filter) +target_link_libraries(Triangulate PRIVATE vtkm_filter vtkm_test_data_generator) vtkm_add_target_information(Triangulate MODIFY_CUDA_FLAGS diff --git a/vtkm/Types.h b/vtkm/Types.h index f3e1675716ae825ef3803b4654ec58599f536447..65af750fc717f6fc89672f11a08e845780d8843a 100644 --- a/vtkm/Types.h +++ b/vtkm/Types.h @@ -680,10 +680,8 @@ public: public: inline VTKM_EXEC_CONT vtkm::IdComponent GetNumberOfComponents() const { return NUM_COMPONENTS; } - inline VTKM_EXEC_CONT const ComponentType& operator[](vtkm::IdComponent idx) const + inline VTKM_EXEC_CONT constexpr const ComponentType& operator[](vtkm::IdComponent idx) const { - VTKM_ASSERT(idx >= 0); - VTKM_ASSERT(idx < NUM_COMPONENTS); return this->Components[idx]; } diff --git a/vtkm/cont/testing/CMakeLists.txt b/vtkm/cont/testing/CMakeLists.txt index 13f6cf2c01f083191a216976e49e97d5b567731d..865a3e94c61c5faa7ec33a9d7f7c8a714437d39e 100644 --- a/vtkm/cont/testing/CMakeLists.txt +++ b/vtkm/cont/testing/CMakeLists.txt @@ -30,6 +30,14 @@ set(headers TestingVirtualObjectHandle.h ) +set(device_srcs + MakeTestDataSet.cxx + ) + +add_library(vtkm_test_data_generator ${device_srcs}) +target_link_libraries(vtkm_test_data_generator PRIVATE vtkm_cont) +vtkm_add_target_information(vtkm_test_data_generator DEVICE_SOURCES ${device_srcs}) + vtkm_declare_headers(${headers}) set(unit_tests diff --git a/vtkm/cont/testing/ExplicitTestData.h b/vtkm/cont/testing/ExplicitTestData.h index c00e8ea385b3b4f15bd05706d2b638a41f81b09c..96f545bea0dc759fcee435a7bdb7569484352532 100644 --- a/vtkm/cont/testing/ExplicitTestData.h +++ b/vtkm/cont/testing/ExplicitTestData.h @@ -23,8 +23,8 @@ namespace testing namespace ExplicitData0 { -static const std::size_t numPoints = 48; -vtkm::Float32 coords[numPoints * 3] = { +constexpr std::size_t numPoints = 48; +constexpr vtkm::Float32 coords[numPoints * 3] = { -5.000f, 0.000f, -10.000f, 5.000f, 0.000f, -5.000f, 0.000f, 5.000f, -5.000f, 5.000f, 5.000f, -5.000f, 10.000f, 5.000f, -5.000f, 5.000f, 5.000f, 0.000f, 5.000f, 0.000f, 0.000f, 5.000f, 5.000f, 5.000f, -5.000f, -1.227f, -10.000f, -6.101f, 0.000f, -10.000f, @@ -42,9 +42,9 @@ vtkm::Float32 coords[numPoints * 3] = { 2.860f, 6.944f, 2.613f, 2.860f, }; -static const std::size_t numCells = 74; -static const std::size_t numConn = 336; -vtkm::Id conn[numConn] = { +constexpr std::size_t numCells = 74; +constexpr std::size_t numConn = 336; +constexpr vtkm::Id conn[numConn] = { 8, 9, 10, 0, 10, 11, 8, 0, 12, 13, 14, 1, 12, 15, 13, 1, 16, 10, 9, 0, 11, 10, 16, 0, 17, 18, 19, 2, 2, 19, 17, 40, 14, 1, 13, 40, 2, 3, 1, 40, 1, 15, 13, 41, 22, 4, 21, 41, 1, 3, 4, 41, 17, 23, 18, 2, 19, 18, 29, 2, 5, 42, 2, 3, 2, 1, 3, 42, 2, 29, 19, 42, @@ -61,13 +61,13 @@ vtkm::Id conn[numConn] = { 6, 26, 27, 1, 14, 12, 6, 27, 28, 1, 12, 15, 5, 30, 33, 7, 35, 38, 7, 37, 38, 5, 32, 33, }; -vtkm::IdComponent numIndices[numCells] = { +constexpr vtkm::IdComponent numIndices[numCells] = { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, }; -vtkm::UInt8 shapes[numCells] = { +constexpr vtkm::UInt8 shapes[numCells] = { vtkm::CELL_SHAPE_HEXAHEDRON, vtkm::CELL_SHAPE_HEXAHEDRON, vtkm::CELL_SHAPE_HEXAHEDRON, vtkm::CELL_SHAPE_HEXAHEDRON, vtkm::CELL_SHAPE_HEXAHEDRON, vtkm::CELL_SHAPE_HEXAHEDRON, vtkm::CELL_SHAPE_HEXAHEDRON, vtkm::CELL_SHAPE_HEXAHEDRON, vtkm::CELL_SHAPE_HEXAHEDRON, @@ -95,7 +95,7 @@ vtkm::UInt8 shapes[numCells] = { vtkm::CELL_SHAPE_WEDGE, vtkm::CELL_SHAPE_WEDGE, }; -vtkm::Float32 pointData[numPoints] = { +constexpr vtkm::Float32 pointData[numPoints] = { 4.078f, 4.368f, 4.266f, 4.356f, 4.083f, 4.450f, 4.373f, 3.859f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, 3.800f, @@ -107,8 +107,8 @@ vtkm::Float32 pointData[numPoints] = { // Resample(5,5,5), CylinderSlice((-10,-10,-10),(10,10,10), r=6), field=hardyglobal namespace ExplicitData1 { -static const std::size_t numPoints = 107; -vtkm::Float32 coords[numPoints * 3] = { +constexpr std::size_t numPoints = 107; +constexpr vtkm::Float32 coords[numPoints * 3] = { -5.000f, -10.000f, -10.000f, -10.000f, -5.000f, -10.000f, -10.000f, -10.000f, -5.000f, -5.000f, -5.000f, -10.000f, -10.000f, -5.000f, -5.000f, -5.000f, -10.000f, -5.000f, 0.000f, -5.000f, -5.000f, -5.000f, -5.000f, -5.000f, -5.000f, 0.000f, -5.000f, @@ -147,9 +147,9 @@ vtkm::Float32 coords[numPoints * 3] = { 1.453f, 7.580f, 7.580f, 7.143f, 7.143f, 7.143f, }; -static const std::size_t numCells = 186; -static const std::size_t numConn = 876; -vtkm::Id conn[numConn] = { +constexpr std::size_t numCells = 186; +constexpr std::size_t numConn = 876; +constexpr vtkm::Id conn[numConn] = { 0, 1, 2, 87, 0, 3, 1, 87, 1, 4, 2, 87, 2, 5, 0, 87, 3, 88, 6, 7, 6, 5, 7, 88, 6, 33, 32, 88, 32, 35, 33, 6, 4, 89, 8, 7, 8, 3, 7, 89, 8, 39, 38, 89, 6, 90, 3, 7, 3, 8, 7, 90, 3, 34, 36, 90, 38, 43, 39, 8, @@ -196,7 +196,7 @@ vtkm::Id conn[numConn] = { 7, 6, 9, 8, 10, 13, 12, 14, 12, 11, 16, 15, 17, 20, 19, 21, }; -vtkm::IdComponent numIndices[numCells] = { +constexpr vtkm::IdComponent numIndices[numCells] = { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, @@ -205,7 +205,7 @@ vtkm::IdComponent numIndices[numCells] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, }; -vtkm::UInt8 shapes[numCells] = { +constexpr vtkm::UInt8 shapes[numCells] = { vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, @@ -270,7 +270,7 @@ vtkm::UInt8 shapes[numCells] = { vtkm::CELL_SHAPE_WEDGE, vtkm::CELL_SHAPE_HEXAHEDRON, vtkm::CELL_SHAPE_HEXAHEDRON, }; -vtkm::Float32 pointData[numPoints] = { +constexpr vtkm::Float32 pointData[numPoints] = { 2.235f, 2.609f, 2.448f, 2.944f, 3.198f, 2.609f, 3.015f, 3.392f, 3.598f, 3.568f, 2.812f, 4.373f, 3.379f, 3.462f, 3.018f, 3.748f, 4.450f, 3.485f, 3.740f, 3.859f, 3.706f, 3.354f, 2.815f, 2.937f, 2.460f, 2.368f, 2.759f, 2.085f, 2.085f, 2.085f, 2.507f, 2.234f, 2.672f, 2.907f, 2.895f, 3.165f, @@ -287,8 +287,8 @@ vtkm::Float32 pointData[numPoints] = { // Resample(6,6,6), CylinderClip((0,0,0) r=8), field=hardyglobal namespace ExplicitData2 { -static const std::size_t numPoints = 104; -vtkm::Float32 coords[numPoints * 3] = { +constexpr std::size_t numPoints = 104; +constexpr vtkm::Float32 coords[numPoints * 3] = { -2.000f, -2.000f, -6.000f, 2.000f, -2.000f, -6.000f, -2.000f, 2.000f, -6.000f, 2.000f, 2.000f, -6.000f, -2.000f, -6.000f, -2.000f, 2.000f, -6.000f, -2.000f, -6.000f, -2.000f, -2.000f, -2.000f, -2.000f, -2.000f, 6.000f, -2.000f, -2.000f, 2.000f, -2.000f, -2.000f, -6.000f, 2.000f, -2.000f, @@ -320,9 +320,9 @@ vtkm::Float32 coords[numPoints * 3] = { 7.250f, 2.000f, 2.000f, 7.250f, }; -static const std::size_t numCells = 125; -static const std::size_t numConn = 704; -vtkm::Id conn[numConn] = { +constexpr std::size_t numCells = 125; +constexpr std::size_t numConn = 704; +constexpr vtkm::Id conn[numConn] = { 32, 33, 34, 0, 36, 37, 35, 1, 39, 42, 38, 2, 43, 40, 41, 3, 44, 45, 46, 4, 48, 49, 47, 5, 50, 51, 52, 6, 4, 6, 7, 0, 8, 9, 1, 5, 53, 55, 54, 8, 57, 60, 56, 10, 11, 12, 10, 2, 13, 14, 3, 15, 64, 58, 59, 15, 61, 66, 62, 11, 67, 63, 65, @@ -359,14 +359,14 @@ vtkm::Id conn[numConn] = { 28, 25, 97, 19, 21, 31, 27, 100, 101, 103, 102, }; -vtkm::IdComponent numIndices[numCells] = { +constexpr vtkm::IdComponent numIndices[numCells] = { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, }; -vtkm::UInt8 shapes[numCells] = { +constexpr vtkm::UInt8 shapes[numCells] = { vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, vtkm::CELL_SHAPE_TETRA, @@ -411,7 +411,7 @@ vtkm::UInt8 shapes[numCells] = { vtkm::CELL_SHAPE_HEXAHEDRON, vtkm::CELL_SHAPE_HEXAHEDRON, }; -vtkm::Float32 pointData[numPoints] = { +constexpr vtkm::Float32 pointData[numPoints] = { 3.558f, 3.219f, 3.738f, 5.246f, 3.204f, 3.535f, 3.536f, 2.668f, 5.001f, 3.375f, 3.336f, 3.141f, 3.824f, 4.556f, 4.097f, 4.969f, 3.164f, 3.306f, 2.031f, 3.613f, 3.084f, 3.958f, 3.583f, 3.748f, 3.036f, 3.112f, 3.331f, 3.297f, 3.821f, 3.758f, 4.511f, 3.389f, 4.000f, 3.518f, 3.905f, 3.150f, diff --git a/vtkm/cont/testing/MakeTestDataSet.cxx b/vtkm/cont/testing/MakeTestDataSet.cxx new file mode 100644 index 0000000000000000000000000000000000000000..d61873ae3950d151838352e9bfad3a5cac9c2209 --- /dev/null +++ b/vtkm/cont/testing/MakeTestDataSet.cxx @@ -0,0 +1,1432 @@ +//============================================================================ +// Copyright (c) Kitware, Inc. +// All rights reserved. +// See LICENSE.txt for details. +// +// This software is distributed WITHOUT ANY WARRANTY; without even +// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +// PURPOSE. See the above copyright notice for more information. +//============================================================================ + +#include + +#include +#include +#include +#include +#include + +#include + +#include + +namespace vtkm +{ +namespace cont +{ +namespace testing +{ + +//Make a simple 1D dataset. +vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet0() +{ + vtkm::cont::DataSetBuilderUniform dsb; + constexpr vtkm::Id nVerts = 6; + vtkm::cont::DataSet dataSet = dsb.Create(nVerts); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr vtkm::Float32 var[nVerts] = { -1.0f, .5f, -.2f, 1.7f, -.1f, .8f }; + constexpr vtkm::Float32 var2[nVerts] = { -1.1f, .7f, -.2f, 0.2f, -.1f, .4f }; + dsf.AddPointField(dataSet, "pointvar", var, nVerts); + dsf.AddPointField(dataSet, "pointvar2", var2, nVerts); + + return dataSet; +} + +//Make another simple 1D dataset. +vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet1() +{ + vtkm::cont::DataSetBuilderUniform dsb; + constexpr vtkm::Id nVerts = 6; + vtkm::cont::DataSet dataSet = dsb.Create(nVerts); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr vtkm::Float32 var[nVerts] = { 1.0e3f, 5.e5f, 2.e8f, 1.e10f, 2e12f, 3e15f }; + dsf.AddPointField(dataSet, "pointvar", var, nVerts); + + return dataSet; +} + + +//Make a simple 1D, 16 cell uniform dataset. +vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet2() +{ + vtkm::cont::DataSetBuilderUniform dsb; + constexpr vtkm::Id dims = 256; + vtkm::cont::DataSet dataSet = dsb.Create(dims); + + vtkm::cont::DataSetFieldAdd dsf; + vtkm::Float64 pointvar[dims]; + constexpr vtkm::Float64 dx = vtkm::Float64(4.0 * vtkm::Pi()) / vtkm::Float64(dims - 1); + + vtkm::Id idx = 0; + for (vtkm::Id x = 0; x < dims; ++x) + { + vtkm::Float64 cx = vtkm::Float64(x) * dx - 2.0 * vtkm::Pi(); + vtkm::Float64 cv = vtkm::Sin(cx); + + pointvar[idx] = cv; + idx++; + } + + dsf.AddPointField(dataSet, "pointvar", pointvar, dims); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make1DExplicitDataSet0() +{ + constexpr int nVerts = 5; + std::vector coords = { vtkm::Vec3f_32(0.0f, 0.f, 0.f), + vtkm::Vec3f_32(1.0f, 0.f, 0.f), + vtkm::Vec3f_32(1.1f, 0.f, 0.f), + vtkm::Vec3f_32(1.2f, 0.f, 0.f), + vtkm::Vec3f_32(4.0f, 0.f, 0.f) }; + + // Each line connects two consecutive vertices + std::vector conn; + for (int i = 0; i < nVerts - 1; i++) + { + conn.push_back(i); + conn.push_back(i + 1); + } + + vtkm::cont::DataSet dataSet; + vtkm::cont::DataSetBuilderExplicit dsb; + + dataSet = dsb.Create(coords, vtkm::CellShapeTagLine(), 2, conn, "coordinates"); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr vtkm::Float32 var[nVerts] = { -1.0f, .5f, -.2f, 1.7f, .8f }; + dsf.AddPointField(dataSet, "pointvar", var, nVerts); + + return dataSet; +} + +//Make a simple 2D, 2 cell uniform dataset. +vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet0() +{ + vtkm::cont::DataSetBuilderUniform dsb; + constexpr vtkm::Id2 dimensions(3, 2); + vtkm::cont::DataSet dataSet = dsb.Create(dimensions); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr vtkm::Id nVerts = 6; + constexpr vtkm::Float32 var[nVerts] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f }; + + dsf.AddPointField(dataSet, "pointvar", var, nVerts); + + constexpr vtkm::Float32 cellvar[2] = { 100.1f, 200.1f }; + dsf.AddCellField(dataSet, "cellvar", cellvar, 2); + + return dataSet; +} + +//Make a simple 2D, 16 cell uniform dataset. +vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet1() +{ + vtkm::cont::DataSetBuilderUniform dsb; + constexpr vtkm::Id2 dimensions(5, 5); + vtkm::cont::DataSet dataSet = dsb.Create(dimensions); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr vtkm::Id nVerts = 25; + constexpr vtkm::Id nCells = 16; + constexpr vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, 1.0f, 94.0f, 71.0f, + 47.0f, 33.0f, 6.0f, 52.0f, 44.0f, 50.0f, 45.0f, + 48.0f, 8.0f, 12.0f, 46.0f, 91.0f, 43.0f, 0.0f, + 5.0f, 51.0f, 76.0f, 83.0f }; + constexpr vtkm::Float32 cellvar[nCells] = { + 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, + 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f + }; + + dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); + dsf.AddCellField(dataSet, "cellvar", cellvar, nCells); + + return dataSet; +} + +//Make a simple 2D, 16 cell uniform dataset. +vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet2() +{ + vtkm::cont::DataSetBuilderUniform dsb; + constexpr vtkm::Id2 dims(16, 16); + vtkm::cont::DataSet dataSet = dsb.Create(dims); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr vtkm::Id nVerts = 256; + constexpr vtkm::Float64 dx = vtkm::Float64(4.0 * vtkm::Pi()) / vtkm::Float64(dims[0] - 1); + constexpr vtkm::Float64 dy = vtkm::Float64(2.0 * vtkm::Pi()) / vtkm::Float64(dims[1] - 1); + vtkm::Float64 pointvar[nVerts]; + + vtkm::Id idx = 0; + for (vtkm::Id y = 0; y < dims[1]; ++y) + { + vtkm::Float64 cy = vtkm::Float64(y) * dy - vtkm::Pi(); + for (vtkm::Id x = 0; x < dims[0]; ++x) + { + vtkm::Float64 cx = vtkm::Float64(x) * dx - 2.0 * vtkm::Pi(); + vtkm::Float64 cv = vtkm::Sin(cx) + vtkm::Sin(cy) + + 2.0 * vtkm::Cos(vtkm::Sqrt((cx * cx) / 2.0 + cy * cy) / 0.75) + + 4.0 * vtkm::Cos(cx * cy / 4.0); + + pointvar[idx] = cv; + idx++; + } + } // y + + dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); + + return dataSet; +} +//Make a simple 3D, 4 cell uniform dataset. +vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet0() +{ + vtkm::cont::DataSetBuilderUniform dsb; + constexpr vtkm::Id3 dimensions(3, 2, 3); + vtkm::cont::DataSet dataSet = dsb.Create(dimensions); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr int nVerts = 18; + constexpr vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.2f, 60.2f, + 70.2f, 80.2f, 90.3f, 100.3f, 110.3f, 120.3f, + 130.4f, 140.4f, 150.4f, 160.4f, 170.5f, 180.5f }; + + //Set point and cell scalar + dsf.AddPointField(dataSet, "pointvar", vars, nVerts); + + constexpr vtkm::Float32 cellvar[4] = { 100.1f, 100.2f, 100.3f, 100.4f }; + dsf.AddCellField(dataSet, "cellvar", cellvar, 4); + + return dataSet; +} + +//Make a simple 3D, 64 cell uniform dataset. +vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet1() +{ + vtkm::cont::DataSetBuilderUniform dsb; + constexpr vtkm::Id3 dimensions(5, 5, 5); + vtkm::cont::DataSet dataSet = dsb.Create(dimensions); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr vtkm::Id nVerts = 125; + constexpr vtkm::Id nCells = 64; + constexpr vtkm::Float32 pointvar[nVerts] = { + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 99.0f, 90.0f, 85.0f, 0.0f, 0.0f, 95.0f, 80.0f, + 95.0f, 0.0f, 0.0f, 85.0f, 90.0f, 99.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 75.0f, 50.0f, 65.0f, 0.0f, 0.0f, 55.0f, 15.0f, + 45.0f, 0.0f, 0.0f, 60.0f, 40.0f, 70.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 97.0f, 87.0f, 82.0f, 0.0f, 0.0f, 92.0f, 77.0f, + 92.0f, 0.0f, 0.0f, 82.0f, 87.0f, 97.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f + }; + constexpr vtkm::Float32 cellvar[nCells] = { + 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, + 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, + + 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, + 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, + + 32.0f, 33.0f, 34.0f, 35.0f, 36.0f, 37.0f, 38.0f, 39.0f, + 40.0f, 41.0f, 42.0f, 43.0f, 44.0f, 45.0f, 46.0f, 47.0f, + + 48.0f, 49.0f, 50.0f, 51.0f, 52.0f, 53.0f, 54.0f, 55.0f, + 56.0f, 57.0f, 58.0f, 59.0f, 60.0f, 61.0f, 62.0f, 63.0f + }; + + dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); + dsf.AddCellField(dataSet, "cellvar", cellvar, nCells); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet2() +{ + constexpr vtkm::Id base_size = 256; + vtkm::cont::DataSetBuilderUniform dsb; + constexpr vtkm::Id3 dimensions(base_size, base_size, base_size); + vtkm::cont::DataSet dataSet = dsb.Create(dimensions); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr vtkm::Id nVerts = base_size * base_size * base_size; + std::vector pointvar(static_cast(nVerts)); + + for (vtkm::Id z = 0; z < base_size; ++z) + for (vtkm::Id y = 0; y < base_size; ++y) + for (vtkm::Id x = 0; x < base_size; ++x) + { + std::size_t index = static_cast(z * base_size * base_size + y * base_size + x); + pointvar[index] = vtkm::Sqrt(vtkm::Float32(x * x + y * y + z * z)); + } + + dsf.AddPointField(dataSet, "pointvar", pointvar); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet3(const vtkm::Id3 dims) +{ + vtkm::cont::DataSetBuilderUniform dsb; + vtkm::cont::DataSet dataSet = dsb.Create(dims); + + // add point scalar field + vtkm::Id numPoints = dims[0] * dims[1] * dims[2]; + std::vector pointvar(static_cast(numPoints)); + + const vtkm::Float64 dx = vtkm::Float64(4.0 * vtkm::Pi()) / vtkm::Float64(dims[0] - 1); + const vtkm::Float64 dy = vtkm::Float64(2.0 * vtkm::Pi()) / vtkm::Float64(dims[1] - 1); + const vtkm::Float64 dz = vtkm::Float64(3.0 * vtkm::Pi()) / vtkm::Float64(dims[2] - 1); + + vtkm::Id idx = 0; + for (vtkm::Id z = 0; z < dims[2]; ++z) + { + vtkm::Float64 cz = vtkm::Float64(z) * dz - 1.5 * vtkm::Pi(); + for (vtkm::Id y = 0; y < dims[1]; ++y) + { + vtkm::Float64 cy = vtkm::Float64(y) * dy - vtkm::Pi(); + for (vtkm::Id x = 0; x < dims[0]; ++x) + { + vtkm::Float64 cx = vtkm::Float64(x) * dx - 2.0 * vtkm::Pi(); + vtkm::Float64 cv = vtkm::Sin(cx) + vtkm::Sin(cy) + + 2.0 * vtkm::Cos(vtkm::Sqrt((cx * cx) / 2.0 + cy * cy) / 0.75) + + 4.0 * vtkm::Cos(cx * cy / 4.0); + + if (dims[2] > 1) + { + cv += vtkm::Sin(cz) + 1.5 * vtkm::Cos(vtkm::Sqrt(cx * cx + cy * cy + cz * cz) / 0.75); + } + pointvar[static_cast(idx)] = cv; + idx++; + } + } // y + } // z + + vtkm::cont::DataSetFieldAdd dsf; + dsf.AddPointField(dataSet, "pointvar", pointvar); + + vtkm::Id numCells = (dims[0] - 1) * (dims[1] - 1) * (dims[2] - 1); + dsf.AddCellField( + dataSet, + "cellvar", + vtkm::cont::make_ArrayHandleCounting(vtkm::Float64(0), vtkm::Float64(1), numCells)); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make2DRectilinearDataSet0() +{ + vtkm::cont::DataSetBuilderRectilinear dsb; + + std::vector X = { 0.0f, 1.0f, 2.0f }; + std::vector Y = { 0.0f, 1.0f }; + vtkm::cont::DataSet dataSet = dsb.Create(X, Y); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr vtkm::Id nVerts = 6; + vtkm::Float32 var[nVerts]; + for (int i = 0; i < nVerts; i++) + var[i] = (vtkm::Float32)i; + dsf.AddPointField(dataSet, "pointvar", var, nVerts); + + constexpr vtkm::Id nCells = 2; + constexpr vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f }; + dsf.AddCellField(dataSet, "cellvar", cellvar, nCells); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DRegularDataSet0() +{ + vtkm::cont::DataSet dataSet; + + constexpr int nVerts = 18; + vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vtkm::Id3(3, 2, 3)); + constexpr vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.2f, 60.2f, + 70.2f, 80.2f, 90.3f, 100.3f, 110.3f, 120.3f, + 130.4f, 140.4f, 150.4f, 160.4f, 170.5f, 180.5f }; + + dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates)); + + //Set point scalar + dataSet.AddField(make_Field( + "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); + + //Set cell scalar + constexpr vtkm::Float32 cellvar[4] = { 100.1f, 100.2f, 100.3f, 100.4f }; + dataSet.AddField(make_Field( + "cellvar", vtkm::cont::Field::Association::CELL_SET, cellvar, 4, vtkm::CopyFlag::On)); + + vtkm::cont::CellSetStructured<3> cellSet; + cellSet.SetPointDimensions(vtkm::make_Vec(3, 2, 3)); + dataSet.AddCellSet(cellSet); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DRegularDataSet1() +{ + vtkm::cont::DataSet dataSet; + + constexpr int nVerts = 8; + vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vtkm::Id3(2, 2, 2)); + constexpr vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.2f, 60.2f, 70.2f, 80.2f }; + + dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates)); + + //Set point scalar + dataSet.AddField(make_Field( + "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); + + //Set cell scalar + constexpr vtkm::Float32 cellvar[1] = { 100.1f }; + dataSet.AddField(make_Field( + "cellvar", vtkm::cont::Field::Association::CELL_SET, cellvar, 1, vtkm::CopyFlag::On)); + + vtkm::cont::CellSetStructured<3> cellSet; + cellSet.SetPointDimensions(vtkm::make_Vec(2, 2, 2)); + dataSet.AddCellSet(cellSet); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DRectilinearDataSet0() +{ + vtkm::cont::DataSetBuilderRectilinear dsb; + + std::vector X = { 0.0f, 1.0f, 2.0f }; + std::vector Y = { 0.0f, 1.0f }; + std::vector Z = { 0.0f, 1.0f, 2.0f }; + vtkm::cont::DataSet dataSet = dsb.Create(X, Y, Z); + + vtkm::cont::DataSetFieldAdd dsf; + constexpr vtkm::Id nVerts = 18; + vtkm::Float32 var[nVerts]; + for (int i = 0; i < nVerts; i++) + var[i] = (vtkm::Float32)i; + dsf.AddPointField(dataSet, "pointvar", var, nVerts); + + constexpr vtkm::Id nCells = 4; + vtkm::Float32 cellvar[nCells]; + for (int i = 0; i < nCells; i++) + cellvar[i] = (vtkm::Float32)i; + dsf.AddCellField(dataSet, "cellvar", cellvar, nCells); + + return dataSet; +} + +// Make a 2D explicit dataset +vtkm::cont::DataSet MakeTestDataSet::Make2DExplicitDataSet0() +{ + vtkm::cont::DataSet dataSet; + vtkm::cont::DataSetBuilderExplicit dsb; + vtkm::cont::DataSetFieldAdd dsf; + + // Coordinates + constexpr int nVerts = 16; + constexpr int nCells = 7; + using CoordType = vtkm::Vec3f_32; + const std::vector coords = { + CoordType(0, 0, 0), CoordType(1, 0, 0), CoordType(2, 0, 0), CoordType(3, 0, 0), + CoordType(0, 1, 0), CoordType(1, 1, 0), CoordType(2, 1, 0), CoordType(3, 1, 0), + CoordType(0, 2, 0), CoordType(1, 2, 0), CoordType(2, 2, 0), CoordType(3, 2, 0), + CoordType(0, 3, 0), CoordType(3, 3, 0), CoordType(1, 4, 0), CoordType(2, 4, 0) + }; + + // Connectivity + std::vector shapes; + std::vector numindices; + std::vector conn; + + shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); + numindices.push_back(3); + conn.push_back(0); + conn.push_back(1); + conn.push_back(5); + + shapes.push_back(vtkm::CELL_SHAPE_QUAD); + numindices.push_back(4); + conn.push_back(1); + conn.push_back(2); + conn.push_back(6); + conn.push_back(5); + + shapes.push_back(vtkm::CELL_SHAPE_QUAD); + numindices.push_back(4); + conn.push_back(5); + conn.push_back(6); + conn.push_back(10); + conn.push_back(9); + + shapes.push_back(vtkm::CELL_SHAPE_QUAD); + numindices.push_back(4); + conn.push_back(4); + conn.push_back(5); + conn.push_back(9); + conn.push_back(8); + + shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); + numindices.push_back(3); + conn.push_back(2); + conn.push_back(3); + conn.push_back(7); + + shapes.push_back(vtkm::CELL_SHAPE_QUAD); + numindices.push_back(4); + conn.push_back(6); + conn.push_back(7); + conn.push_back(11); + conn.push_back(10); + + shapes.push_back(vtkm::CELL_SHAPE_POLYGON); + numindices.push_back(6); + conn.push_back(9); + conn.push_back(10); + conn.push_back(13); + conn.push_back(15); + conn.push_back(14); + conn.push_back(12); + dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates"); + + // Field data + constexpr vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, 94.0f, 71.0f, + 47.0f, 33.0f, 52.0f, 44.0f, 50.0f, 45.0f, + 8.0f, 12.0f, 46.0f, 91.0f }; + constexpr vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f }; + + dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); + dsf.AddCellField(dataSet, "cellvar", cellvar, nCells); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet0() +{ + vtkm::cont::DataSet dataSet; + vtkm::cont::DataSetBuilderExplicit dsb; + + constexpr int nVerts = 5; + using CoordType = vtkm::Vec3f_32; + const std::vector coords = { CoordType(0, 0, 0), + CoordType(1, 0, 0), + CoordType(1, 1, 0), + CoordType(2, 1, 0), + CoordType(2, 2, 0) }; + + //Connectivity + std::vector shapes; + shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); + shapes.push_back(vtkm::CELL_SHAPE_QUAD); + + std::vector numindices; + numindices.push_back(3); + numindices.push_back(4); + + std::vector conn; + // First Cell: Triangle + conn.push_back(0); + conn.push_back(1); + conn.push_back(2); + // Second Cell: Quad + conn.push_back(2); + conn.push_back(1); + conn.push_back(3); + conn.push_back(4); + + //Create the dataset. + dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates"); + + constexpr vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f }; + constexpr vtkm::Float32 cellvar[2] = { 100.1f, 100.2f }; + + vtkm::cont::DataSetFieldAdd dsf; + dsf.AddPointField(dataSet, "pointvar", vars, nVerts); + dsf.AddCellField(dataSet, "cellvar", cellvar, 2); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet1() +{ + vtkm::cont::DataSet dataSet; + vtkm::cont::DataSetBuilderExplicit dsb; + + constexpr int nVerts = 5; + using CoordType = vtkm::Vec3f_32; + constexpr CoordType coordinates[nVerts] = { CoordType(0, 0, 0), + CoordType(1, 0, 0), + CoordType(1, 1, 0), + CoordType(2, 1, 0), + CoordType(2, 2, 0) }; + constexpr vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f }; + + dataSet.AddCoordinateSystem( + vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); + vtkm::cont::CellSetExplicit<> cellSet; + cellSet.PrepareToAddCells(2, 7); + cellSet.AddCell(vtkm::CELL_SHAPE_TRIANGLE, 3, make_Vec(0, 1, 2)); + cellSet.AddCell(vtkm::CELL_SHAPE_QUAD, 4, make_Vec(2, 1, 3, 4)); + cellSet.CompleteAddingCells(nVerts); + dataSet.AddCellSet(cellSet); + + //Set point scalar + dataSet.AddField(make_Field( + "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); + + //Set cell scalar + constexpr vtkm::Float32 cellvar[2] = { 100.1f, 100.2f }; + dataSet.AddField(make_Field( + "cellvar", vtkm::cont::Field::Association::CELL_SET, cellvar, 2, vtkm::CopyFlag::On)); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet2() +{ + vtkm::cont::DataSet dataSet; + + constexpr int nVerts = 8; + using CoordType = vtkm::Vec3f_32; + constexpr CoordType coordinates[nVerts] = { + CoordType(0, 0, 0), // 0 + CoordType(1, 0, 0), // 1 + CoordType(1, 0, 1), // 2 + CoordType(0, 0, 1), // 3 + CoordType(0, 1, 0), // 4 + CoordType(1, 1, 0), // 5 + CoordType(1, 1, 1), // 6 + CoordType(0, 1, 1) // 7 + }; + constexpr vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f, 60.2f, 70.2f, 80.3f }; + + dataSet.AddCoordinateSystem( + vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); + + //Set point scalar + dataSet.AddField(make_Field( + "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); + + //Set cell scalar + vtkm::Float32 cellvar[2] = { 100.1f }; + dataSet.AddField(make_Field( + "cellvar", vtkm::cont::Field::Association::CELL_SET, cellvar, 1, vtkm::CopyFlag::On)); + + vtkm::cont::CellSetExplicit<> cellSet; + const vtkm::Vec ids{ 0, 1, 2, 3, 4, 5, 6, 7 }; + + cellSet.PrepareToAddCells(1, 8); + cellSet.AddCell(vtkm::CELL_SHAPE_HEXAHEDRON, 8, ids); + cellSet.CompleteAddingCells(nVerts); + + //todo this need to be a reference/shared_ptr style class + dataSet.AddCellSet(cellSet); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet4() +{ + vtkm::cont::DataSet dataSet; + + constexpr int nVerts = 12; + using CoordType = vtkm::Vec3f_32; + constexpr CoordType coordinates[nVerts] = { + CoordType(0, 0, 0), CoordType(1, 0, 0), CoordType(1, 0, 1), CoordType(0, 0, 1), + CoordType(0, 1, 0), CoordType(1, 1, 0), CoordType(1, 1, 1), CoordType(0, 1, 1), + CoordType(2, 0, 0), CoordType(2, 0, 1), CoordType(2, 1, 1), CoordType(2, 1, 0) + }; + constexpr vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f, 60.2f, + 70.2f, 80.3f, 90.f, 10.f, 11.f, 12.f }; + + dataSet.AddCoordinateSystem( + vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); + + //Set point scalar + dataSet.AddField(make_Field( + "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); + + //Set cell scalar + vtkm::Float32 cellvar[2] = { 100.1f, 110.f }; + dataSet.AddField(make_Field( + "cellvar", vtkm::cont::Field::Association::CELL_SET, cellvar, 2, vtkm::CopyFlag::On)); + + vtkm::cont::CellSetExplicit<> cellSet; + vtkm::Vec ids; + ids[0] = 0; + ids[1] = 4; + ids[2] = 5; + ids[3] = 1; + ids[4] = 3; + ids[5] = 7; + ids[6] = 6; + ids[7] = 2; + + cellSet.PrepareToAddCells(2, 16); + cellSet.AddCell(vtkm::CELL_SHAPE_HEXAHEDRON, 8, ids); + ids[0] = 1; + ids[1] = 5; + ids[2] = 11; + ids[3] = 8; + ids[4] = 2; + ids[5] = 6; + ids[6] = 10; + ids[7] = 9; + cellSet.AddCell(vtkm::CELL_SHAPE_HEXAHEDRON, 8, ids); + cellSet.CompleteAddingCells(nVerts); + + //todo this need to be a reference/shared_ptr style class + dataSet.AddCellSet(cellSet); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet3() +{ + vtkm::cont::DataSet dataSet; + + constexpr int nVerts = 4; + using CoordType = vtkm::Vec3f_32; + constexpr CoordType coordinates[nVerts] = { + CoordType(0, 0, 0), CoordType(1, 0, 0), CoordType(1, 0, 1), CoordType(0, 1, 0) + }; + constexpr vtkm::Float32 vars[nVerts] = { 10.1f, 10.1f, 10.2f, 30.2f }; + + dataSet.AddCoordinateSystem( + vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); + + //Set point scalar + dataSet.AddField(make_Field( + "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); + + //Set cell scalar + vtkm::Float32 cellvar[2] = { 100.1f }; + dataSet.AddField(make_Field( + "cellvar", vtkm::cont::Field::Association::CELL_SET, cellvar, 1, vtkm::CopyFlag::On)); + + vtkm::cont::CellSetExplicit<> cellSet; + constexpr vtkm::Id4 ids{ 0, 1, 2, 3 }; + + cellSet.PrepareToAddCells(1, 4); + cellSet.AddCell(vtkm::CELL_SHAPE_TETRA, 4, ids); + cellSet.CompleteAddingCells(nVerts); + + //todo this need to be a reference/shared_ptr style class + dataSet.AddCellSet(cellSet); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet5() +{ + vtkm::cont::DataSet dataSet; + + constexpr int nVerts = 11; + using CoordType = vtkm::Vec3f_32; + constexpr CoordType coordinates[nVerts] = { + CoordType(0, 0, 0), CoordType(1, 0, 0), CoordType(1, 0, 1), CoordType(0, 0, 1), + CoordType(0, 1, 0), CoordType(1, 1, 0), CoordType(1, 1, 1), CoordType(0, 1, 1), + CoordType(2.0f, 0.5f, 0.5f), CoordType(0, 2, 0), CoordType(1, 2, 0) + }; + constexpr vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f, 60.2f, + 70.2f, 80.3f, 90.f, 10.f, 11.f }; + + dataSet.AddCoordinateSystem( + vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); + + //Set point scalar + dataSet.AddField(make_Field( + "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); + + //Set cell scalar + constexpr int nCells = 4; + constexpr vtkm::Float32 cellvar[nCells] = { 100.1f, 110.f, 120.2f, 130.5f }; + dataSet.AddField(make_Field( + "cellvar", vtkm::cont::Field::Association::CELL_SET, cellvar, nCells, vtkm::CopyFlag::On)); + + vtkm::cont::CellSetExplicit<> cellSet; + vtkm::Vec ids; + + cellSet.PrepareToAddCells(nCells, 23); + + ids[0] = 0; + ids[1] = 1; + ids[2] = 5; + ids[3] = 4; + ids[4] = 3; + ids[5] = 2; + ids[6] = 6; + ids[7] = 7; + cellSet.AddCell(vtkm::CELL_SHAPE_HEXAHEDRON, 8, ids); + + ids[0] = 1; + ids[1] = 5; + ids[2] = 6; + ids[3] = 2; + ids[4] = 8; + cellSet.AddCell(vtkm::CELL_SHAPE_PYRAMID, 5, ids); + + ids[0] = 5; + ids[1] = 8; + ids[2] = 10; + ids[3] = 6; + cellSet.AddCell(vtkm::CELL_SHAPE_TETRA, 4, ids); + + ids[0] = 4; + ids[1] = 7; + ids[2] = 9; + ids[3] = 5; + ids[4] = 6; + ids[5] = 10; + cellSet.AddCell(vtkm::CELL_SHAPE_WEDGE, 6, ids); + + cellSet.CompleteAddingCells(nVerts); + + //todo this need to be a reference/shared_ptr style class + dataSet.AddCellSet(cellSet); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet6() +{ + vtkm::cont::DataSet dataSet; + vtkm::cont::DataSetBuilderExplicit dsb; + vtkm::cont::DataSetFieldAdd dsf; + + // Coordinates + constexpr int nVerts = 8; + constexpr int nCells = 8; + using CoordType = vtkm::Vec3f_32; + const std::vector coords = { + { -0.707f, -0.354f, -0.354f }, { 0.000f, -0.854f, 0.146f }, { 0.000f, -0.146f, 0.854f }, + { -0.707f, 0.354f, 0.354f }, { 10.0f, 10.0f, 10.0f }, { 5.0f, 5.0f, 5.0f }, + { 0.0f, 0.0f, 2.0f }, { 0.0f, 0.0f, -2.0f } + }; + + // Connectivity + std::vector shapes; + std::vector numindices; + std::vector conn; + + shapes.push_back(vtkm::CELL_SHAPE_LINE); + numindices.push_back(2); + conn.push_back(0); + conn.push_back(1); + + shapes.push_back(vtkm::CELL_SHAPE_LINE); + numindices.push_back(2); + conn.push_back(2); + conn.push_back(3); + + shapes.push_back(vtkm::CELL_SHAPE_VERTEX); + numindices.push_back(1); + conn.push_back(4); + + shapes.push_back(vtkm::CELL_SHAPE_VERTEX); + numindices.push_back(1); + conn.push_back(5); + + shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); + numindices.push_back(3); + conn.push_back(2); + conn.push_back(3); + conn.push_back(5); + + shapes.push_back(vtkm::CELL_SHAPE_QUAD); + numindices.push_back(4); + conn.push_back(0); + conn.push_back(1); + conn.push_back(2); + conn.push_back(3); + + shapes.push_back(vtkm::CELL_SHAPE_TETRA); + numindices.push_back(4); + conn.push_back(0); + conn.push_back(2); + conn.push_back(3); + conn.push_back(6); + + shapes.push_back(vtkm::CELL_SHAPE_TETRA); + numindices.push_back(4); + conn.push_back(3); + conn.push_back(2); + conn.push_back(0); + conn.push_back(7); + + dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates"); + + // Field data + constexpr vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, + 94.0f, 71.0f, 47.0f, 57.0f }; + constexpr vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f }; + + dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); + dsf.AddCellField(dataSet, "cellvar", cellvar, nCells); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetZoo() +{ + vtkm::cont::DataSet dataSet; + vtkm::cont::DataSetBuilderExplicit dsb; + vtkm::cont::DataSetFieldAdd dsf; + + // Coordinates + constexpr int nVerts = 30; + constexpr int nCells = 25; + using CoordType = vtkm::Vec3f_32; + + const std::vector coords = + + { { 0.00f, 0.00f, 0.00f }, { 1.00f, 0.00f, 0.00f }, { 2.00f, 0.00f, 0.00f }, + { 0.00f, 0.00f, 1.00f }, { 1.00f, 0.00f, 1.00f }, { 2.00f, 0.00f, 1.00f }, + { 0.00f, 1.00f, 0.00f }, { 1.00f, 1.00f, 0.00f }, { 2.00f, 1.00f, 0.00f }, + { 0.00f, 1.00f, 1.00f }, { 1.00f, 1.00f, 1.00f }, { 2.00f, 1.00f, 1.00f }, + { 0.00f, 2.00f, 0.00f }, { 1.00f, 2.00f, 0.00f }, { 2.00f, 2.00f, 0.00f }, + { 0.00f, 2.00f, 1.00f }, { 1.00f, 2.00f, 1.00f }, { 2.00f, 2.00f, 1.00f }, + { 1.00f, 3.00f, 1.00f }, { 2.75f, 0.00f, 1.00f }, { 3.00f, 0.00f, 0.75f }, + { 3.00f, 0.25f, 1.00f }, { 3.00f, 1.00f, 1.00f }, { 3.00f, 1.00f, 0.00f }, + { 2.57f, 2.00f, 1.00f }, { 3.00f, 1.75f, 1.00f }, { 3.00f, 1.75f, 0.75f }, + { 3.00f, 0.00f, 0.00f }, { 2.57f, 0.42f, 0.57f }, { 2.59f, 1.43f, 0.71f } }; + + // Connectivity + std::vector shapes; + std::vector numindices; + std::vector conn; + + shapes.push_back(vtkm::CELL_SHAPE_HEXAHEDRON); + numindices.push_back(8); + conn.push_back(0); + conn.push_back(3); + conn.push_back(4); + conn.push_back(1); + conn.push_back(6); + conn.push_back(9); + conn.push_back(10); + conn.push_back(7); + + shapes.push_back(vtkm::CELL_SHAPE_HEXAHEDRON); + numindices.push_back(8); + conn.push_back(1); + conn.push_back(4); + conn.push_back(5); + conn.push_back(2); + conn.push_back(7); + conn.push_back(10); + conn.push_back(11); + conn.push_back(8); + + shapes.push_back(vtkm::CELL_SHAPE_TETRA); + numindices.push_back(4); + conn.push_back(23); + conn.push_back(26); + conn.push_back(24); + conn.push_back(29); + + shapes.push_back(vtkm::CELL_SHAPE_TETRA); + numindices.push_back(4); + conn.push_back(24); + conn.push_back(26); + conn.push_back(25); + conn.push_back(29); + + shapes.push_back(vtkm::CELL_SHAPE_TETRA); + numindices.push_back(4); + conn.push_back(8); + conn.push_back(17); + conn.push_back(11); + conn.push_back(29); + + shapes.push_back(vtkm::CELL_SHAPE_TETRA); + numindices.push_back(4); + conn.push_back(17); + conn.push_back(24); + conn.push_back(25); + conn.push_back(29); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(24); + conn.push_back(17); + conn.push_back(8); + conn.push_back(23); + conn.push_back(29); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(23); + conn.push_back(8); + conn.push_back(11); + conn.push_back(22); + conn.push_back(29); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(25); + conn.push_back(22); + conn.push_back(11); + conn.push_back(17); + conn.push_back(29); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(26); + conn.push_back(23); + conn.push_back(22); + conn.push_back(25); + conn.push_back(29); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(23); + conn.push_back(8); + conn.push_back(2); + conn.push_back(27); + conn.push_back(28); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(22); + conn.push_back(11); + conn.push_back(8); + conn.push_back(23); + conn.push_back(28); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(11); + conn.push_back(5); + conn.push_back(2); + conn.push_back(8); + conn.push_back(28); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(21); + conn.push_back(19); + conn.push_back(5); + conn.push_back(11); + conn.push_back(28); + + shapes.push_back(vtkm::CELL_SHAPE_TETRA); + numindices.push_back(4); + conn.push_back(11); + conn.push_back(22); + conn.push_back(21); + conn.push_back(28); + + shapes.push_back(vtkm::CELL_SHAPE_TETRA); + numindices.push_back(4); + conn.push_back(5); + conn.push_back(19); + conn.push_back(20); + conn.push_back(28); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(23); + conn.push_back(27); + conn.push_back(20); + conn.push_back(21); + conn.push_back(28); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(20); + conn.push_back(27); + conn.push_back(2); + conn.push_back(5); + conn.push_back(28); + + shapes.push_back(vtkm::CELL_SHAPE_TETRA); + numindices.push_back(4); + conn.push_back(19); + conn.push_back(21); + conn.push_back(20); + conn.push_back(28); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(7); + conn.push_back(6); + conn.push_back(12); + conn.push_back(13); + conn.push_back(16); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(6); + conn.push_back(9); + conn.push_back(15); + conn.push_back(12); + conn.push_back(16); + + shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); + numindices.push_back(5); + conn.push_back(6); + conn.push_back(7); + conn.push_back(10); + conn.push_back(9); + conn.push_back(16); + + shapes.push_back(vtkm::CELL_SHAPE_TETRA); + numindices.push_back(4); + conn.push_back(12); + conn.push_back(15); + conn.push_back(16); + conn.push_back(18); + + shapes.push_back(vtkm::CELL_SHAPE_WEDGE); + numindices.push_back(6); + conn.push_back(8); + conn.push_back(14); + conn.push_back(17); + conn.push_back(7); + conn.push_back(13); + conn.push_back(16); + + shapes.push_back(vtkm::CELL_SHAPE_WEDGE); + numindices.push_back(6); + conn.push_back(11); + conn.push_back(8); + conn.push_back(17); + conn.push_back(10); + conn.push_back(7); + conn.push_back(16); + + dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates"); + + // Field data + constexpr vtkm::Float32 pointvar[nVerts] = + + { 4.0, 5.0f, 9.5f, 5.5f, 6.0f, 9.5f, 5.0f, 5.5f, 5.7f, 6.5f, 6.4f, 6.9f, 6.6f, 6.1f, 7.1f, + 7.2f, 7.3f, 7.4f, 9.1f, 9.2f, 9.3f, 5.4f, 9.5f, 9.6f, 6.7f, 9.8f, 6.0f, 4.3f, 4.9f, 4.1f }; + + constexpr vtkm::Float32 cellvar[nCells] = + + { 4.0f, 5.0f, 9.5f, 5.5f, 6.0f, 9.5f, 5.0f, 5.5f, 5.7f, 6.5f, 6.4f, 6.9f, 6.6f, + 6.1f, 7.1f, 7.2f, 7.3f, 7.4f, 9.1f, 9.2f, 9.3f, 5.4f, 9.5f, 9.6f, 6.7f }; + + dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); + dsf.AddCellField(dataSet, "cellvar", cellvar, nCells); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet7() +{ + vtkm::cont::DataSet dataSet; + vtkm::cont::DataSetBuilderExplicit dsb; + vtkm::cont::DataSetFieldAdd dsf; + + // Coordinates + constexpr int nVerts = 8; + constexpr int nCells = 8; + + using CoordType = vtkm::Vec3f_32; + const std::vector coords = + + { { -0.707f, -0.354f, -0.354f }, { 0.000f, -0.854f, 0.146f }, { 0.000f, -0.146f, 0.854f }, + { -0.707f, 0.354f, 0.354f }, { 10.0f, 10.0f, 10.0f }, { 5.0f, 5.0f, 5.0f }, + { 0.0f, 0.0f, 2.0f }, { 0.0f, 0.0f, -2.0f } }; + + // Connectivity + std::vector shapes; + std::vector numindices; + std::vector conn; + + + shapes.push_back(vtkm::CELL_SHAPE_VERTEX); + numindices.push_back(1); + conn.push_back(0); + + shapes.push_back(vtkm::CELL_SHAPE_VERTEX); + numindices.push_back(1); + conn.push_back(1); + + shapes.push_back(vtkm::CELL_SHAPE_VERTEX); + numindices.push_back(1); + conn.push_back(2); + + shapes.push_back(vtkm::CELL_SHAPE_VERTEX); + numindices.push_back(1); + conn.push_back(3); + + shapes.push_back(vtkm::CELL_SHAPE_VERTEX); + numindices.push_back(1); + conn.push_back(4); + + shapes.push_back(vtkm::CELL_SHAPE_VERTEX); + numindices.push_back(1); + conn.push_back(5); + + shapes.push_back(vtkm::CELL_SHAPE_VERTEX); + numindices.push_back(1); + conn.push_back(6); + + shapes.push_back(vtkm::CELL_SHAPE_VERTEX); + numindices.push_back(1); + conn.push_back(7); + + + dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates"); + + // Field data + constexpr vtkm::Float32 pointvar[nVerts] = { + 100.0f, 78.0f, 49.0f, 17.0f, 10.f, 20.f, 33.f, 52.f + }; + constexpr vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f }; + + dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); + dsf.AddCellField(dataSet, "cellvar", cellvar, nCells); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet8() +{ + vtkm::cont::DataSet dataSet; + vtkm::cont::DataSetBuilderExplicit dsb; + vtkm::cont::DataSetFieldAdd dsf; + + // Coordinates + constexpr int nVerts = 8; + constexpr int nCells = 10; + using CoordType = vtkm::Vec3f_32; + const std::vector coords = { + { -0.707f, -0.354f, -0.354f }, { 0.000f, -0.854f, 0.146f }, { 0.000f, -0.146f, 0.854f }, + { -0.707f, 0.354f, 0.354f }, { 10.0f, 10.0f, 10.0f }, { 5.0f, 5.0f, 5.0f }, + { 0.0f, 0.0f, 2.0f }, { 0.0f, 0.0f, -2.0f } + }; + + // Connectivity + std::vector shapes; + std::vector numindices; + std::vector conn; + + //I need two triangles because the leaf needs four nodes otherwise segfault? + shapes.push_back(vtkm::CELL_SHAPE_LINE); + numindices.push_back(2); + conn.push_back(0); + conn.push_back(1); + + shapes.push_back(vtkm::CELL_SHAPE_LINE); + numindices.push_back(2); + conn.push_back(1); + conn.push_back(2); + + shapes.push_back(vtkm::CELL_SHAPE_LINE); + numindices.push_back(2); + conn.push_back(2); + conn.push_back(3); + + shapes.push_back(vtkm::CELL_SHAPE_LINE); + numindices.push_back(2); + conn.push_back(3); + conn.push_back(4); + + shapes.push_back(vtkm::CELL_SHAPE_LINE); + numindices.push_back(2); + conn.push_back(4); + conn.push_back(5); + + shapes.push_back(vtkm::CELL_SHAPE_LINE); + numindices.push_back(2); + conn.push_back(5); + conn.push_back(6); + + shapes.push_back(vtkm::CELL_SHAPE_LINE); + numindices.push_back(2); + conn.push_back(6); + conn.push_back(7); + + shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); + numindices.push_back(3); + conn.push_back(2); + conn.push_back(5); + conn.push_back(4); + + shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); + numindices.push_back(3); + conn.push_back(4); + conn.push_back(5); + conn.push_back(6); + + dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates"); + + // Field data + constexpr vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, + 94.0f, 71.0f, 47.0f, 57.0f }; + constexpr vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, + 5.0f, 6.0f, 7.0f, 8.0f, 9.0f }; + + dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); + dsf.AddCellField(dataSet, "cellvar", cellvar, nCells); + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetPolygonal() +{ + vtkm::cont::DataSet dataSet; + vtkm::cont::DataSetBuilderExplicit dsb; + vtkm::cont::DataSetFieldAdd dsf; + + // Coordinates + constexpr int nVerts = 8; + constexpr int nCells = 8; + const std::vector coords = { + { -0.707f, -0.354f, -0.354f }, { 0.000f, -0.854f, 0.146f }, { 0.000f, -0.146f, 0.854f }, + { -0.707f, 0.354f, 0.354f }, { 0.000f, 0.146f, -0.854f }, { 0.000f, 0.854f, -0.146f }, + { 0.707f, 0.354f, 0.354f }, { 0.707f, -0.354f, -0.354f } + }; + + // Connectivity + std::vector shapes; + std::vector numindices; + std::vector conn; + + shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); + numindices.push_back(3); + conn.push_back(0); + conn.push_back(1); + conn.push_back(3); + + shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); + numindices.push_back(3); + conn.push_back(1); + conn.push_back(2); + conn.push_back(3); + + shapes.push_back(vtkm::CELL_SHAPE_QUAD); + numindices.push_back(4); + conn.push_back(4); + conn.push_back(5); + conn.push_back(6); + conn.push_back(7); + + shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); + numindices.push_back(3); + conn.push_back(0); + conn.push_back(4); + conn.push_back(1); + + shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); + numindices.push_back(3); + conn.push_back(4); + conn.push_back(7); + conn.push_back(1); + + shapes.push_back(vtkm::CELL_SHAPE_POLYGON); + numindices.push_back(4); + conn.push_back(3); + conn.push_back(2); + conn.push_back(6); + conn.push_back(5); + + shapes.push_back(vtkm::CELL_SHAPE_QUAD); + numindices.push_back(4); + conn.push_back(0); + conn.push_back(3); + conn.push_back(5); + conn.push_back(4); + + shapes.push_back(vtkm::CELL_SHAPE_POLYGON); + numindices.push_back(4); + conn.push_back(1); + conn.push_back(7); + conn.push_back(6); + conn.push_back(2); + + dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates"); + + // Field data + vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, 94.0f, 71.0f, 47.0f, 33.0f }; + vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f }; + + dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); + dsf.AddCellField(dataSet, "cellvar", cellvar, nCells); + + return dataSet; +} + +vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetCowNose() +{ + // prepare data array + constexpr int nVerts = 17; + using CoordType = vtkm::Vec3f_64; + constexpr CoordType coordinates[nVerts] = { + CoordType(0.0480879, 0.151874, 0.107334), CoordType(0.0293568, 0.245532, 0.125337), + CoordType(0.0224398, 0.246495, 0.1351), CoordType(0.0180085, 0.20436, 0.145316), + CoordType(0.0307091, 0.152142, 0.0539249), CoordType(0.0270341, 0.242992, 0.107567), + CoordType(0.000684071, 0.00272505, 0.175648), CoordType(0.00946217, 0.077227, 0.187097), + CoordType(-0.000168991, 0.0692243, 0.200755), CoordType(-0.000129414, 0.00247137, 0.176561), + CoordType(0.0174172, 0.137124, 0.124553), CoordType(0.00325994, 0.0797155, 0.184912), + CoordType(0.00191765, 0.00589327, 0.16608), CoordType(0.0174716, 0.0501928, 0.0930275), + CoordType(0.0242103, 0.250062, 0.126256), CoordType(0.0108188, 0.152774, 0.167914), + CoordType(5.41687e-05, 0.00137834, 0.175119) + }; + constexpr int connectivitySize = 57; + constexpr vtkm::Id pointId[connectivitySize] = { 0, 1, 3, 2, 3, 1, 4, 5, 0, 1, 0, 5, + 7, 8, 6, 9, 6, 8, 0, 10, 7, 11, 7, 10, + 0, 6, 13, 12, 13, 6, 1, 5, 14, 1, 14, 2, + 0, 3, 15, 0, 13, 4, 6, 16, 12, 6, 9, 16, + 7, 11, 8, 0, 15, 10, 7, 6, 0 }; + + // create DataSet + vtkm::cont::DataSet dataSet; + dataSet.AddCoordinateSystem( + vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); + + vtkm::cont::ArrayHandle connectivity; + connectivity.Allocate(connectivitySize); + + for (vtkm::Id i = 0; i < connectivitySize; ++i) + { + connectivity.GetPortalControl().Set(i, pointId[i]); + } + vtkm::cont::CellSetSingleType<> cellSet; + cellSet.Fill(nVerts, vtkm::CELL_SHAPE_TRIANGLE, 3, connectivity); + dataSet.AddCellSet(cellSet); + + std::vector pointvar(nVerts); + std::iota(pointvar.begin(), pointvar.end(), 15.f); + std::vector cellvar(connectivitySize / 3); + std::iota(cellvar.begin(), cellvar.end(), 132.f); + + vtkm::cont::ArrayHandle pointvec; + pointvec.Allocate(nVerts); + SetPortal(pointvec.GetPortalControl()); + + vtkm::cont::ArrayHandle cellvec; + cellvec.Allocate(connectivitySize / 3); + SetPortal(cellvec.GetPortalControl()); + + vtkm::cont::DataSetFieldAdd dsf; + dsf.AddPointField(dataSet, "pointvar", pointvar); + dsf.AddCellField(dataSet, "cellvar", cellvar); + dsf.AddPointField(dataSet, "point_vectors", pointvec); + dsf.AddCellField(dataSet, "cell_vectors", cellvec); + + return dataSet; +} +} +} +} // namespace vtkm::cont::testing diff --git a/vtkm/cont/testing/MakeTestDataSet.h b/vtkm/cont/testing/MakeTestDataSet.h index 4493d6aa5ae4585338b1339ebf1133f94995ce6a..a09380490e695eafb633d11d884721a61957c056 100644 --- a/vtkm/cont/testing/MakeTestDataSet.h +++ b/vtkm/cont/testing/MakeTestDataSet.h @@ -11,16 +11,9 @@ #ifndef vtk_m_cont_testing_MakeTestDataSet_h #define vtk_m_cont_testing_MakeTestDataSet_h -#include #include -#include -#include -#include -#include - -#include -#include +#include namespace vtkm { @@ -29,7 +22,7 @@ namespace cont namespace testing { -class MakeTestDataSet +class VTKM_ALWAYS_EXPORT MakeTestDataSet { public: // 1D uniform datasets. @@ -76,1499 +69,6 @@ public: vtkm::cont::DataSet Make3DExplicitDataSetPolygonal(); vtkm::cont::DataSet Make3DExplicitDataSetCowNose(); }; - -//Make a simple 1D dataset. -inline vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet0() -{ - vtkm::cont::DataSetBuilderUniform dsb; - const vtkm::Id nVerts = 6; - vtkm::cont::DataSet dataSet = dsb.Create(nVerts); - - vtkm::cont::DataSetFieldAdd dsf; - vtkm::Float32 var[nVerts] = { -1.0f, .5f, -.2f, 1.7f, -.1f, .8f }; - vtkm::Float32 var2[nVerts] = { -1.1f, .7f, -.2f, 0.2f, -.1f, .4f }; - dsf.AddPointField(dataSet, "pointvar", var, nVerts); - dsf.AddPointField(dataSet, "pointvar2", var2, nVerts); - - return dataSet; -} - -//Make another simple 1D dataset. -inline vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet1() -{ - vtkm::cont::DataSetBuilderUniform dsb; - const vtkm::Id nVerts = 6; - vtkm::cont::DataSet dataSet = dsb.Create(nVerts); - - vtkm::cont::DataSetFieldAdd dsf; - vtkm::Float32 var[nVerts] = { 1.0e3f, 5.e5f, 2.e8f, 1.e10f, 2e12f, 3e15f }; - dsf.AddPointField(dataSet, "pointvar", var, nVerts); - - return dataSet; -} - - -//Make a simple 1D, 16 cell uniform dataset. -inline vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet2() -{ - vtkm::cont::DataSetBuilderUniform dsb; - constexpr vtkm::Id dims = 256; - vtkm::cont::DataSet dataSet = dsb.Create(dims); - - vtkm::cont::DataSetFieldAdd dsf; - vtkm::Float64 pointvar[dims]; - vtkm::Float64 dx = vtkm::Float64(4.0 * vtkm::Pi()) / vtkm::Float64(dims - 1); - - vtkm::Id idx = 0; - for (vtkm::Id x = 0; x < dims; ++x) - { - vtkm::Float64 cx = vtkm::Float64(x) * dx - 2.0 * vtkm::Pi(); - vtkm::Float64 cv = vtkm::Sin(cx); - - pointvar[idx] = cv; - idx++; - } - - dsf.AddPointField(dataSet, "pointvar", pointvar, dims); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make1DExplicitDataSet0() -{ - const int nVerts = 5; - using CoordType = vtkm::Vec3f_32; - std::vector coords(nVerts); - coords[0] = CoordType(0.0f, 0.f, 0.f); - coords[1] = CoordType(1.0f, 0.f, 0.f); - coords[2] = CoordType(1.1f, 0.f, 0.f); - coords[3] = CoordType(1.2f, 0.f, 0.f); - coords[4] = CoordType(4.0f, 0.f, 0.f); - - // Each line connects two consecutive vertices - std::vector conn; - for (int i = 0; i < nVerts - 1; i++) - { - conn.push_back(i); - conn.push_back(i + 1); - } - - vtkm::cont::DataSet dataSet; - vtkm::cont::DataSetBuilderExplicit dsb; - - dataSet = dsb.Create(coords, vtkm::CellShapeTagLine(), 2, conn, "coordinates", "cells"); - - vtkm::cont::DataSetFieldAdd dsf; - vtkm::Float32 var[nVerts] = { -1.0f, .5f, -.2f, 1.7f, .8f }; - dsf.AddPointField(dataSet, "pointvar", var, nVerts); - - return dataSet; -} - -//Make a simple 2D, 2 cell uniform dataset. -inline vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet0() -{ - vtkm::cont::DataSetBuilderUniform dsb; - vtkm::Id2 dimensions(3, 2); - vtkm::cont::DataSet dataSet = dsb.Create(dimensions); - - vtkm::cont::DataSetFieldAdd dsf; - const vtkm::Id nVerts = 6; - vtkm::Float32 var[nVerts] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f }; - - dsf.AddPointField(dataSet, "pointvar", var, nVerts); - - vtkm::Float32 cellvar[2] = { 100.1f, 200.1f }; - dsf.AddCellField(dataSet, "cellvar", cellvar, 2, "cells"); - - return dataSet; -} - -//Make a simple 2D, 16 cell uniform dataset. -inline vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet1() -{ - vtkm::cont::DataSetBuilderUniform dsb; - vtkm::Id2 dimensions(5, 5); - vtkm::cont::DataSet dataSet = dsb.Create(dimensions); - - vtkm::cont::DataSetFieldAdd dsf; - const vtkm::Id nVerts = 25; - const vtkm::Id nCells = 16; - vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, 1.0f, 94.0f, 71.0f, 47.0f, 33.0f, - 6.0f, 52.0f, 44.0f, 50.0f, 45.0f, 48.0f, 8.0f, 12.0f, 46.0f, - 91.0f, 43.0f, 0.0f, 5.0f, 51.0f, 76.0f, 83.0f }; - vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, - 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f }; - - dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); - dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells"); - - return dataSet; -} - -//Make a simple 2D, 16 cell uniform dataset. -inline vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet2() -{ - vtkm::cont::DataSetBuilderUniform dsb; - vtkm::Id2 dims(16, 16); - vtkm::cont::DataSet dataSet = dsb.Create(dims); - - vtkm::cont::DataSetFieldAdd dsf; - constexpr vtkm::Id nVerts = 256; - vtkm::Float64 pointvar[nVerts]; - vtkm::Float64 dx = vtkm::Float64(4.0 * vtkm::Pi()) / vtkm::Float64(dims[0] - 1); - vtkm::Float64 dy = vtkm::Float64(2.0 * vtkm::Pi()) / vtkm::Float64(dims[1] - 1); - - vtkm::Id idx = 0; - for (vtkm::Id y = 0; y < dims[1]; ++y) - { - vtkm::Float64 cy = vtkm::Float64(y) * dy - vtkm::Pi(); - for (vtkm::Id x = 0; x < dims[0]; ++x) - { - vtkm::Float64 cx = vtkm::Float64(x) * dx - 2.0 * vtkm::Pi(); - vtkm::Float64 cv = vtkm::Sin(cx) + vtkm::Sin(cy) + - 2.0 * vtkm::Cos(vtkm::Sqrt((cx * cx) / 2.0 + cy * cy) / 0.75) + - 4.0 * vtkm::Cos(cx * cy / 4.0); - - pointvar[idx] = cv; - idx++; - } - } // y - - dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); - - return dataSet; -} -//Make a simple 3D, 4 cell uniform dataset. -inline vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet0() -{ - vtkm::cont::DataSetBuilderUniform dsb; - vtkm::Id3 dimensions(3, 2, 3); - vtkm::cont::DataSet dataSet = dsb.Create(dimensions); - - vtkm::cont::DataSetFieldAdd dsf; - const int nVerts = 18; - vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.2f, 60.2f, - 70.2f, 80.2f, 90.3f, 100.3f, 110.3f, 120.3f, - 130.4f, 140.4f, 150.4f, 160.4f, 170.5f, 180.5f }; - - //Set point and cell scalar - dsf.AddPointField(dataSet, "pointvar", vars, nVerts); - - vtkm::Float32 cellvar[4] = { 100.1f, 100.2f, 100.3f, 100.4f }; - dsf.AddCellField(dataSet, "cellvar", cellvar, 4, "cells"); - - return dataSet; -} - -//Make a simple 3D, 64 cell uniform dataset. -inline vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet1() -{ - vtkm::cont::DataSetBuilderUniform dsb; - vtkm::Id3 dimensions(5, 5, 5); - vtkm::cont::DataSet dataSet = dsb.Create(dimensions); - - vtkm::cont::DataSetFieldAdd dsf; - const vtkm::Id nVerts = 125; - const vtkm::Id nCells = 64; - vtkm::Float32 pointvar[nVerts] = { - 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, - - 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 99.0f, 90.0f, 85.0f, 0.0f, 0.0f, 95.0f, 80.0f, - 95.0f, 0.0f, 0.0f, 85.0f, 90.0f, 99.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, - - 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 75.0f, 50.0f, 65.0f, 0.0f, 0.0f, 55.0f, 15.0f, - 45.0f, 0.0f, 0.0f, 60.0f, 40.0f, 70.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, - - 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 97.0f, 87.0f, 82.0f, 0.0f, 0.0f, 92.0f, 77.0f, - 92.0f, 0.0f, 0.0f, 82.0f, 87.0f, 97.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, - - 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f - }; - vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, - 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, - - 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, - 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 30.0f, 31.0f, - - 32.0f, 33.0f, 34.0f, 35.0f, 36.0f, 37.0f, 38.0f, 39.0f, - 40.0f, 41.0f, 42.0f, 43.0f, 44.0f, 45.0f, 46.0f, 47.0f, - - 48.0f, 49.0f, 50.0f, 51.0f, 52.0f, 53.0f, 54.0f, 55.0f, - 56.0f, 57.0f, 58.0f, 59.0f, 60.0f, 61.0f, 62.0f, 63.0f }; - - dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); - dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells"); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet2() -{ - const vtkm::Id base_size = 256; - vtkm::cont::DataSetBuilderUniform dsb; - vtkm::Id3 dimensions(base_size, base_size, base_size); - vtkm::cont::DataSet dataSet = dsb.Create(dimensions); - - vtkm::cont::DataSetFieldAdd dsf; - const vtkm::Id nVerts = base_size * base_size * base_size; - vtkm::Float32* pointvar = new vtkm::Float32[nVerts]; - - for (vtkm::Id z = 0; z < base_size; ++z) - for (vtkm::Id y = 0; y < base_size; ++y) - for (vtkm::Id x = 0; x < base_size; ++x) - { - std::size_t index = static_cast(z * base_size * base_size + y * base_size + x); - pointvar[index] = vtkm::Sqrt(vtkm::Float32(x * x + y * y + z * z)); - } - - dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); - - delete[] pointvar; - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet3(const vtkm::Id3 dims) -{ - vtkm::cont::DataSetBuilderUniform dsb; - vtkm::cont::DataSet dataSet = dsb.Create(dims); - - // add point scalar field - vtkm::Id numPoints = dims[0] * dims[1] * dims[2]; - std::vector pointvar(static_cast(numPoints)); - - vtkm::Float64 dx = vtkm::Float64(4.0 * vtkm::Pi()) / vtkm::Float64(dims[0] - 1); - vtkm::Float64 dy = vtkm::Float64(2.0 * vtkm::Pi()) / vtkm::Float64(dims[1] - 1); - vtkm::Float64 dz = vtkm::Float64(3.0 * vtkm::Pi()) / vtkm::Float64(dims[2] - 1); - - vtkm::Id idx = 0; - for (vtkm::Id z = 0; z < dims[2]; ++z) - { - vtkm::Float64 cz = vtkm::Float64(z) * dz - 1.5 * vtkm::Pi(); - for (vtkm::Id y = 0; y < dims[1]; ++y) - { - vtkm::Float64 cy = vtkm::Float64(y) * dy - vtkm::Pi(); - for (vtkm::Id x = 0; x < dims[0]; ++x) - { - vtkm::Float64 cx = vtkm::Float64(x) * dx - 2.0 * vtkm::Pi(); - vtkm::Float64 cv = vtkm::Sin(cx) + vtkm::Sin(cy) + - 2.0 * vtkm::Cos(vtkm::Sqrt((cx * cx) / 2.0 + cy * cy) / 0.75) + - 4.0 * vtkm::Cos(cx * cy / 4.0); - - if (dims[2] > 1) - { - cv += vtkm::Sin(cz) + 1.5 * vtkm::Cos(vtkm::Sqrt(cx * cx + cy * cy + cz * cz) / 0.75); - } - pointvar[static_cast(idx)] = cv; - idx++; - } - } // y - } // z - - vtkm::cont::DataSetFieldAdd dsf; - dsf.AddPointField(dataSet, "pointvar", pointvar); - - vtkm::Id numCells = (dims[0] - 1) * (dims[1] - 1) * (dims[2] - 1); - dsf.AddCellField( - dataSet, - "cellvar", - vtkm::cont::make_ArrayHandleCounting(vtkm::Float64(0), vtkm::Float64(1), numCells)); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make2DRectilinearDataSet0() -{ - vtkm::cont::DataSetBuilderRectilinear dsb; - std::vector X(3), Y(2); - - X[0] = 0.0f; - X[1] = 1.0f; - X[2] = 2.0f; - Y[0] = 0.0f; - Y[1] = 1.0f; - - vtkm::cont::DataSet dataSet = dsb.Create(X, Y); - - vtkm::cont::DataSetFieldAdd dsf; - const vtkm::Id nVerts = 6; - vtkm::Float32 var[nVerts]; - for (int i = 0; i < nVerts; i++) - var[i] = (vtkm::Float32)i; - dsf.AddPointField(dataSet, "pointvar", var, nVerts); - - const vtkm::Id nCells = 2; - vtkm::Float32 cellvar[nCells]; - for (int i = 0; i < nCells; i++) - cellvar[i] = (vtkm::Float32)i; - dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells"); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DRegularDataSet0() -{ - vtkm::cont::DataSet dataSet; - - const int nVerts = 18; - vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vtkm::Id3(3, 2, 3)); - vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.2f, 60.2f, - 70.2f, 80.2f, 90.3f, 100.3f, 110.3f, 120.3f, - 130.4f, 140.4f, 150.4f, 160.4f, 170.5f, 180.5f }; - - dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates)); - - //Set point scalar - dataSet.AddField(make_Field( - "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); - - //Set cell scalar - vtkm::Float32 cellvar[4] = { 100.1f, 100.2f, 100.3f, 100.4f }; - dataSet.AddField(make_Field( - "cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 4, vtkm::CopyFlag::On)); - - static constexpr vtkm::IdComponent dim = 3; - vtkm::cont::CellSetStructured cellSet("cells"); - cellSet.SetPointDimensions(vtkm::make_Vec(3, 2, 3)); - dataSet.AddCellSet(cellSet); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DRegularDataSet1() -{ - vtkm::cont::DataSet dataSet; - - const int nVerts = 8; - vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vtkm::Id3(2, 2, 2)); - vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.2f, 60.2f, 70.2f, 80.2f }; - - dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates)); - - //Set point scalar - dataSet.AddField(make_Field( - "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); - - //Set cell scalar - vtkm::Float32 cellvar[1] = { 100.1f }; - dataSet.AddField(make_Field( - "cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 1, vtkm::CopyFlag::On)); - - static constexpr vtkm::IdComponent dim = 3; - vtkm::cont::CellSetStructured cellSet("cells"); - cellSet.SetPointDimensions(vtkm::make_Vec(2, 2, 2)); - dataSet.AddCellSet(cellSet); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DRectilinearDataSet0() -{ - vtkm::cont::DataSetBuilderRectilinear dsb; - std::vector X(3), Y(2), Z(3); - - X[0] = 0.0f; - X[1] = 1.0f; - X[2] = 2.0f; - Y[0] = 0.0f; - Y[1] = 1.0f; - Z[0] = 0.0f; - Z[1] = 1.0f; - Z[2] = 2.0f; - - vtkm::cont::DataSet dataSet = dsb.Create(X, Y, Z); - - vtkm::cont::DataSetFieldAdd dsf; - const vtkm::Id nVerts = 18; - vtkm::Float32 var[nVerts]; - for (int i = 0; i < nVerts; i++) - var[i] = (vtkm::Float32)i; - dsf.AddPointField(dataSet, "pointvar", var, nVerts); - - const vtkm::Id nCells = 4; - vtkm::Float32 cellvar[nCells]; - for (int i = 0; i < nCells; i++) - cellvar[i] = (vtkm::Float32)i; - dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells"); - - return dataSet; -} - -// Make a 2D explicit dataset -inline vtkm::cont::DataSet MakeTestDataSet::Make2DExplicitDataSet0() -{ - vtkm::cont::DataSet dataSet; - vtkm::cont::DataSetBuilderExplicit dsb; - vtkm::cont::DataSetFieldAdd dsf; - - // Coordinates - const int nVerts = 16; - const int nCells = 7; - using CoordType = vtkm::Vec3f_32; - std::vector coords(nVerts); - - coords[0] = CoordType(0, 0, 0); - coords[1] = CoordType(1, 0, 0); - coords[2] = CoordType(2, 0, 0); - coords[3] = CoordType(3, 0, 0); - coords[4] = CoordType(0, 1, 0); - coords[5] = CoordType(1, 1, 0); - coords[6] = CoordType(2, 1, 0); - coords[7] = CoordType(3, 1, 0); - coords[8] = CoordType(0, 2, 0); - coords[9] = CoordType(1, 2, 0); - coords[10] = CoordType(2, 2, 0); - coords[11] = CoordType(3, 2, 0); - coords[12] = CoordType(0, 3, 0); - coords[13] = CoordType(3, 3, 0); - coords[14] = CoordType(1, 4, 0); - coords[15] = CoordType(2, 4, 0); - - // Connectivity - std::vector shapes; - std::vector numindices; - std::vector conn; - - shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); - numindices.push_back(3); - conn.push_back(0); - conn.push_back(1); - conn.push_back(5); - - shapes.push_back(vtkm::CELL_SHAPE_QUAD); - numindices.push_back(4); - conn.push_back(1); - conn.push_back(2); - conn.push_back(6); - conn.push_back(5); - - shapes.push_back(vtkm::CELL_SHAPE_QUAD); - numindices.push_back(4); - conn.push_back(5); - conn.push_back(6); - conn.push_back(10); - conn.push_back(9); - - shapes.push_back(vtkm::CELL_SHAPE_QUAD); - numindices.push_back(4); - conn.push_back(4); - conn.push_back(5); - conn.push_back(9); - conn.push_back(8); - - shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); - numindices.push_back(3); - conn.push_back(2); - conn.push_back(3); - conn.push_back(7); - - shapes.push_back(vtkm::CELL_SHAPE_QUAD); - numindices.push_back(4); - conn.push_back(6); - conn.push_back(7); - conn.push_back(11); - conn.push_back(10); - - shapes.push_back(vtkm::CELL_SHAPE_POLYGON); - numindices.push_back(6); - conn.push_back(9); - conn.push_back(10); - conn.push_back(13); - conn.push_back(15); - conn.push_back(14); - conn.push_back(12); - dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates", "cells"); - - // Field data - vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, 94.0f, 71.0f, 47.0f, 33.0f, - 52.0f, 44.0f, 50.0f, 45.0f, 8.0f, 12.0f, 46.0f, 91.0f }; - vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f }; - - dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); - dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells"); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet0() -{ - vtkm::cont::DataSet dataSet; - vtkm::cont::DataSetBuilderExplicit dsb; - - const int nVerts = 5; - using CoordType = vtkm::Vec3f_32; - std::vector coords(nVerts); - coords[0] = CoordType(0, 0, 0); - coords[1] = CoordType(1, 0, 0); - coords[2] = CoordType(1, 1, 0); - coords[3] = CoordType(2, 1, 0); - coords[4] = CoordType(2, 2, 0); - - //Connectivity - std::vector shapes; - shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); - shapes.push_back(vtkm::CELL_SHAPE_QUAD); - - std::vector numindices; - numindices.push_back(3); - numindices.push_back(4); - - std::vector conn; - // First Cell: Triangle - conn.push_back(0); - conn.push_back(1); - conn.push_back(2); - // Second Cell: Quad - conn.push_back(2); - conn.push_back(1); - conn.push_back(3); - conn.push_back(4); - - //Create the dataset. - dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates", "cells"); - - vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f }; - vtkm::Float32 cellvar[2] = { 100.1f, 100.2f }; - - vtkm::cont::DataSetFieldAdd dsf; - dsf.AddPointField(dataSet, "pointvar", vars, nVerts); - dsf.AddCellField(dataSet, "cellvar", cellvar, 2, "cells"); - - return dataSet; -} - -/* -inline vtkm::cont::DataSet -MakeTestDataSet::Make3DExplicitDataSet1() -{ - vtkm::cont::DataSet dataSet; - vtkm::cont::DataSetIterativeBuilderExplicit dsb; - vtkm::Id id0, id1, id2, id3, id4; - - dsb.Begin("coords", "cells"); - - id0 = dsb.AddPoint(0,0,0); - id1 = dsb.AddPoint(1,0,0); - id2 = dsb.AddPoint(1,1,0); - id3 = dsb.AddPoint(2,1,0); - id4 = dsb.AddPoint(2,2,0); - - vtkm::Id ids0[3] = {id0, id1, id2}; - dsb.AddCell(vtkm::CELL_SHAPE_TRIANGLE, ids0, 3); - - vtkm::Id ids1[4] = {id2, id1, id3, id4}; - dsb.AddCell(vtkm::CELL_SHAPE_QUAD, ids1, 4); - dataSet = dsb.Create(); - - vtkm::Float32 vars[5] = {10.1f, 20.1f, 30.2f, 40.2f, 50.3f}; - vtkm::Float32 cellvar[2] = {100.1f, 100.2f}; - - vtkm::cont::DataSetFieldAdd dsf; - dsf.AddPointField(dataSet, "pointvar", vars, 5); - dsf.AddCellField(dataSet, "cellvar", cellvar, 2, "cells"); - - return dataSet; -} - */ - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet1() -{ - vtkm::cont::DataSet dataSet; - vtkm::cont::DataSetBuilderExplicit dsb; - - const int nVerts = 5; - using CoordType = vtkm::Vec3f_32; - std::vector coords(nVerts); - - coords[0] = CoordType(0, 0, 0); - coords[1] = CoordType(1, 0, 0); - coords[2] = CoordType(1, 1, 0); - coords[3] = CoordType(2, 1, 0); - coords[4] = CoordType(2, 2, 0); - CoordType coordinates[nVerts] = { CoordType(0, 0, 0), - CoordType(1, 0, 0), - CoordType(1, 1, 0), - CoordType(2, 1, 0), - CoordType(2, 2, 0) }; - vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f }; - - dataSet.AddCoordinateSystem( - vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); - vtkm::cont::CellSetExplicit<> cellSet("cells"); - cellSet.PrepareToAddCells(2, 7); - cellSet.AddCell(vtkm::CELL_SHAPE_TRIANGLE, 3, make_Vec(0, 1, 2)); - cellSet.AddCell(vtkm::CELL_SHAPE_QUAD, 4, make_Vec(2, 1, 3, 4)); - cellSet.CompleteAddingCells(nVerts); - dataSet.AddCellSet(cellSet); - - //Set point scalar - dataSet.AddField(make_Field( - "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); - - //Set cell scalar - vtkm::Float32 cellvar[2] = { 100.1f, 100.2f }; - dataSet.AddField(make_Field( - "cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 2, vtkm::CopyFlag::On)); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet2() -{ - vtkm::cont::DataSet dataSet; - - const int nVerts = 8; - using CoordType = vtkm::Vec3f_32; - CoordType coordinates[nVerts] = { - CoordType(0, 0, 0), // 0 - CoordType(1, 0, 0), // 1 - CoordType(1, 0, 1), // 2 - CoordType(0, 0, 1), // 3 - CoordType(0, 1, 0), // 4 - CoordType(1, 1, 0), // 5 - CoordType(1, 1, 1), // 6 - CoordType(0, 1, 1) // 7 - }; - vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f, 60.2f, 70.2f, 80.3f }; - - dataSet.AddCoordinateSystem( - vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); - - //Set point scalar - dataSet.AddField(make_Field( - "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); - - //Set cell scalar - vtkm::Float32 cellvar[2] = { 100.1f }; - dataSet.AddField(make_Field( - "cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 1, vtkm::CopyFlag::On)); - - vtkm::cont::CellSetExplicit<> cellSet("cells"); - vtkm::Vec ids; - ids[0] = 0; - ids[1] = 1; - ids[2] = 2; - ids[3] = 3; - ids[4] = 4; - ids[5] = 5; - ids[6] = 6; - ids[7] = 7; - - cellSet.PrepareToAddCells(1, 8); - cellSet.AddCell(vtkm::CELL_SHAPE_HEXAHEDRON, 8, ids); - cellSet.CompleteAddingCells(nVerts); - - //todo this need to be a reference/shared_ptr style class - dataSet.AddCellSet(cellSet); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet4() -{ - vtkm::cont::DataSet dataSet; - - const int nVerts = 12; - using CoordType = vtkm::Vec3f_32; - CoordType coordinates[nVerts] = { - CoordType(0, 0, 0), //0 - CoordType(1, 0, 0), //1 - CoordType(1, 0, 1), //2 - CoordType(0, 0, 1), //3 - CoordType(0, 1, 0), //4 - CoordType(1, 1, 0), //5 - CoordType(1, 1, 1), //6 - CoordType(0, 1, 1), //7 - CoordType(2, 0, 0), //8 - CoordType(2, 0, 1), //9 - CoordType(2, 1, 1), //10 - CoordType(2, 1, 0) //11 - }; - vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f, 60.2f, - 70.2f, 80.3f, 90.f, 10.f, 11.f, 12.f }; - - dataSet.AddCoordinateSystem( - vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); - - //Set point scalar - dataSet.AddField(make_Field( - "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); - - //Set cell scalar - vtkm::Float32 cellvar[2] = { 100.1f, 110.f }; - dataSet.AddField(make_Field( - "cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 2, vtkm::CopyFlag::On)); - - vtkm::cont::CellSetExplicit<> cellSet("cells"); - vtkm::Vec ids; - ids[0] = 0; - ids[1] = 4; - ids[2] = 5; - ids[3] = 1; - ids[4] = 3; - ids[5] = 7; - ids[6] = 6; - ids[7] = 2; - - cellSet.PrepareToAddCells(2, 16); - cellSet.AddCell(vtkm::CELL_SHAPE_HEXAHEDRON, 8, ids); - ids[0] = 1; - ids[1] = 5; - ids[2] = 11; - ids[3] = 8; - ids[4] = 2; - ids[5] = 6; - ids[6] = 10; - ids[7] = 9; - cellSet.AddCell(vtkm::CELL_SHAPE_HEXAHEDRON, 8, ids); - cellSet.CompleteAddingCells(nVerts); - - //todo this need to be a reference/shared_ptr style class - dataSet.AddCellSet(cellSet); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet3() -{ - vtkm::cont::DataSet dataSet; - - const int nVerts = 4; - using CoordType = vtkm::Vec3f_32; - CoordType coordinates[nVerts] = { - CoordType(0, 0, 0), CoordType(1, 0, 0), CoordType(1, 0, 1), CoordType(0, 1, 0) - }; - vtkm::Float32 vars[nVerts] = { 10.1f, 10.1f, 10.2f, 30.2f }; - - dataSet.AddCoordinateSystem( - vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); - - //Set point scalar - dataSet.AddField(make_Field( - "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); - - //Set cell scalar - vtkm::Float32 cellvar[2] = { 100.1f }; - dataSet.AddField(make_Field( - "cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 1, vtkm::CopyFlag::On)); - - vtkm::cont::CellSetExplicit<> cellSet("cells"); - vtkm::Id4 ids; - ids[0] = 0; - ids[1] = 1; - ids[2] = 2; - ids[3] = 3; - - cellSet.PrepareToAddCells(1, 4); - cellSet.AddCell(vtkm::CELL_SHAPE_TETRA, 4, ids); - cellSet.CompleteAddingCells(nVerts); - - //todo this need to be a reference/shared_ptr style class - dataSet.AddCellSet(cellSet); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet5() -{ - vtkm::cont::DataSet dataSet; - - const int nVerts = 11; - using CoordType = vtkm::Vec3f_32; - CoordType coordinates[nVerts] = { - CoordType(0, 0, 0), //0 - CoordType(1, 0, 0), //1 - CoordType(1, 0, 1), //2 - CoordType(0, 0, 1), //3 - CoordType(0, 1, 0), //4 - CoordType(1, 1, 0), //5 - CoordType(1, 1, 1), //6 - CoordType(0, 1, 1), //7 - CoordType(2, 0.5, 0.5), //8 - CoordType(0, 2, 0), //9 - CoordType(1, 2, 0) //10 - }; - vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f, 60.2f, - 70.2f, 80.3f, 90.f, 10.f, 11.f }; - - dataSet.AddCoordinateSystem( - vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); - - //Set point scalar - dataSet.AddField(make_Field( - "pointvar", vtkm::cont::Field::Association::POINTS, vars, nVerts, vtkm::CopyFlag::On)); - - //Set cell scalar - const int nCells = 4; - vtkm::Float32 cellvar[nCells] = { 100.1f, 110.f, 120.2f, 130.5f }; - dataSet.AddField(make_Field("cellvar", - vtkm::cont::Field::Association::CELL_SET, - "cells", - cellvar, - nCells, - vtkm::CopyFlag::On)); - - vtkm::cont::CellSetExplicit<> cellSet("cells"); - vtkm::Vec ids; - - cellSet.PrepareToAddCells(nCells, 23); - - ids[0] = 0; - ids[1] = 1; - ids[2] = 5; - ids[3] = 4; - ids[4] = 3; - ids[5] = 2; - ids[6] = 6; - ids[7] = 7; - cellSet.AddCell(vtkm::CELL_SHAPE_HEXAHEDRON, 8, ids); - - ids[0] = 1; - ids[1] = 5; - ids[2] = 6; - ids[3] = 2; - ids[4] = 8; - cellSet.AddCell(vtkm::CELL_SHAPE_PYRAMID, 5, ids); - - ids[0] = 5; - ids[1] = 8; - ids[2] = 10; - ids[3] = 6; - cellSet.AddCell(vtkm::CELL_SHAPE_TETRA, 4, ids); - - ids[0] = 4; - ids[1] = 7; - ids[2] = 9; - ids[3] = 5; - ids[4] = 6; - ids[5] = 10; - cellSet.AddCell(vtkm::CELL_SHAPE_WEDGE, 6, ids); - - cellSet.CompleteAddingCells(nVerts); - - //todo this need to be a reference/shared_ptr style class - dataSet.AddCellSet(cellSet); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet6() -{ - vtkm::cont::DataSet dataSet; - vtkm::cont::DataSetBuilderExplicit dsb; - vtkm::cont::DataSetFieldAdd dsf; - - // Coordinates - const int nVerts = 8; - const int nCells = 8; - using CoordType = vtkm::Vec3f_32; - std::vector coords = { { -0.707f, -0.354f, -0.354f }, { 0.000f, -0.854f, 0.146f }, - { 0.000f, -0.146f, 0.854f }, { -0.707f, 0.354f, 0.354f }, - { 10.0f, 10.0f, 10.0f }, { 5.0f, 5.0f, 5.0f }, - { 0.0f, 0.0f, 2.0f }, { 0.0f, 0.0f, -2.0f } }; - - // Connectivity - std::vector shapes; - std::vector numindices; - std::vector conn; - - shapes.push_back(vtkm::CELL_SHAPE_LINE); - numindices.push_back(2); - conn.push_back(0); - conn.push_back(1); - - shapes.push_back(vtkm::CELL_SHAPE_LINE); - numindices.push_back(2); - conn.push_back(2); - conn.push_back(3); - - shapes.push_back(vtkm::CELL_SHAPE_VERTEX); - numindices.push_back(1); - conn.push_back(4); - - shapes.push_back(vtkm::CELL_SHAPE_VERTEX); - numindices.push_back(1); - conn.push_back(5); - - shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); - numindices.push_back(3); - conn.push_back(2); - conn.push_back(3); - conn.push_back(5); - - shapes.push_back(vtkm::CELL_SHAPE_QUAD); - numindices.push_back(4); - conn.push_back(0); - conn.push_back(1); - conn.push_back(2); - conn.push_back(3); - - shapes.push_back(vtkm::CELL_SHAPE_TETRA); - numindices.push_back(4); - conn.push_back(0); - conn.push_back(2); - conn.push_back(3); - conn.push_back(6); - - shapes.push_back(vtkm::CELL_SHAPE_TETRA); - numindices.push_back(4); - conn.push_back(3); - conn.push_back(2); - conn.push_back(0); - conn.push_back(7); - - dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates", "cells"); - - // Field data - vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, 94.0f, 71.0f, 47.0f, 57.0f }; - vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f }; - - dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); - dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells"); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetZoo() -{ - vtkm::cont::DataSet dataSet; - vtkm::cont::DataSetBuilderExplicit dsb; - vtkm::cont::DataSetFieldAdd dsf; - - // Coordinates - constexpr int nVerts = 30; - constexpr int nCells = 25; - using CoordType = vtkm::Vec3f_32; - - std::vector coords = - - { { 0.00f, 0.00f, 0.00f }, { 1.00f, 0.00f, 0.00f }, { 2.00f, 0.00f, 0.00f }, - { 0.00f, 0.00f, 1.00f }, { 1.00f, 0.00f, 1.00f }, { 2.00f, 0.00f, 1.00f }, - { 0.00f, 1.00f, 0.00f }, { 1.00f, 1.00f, 0.00f }, { 2.00f, 1.00f, 0.00f }, - { 0.00f, 1.00f, 1.00f }, { 1.00f, 1.00f, 1.00f }, { 2.00f, 1.00f, 1.00f }, - { 0.00f, 2.00f, 0.00f }, { 1.00f, 2.00f, 0.00f }, { 2.00f, 2.00f, 0.00f }, - { 0.00f, 2.00f, 1.00f }, { 1.00f, 2.00f, 1.00f }, { 2.00f, 2.00f, 1.00f }, - { 1.00f, 3.00f, 1.00f }, { 2.75f, 0.00f, 1.00f }, { 3.00f, 0.00f, 0.75f }, - { 3.00f, 0.25f, 1.00f }, { 3.00f, 1.00f, 1.00f }, { 3.00f, 1.00f, 0.00f }, - { 2.57f, 2.00f, 1.00f }, { 3.00f, 1.75f, 1.00f }, { 3.00f, 1.75f, 0.75f }, - { 3.00f, 0.00f, 0.00f }, { 2.57f, 0.42f, 0.57f }, { 2.59f, 1.43f, 0.71f } }; - - // Connectivity - std::vector shapes; - std::vector numindices; - std::vector conn; - - shapes.push_back(vtkm::CELL_SHAPE_HEXAHEDRON); - numindices.push_back(8); - conn.push_back(0); - conn.push_back(3); - conn.push_back(4); - conn.push_back(1); - conn.push_back(6); - conn.push_back(9); - conn.push_back(10); - conn.push_back(7); - - shapes.push_back(vtkm::CELL_SHAPE_HEXAHEDRON); - numindices.push_back(8); - conn.push_back(1); - conn.push_back(4); - conn.push_back(5); - conn.push_back(2); - conn.push_back(7); - conn.push_back(10); - conn.push_back(11); - conn.push_back(8); - - shapes.push_back(vtkm::CELL_SHAPE_TETRA); - numindices.push_back(4); - conn.push_back(23); - conn.push_back(26); - conn.push_back(24); - conn.push_back(29); - - shapes.push_back(vtkm::CELL_SHAPE_TETRA); - numindices.push_back(4); - conn.push_back(24); - conn.push_back(26); - conn.push_back(25); - conn.push_back(29); - - shapes.push_back(vtkm::CELL_SHAPE_TETRA); - numindices.push_back(4); - conn.push_back(8); - conn.push_back(17); - conn.push_back(11); - conn.push_back(29); - - shapes.push_back(vtkm::CELL_SHAPE_TETRA); - numindices.push_back(4); - conn.push_back(17); - conn.push_back(24); - conn.push_back(25); - conn.push_back(29); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(24); - conn.push_back(17); - conn.push_back(8); - conn.push_back(23); - conn.push_back(29); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(23); - conn.push_back(8); - conn.push_back(11); - conn.push_back(22); - conn.push_back(29); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(25); - conn.push_back(22); - conn.push_back(11); - conn.push_back(17); - conn.push_back(29); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(26); - conn.push_back(23); - conn.push_back(22); - conn.push_back(25); - conn.push_back(29); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(23); - conn.push_back(8); - conn.push_back(2); - conn.push_back(27); - conn.push_back(28); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(22); - conn.push_back(11); - conn.push_back(8); - conn.push_back(23); - conn.push_back(28); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(11); - conn.push_back(5); - conn.push_back(2); - conn.push_back(8); - conn.push_back(28); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(21); - conn.push_back(19); - conn.push_back(5); - conn.push_back(11); - conn.push_back(28); - - shapes.push_back(vtkm::CELL_SHAPE_TETRA); - numindices.push_back(4); - conn.push_back(11); - conn.push_back(22); - conn.push_back(21); - conn.push_back(28); - - shapes.push_back(vtkm::CELL_SHAPE_TETRA); - numindices.push_back(4); - conn.push_back(5); - conn.push_back(19); - conn.push_back(20); - conn.push_back(28); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(23); - conn.push_back(27); - conn.push_back(20); - conn.push_back(21); - conn.push_back(28); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(20); - conn.push_back(27); - conn.push_back(2); - conn.push_back(5); - conn.push_back(28); - - shapes.push_back(vtkm::CELL_SHAPE_TETRA); - numindices.push_back(4); - conn.push_back(19); - conn.push_back(21); - conn.push_back(20); - conn.push_back(28); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(7); - conn.push_back(6); - conn.push_back(12); - conn.push_back(13); - conn.push_back(16); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(6); - conn.push_back(9); - conn.push_back(15); - conn.push_back(12); - conn.push_back(16); - - shapes.push_back(vtkm::CELL_SHAPE_PYRAMID); - numindices.push_back(5); - conn.push_back(6); - conn.push_back(7); - conn.push_back(10); - conn.push_back(9); - conn.push_back(16); - - shapes.push_back(vtkm::CELL_SHAPE_TETRA); - numindices.push_back(4); - conn.push_back(12); - conn.push_back(15); - conn.push_back(16); - conn.push_back(18); - - shapes.push_back(vtkm::CELL_SHAPE_WEDGE); - numindices.push_back(6); - conn.push_back(8); - conn.push_back(14); - conn.push_back(17); - conn.push_back(7); - conn.push_back(13); - conn.push_back(16); - - shapes.push_back(vtkm::CELL_SHAPE_WEDGE); - numindices.push_back(6); - conn.push_back(11); - conn.push_back(8); - conn.push_back(17); - conn.push_back(10); - conn.push_back(7); - conn.push_back(16); - - dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates", "cells"); - - // Field data - vtkm::Float32 pointvar[nVerts] = - - { 4.0, 5.0f, 9.5f, 5.5f, 6.0f, 9.5f, 5.0f, 5.5f, 5.7f, 6.5f, 6.4f, 6.9f, 6.6f, 6.1f, 7.1f, - 7.2f, 7.3f, 7.4f, 9.1f, 9.2f, 9.3f, 5.4f, 9.5f, 9.6f, 6.7f, 9.8f, 6.0f, 4.3f, 4.9f, 4.1f }; - - vtkm::Float32 cellvar[nCells] = - - { 4.0f, 5.0f, 9.5f, 5.5f, 6.0f, 9.5f, 5.0f, 5.5f, 5.7f, 6.5f, 6.4f, 6.9f, 6.6f, - 6.1f, 7.1f, 7.2f, 7.3f, 7.4f, 9.1f, 9.2f, 9.3f, 5.4f, 9.5f, 9.6f, 6.7f }; - - dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); - dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells"); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet7() -{ - vtkm::cont::DataSet dataSet; - vtkm::cont::DataSetBuilderExplicit dsb; - vtkm::cont::DataSetFieldAdd dsf; - - // Coordinates - const int nVerts = 8; - const int nCells = 8; - - using CoordType = vtkm::Vec3f_32; - std::vector coords = { { -0.707f, -0.354f, -0.354f }, { 0.000f, -0.854f, 0.146f }, - { 0.000f, -0.146f, 0.854f }, { -0.707f, 0.354f, 0.354f }, - { 10.0f, 10.0f, 10.0f }, { 5.0f, 5.0f, 5.0f }, - { 0.0f, 0.0f, 2.0f }, { 0.0f, 0.0f, -2.0f } }; - - // Connectivity - std::vector shapes; - std::vector numindices; - std::vector conn; - - - shapes.push_back(vtkm::CELL_SHAPE_VERTEX); - numindices.push_back(1); - conn.push_back(0); - - shapes.push_back(vtkm::CELL_SHAPE_VERTEX); - numindices.push_back(1); - conn.push_back(1); - - shapes.push_back(vtkm::CELL_SHAPE_VERTEX); - numindices.push_back(1); - conn.push_back(2); - - shapes.push_back(vtkm::CELL_SHAPE_VERTEX); - numindices.push_back(1); - conn.push_back(3); - - shapes.push_back(vtkm::CELL_SHAPE_VERTEX); - numindices.push_back(1); - conn.push_back(4); - - shapes.push_back(vtkm::CELL_SHAPE_VERTEX); - numindices.push_back(1); - conn.push_back(5); - - shapes.push_back(vtkm::CELL_SHAPE_VERTEX); - numindices.push_back(1); - conn.push_back(6); - - shapes.push_back(vtkm::CELL_SHAPE_VERTEX); - numindices.push_back(1); - conn.push_back(7); - - - dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates", "cells"); - - // Field data - vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, 10.f, 20.f, 33.f, 52.f }; - vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f }; - - dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); - dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells"); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet8() -{ - vtkm::cont::DataSet dataSet; - vtkm::cont::DataSetBuilderExplicit dsb; - vtkm::cont::DataSetFieldAdd dsf; - - // Coordinates - const int nVerts = 8; - const int nCells = 10; - using CoordType = vtkm::Vec3f_32; - std::vector coords = { { -0.707f, -0.354f, -0.354f }, { 0.000f, -0.854f, 0.146f }, - { 0.000f, -0.146f, 0.854f }, { -0.707f, 0.354f, 0.354f }, - { 10.0f, 10.0f, 10.0f }, { 5.0f, 5.0f, 5.0f }, - { 0.0f, 0.0f, 2.0f }, { 0.0f, 0.0f, -2.0f } }; - - // Connectivity - std::vector shapes; - std::vector numindices; - std::vector conn; - - //I need two triangles because the leaf needs four nodes otherwise segfault? - shapes.push_back(vtkm::CELL_SHAPE_LINE); - numindices.push_back(2); - conn.push_back(0); - conn.push_back(1); - - shapes.push_back(vtkm::CELL_SHAPE_LINE); - numindices.push_back(2); - conn.push_back(1); - conn.push_back(2); - - shapes.push_back(vtkm::CELL_SHAPE_LINE); - numindices.push_back(2); - conn.push_back(2); - conn.push_back(3); - - shapes.push_back(vtkm::CELL_SHAPE_LINE); - numindices.push_back(2); - conn.push_back(3); - conn.push_back(4); - - shapes.push_back(vtkm::CELL_SHAPE_LINE); - numindices.push_back(2); - conn.push_back(4); - conn.push_back(5); - - shapes.push_back(vtkm::CELL_SHAPE_LINE); - numindices.push_back(2); - conn.push_back(5); - conn.push_back(6); - - shapes.push_back(vtkm::CELL_SHAPE_LINE); - numindices.push_back(2); - conn.push_back(6); - conn.push_back(7); - - shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); - numindices.push_back(3); - conn.push_back(2); - conn.push_back(5); - conn.push_back(4); - - shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); - numindices.push_back(3); - conn.push_back(4); - conn.push_back(5); - conn.push_back(6); - - dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates", "cells"); - - // Field data - vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, 94.0f, 71.0f, 47.0f, 57.0f }; - vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f }; - - dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); - dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells"); - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetPolygonal() -{ - vtkm::cont::DataSet dataSet; - vtkm::cont::DataSetBuilderExplicit dsb; - vtkm::cont::DataSetFieldAdd dsf; - - // Coordinates - const int nVerts = 8; - const int nCells = 8; - using CoordType = vtkm::Vec3f_32; - std::vector coords = { { -0.707f, -0.354f, -0.354f }, { 0.000f, -0.854f, 0.146f }, - { 0.000f, -0.146f, 0.854f }, { -0.707f, 0.354f, 0.354f }, - { 0.000f, 0.146f, -0.854f }, { 0.000f, 0.854f, -0.146f }, - { 0.707f, 0.354f, 0.354f }, { 0.707f, -0.354f, -0.354f } }; - - // Connectivity - std::vector shapes; - std::vector numindices; - std::vector conn; - - shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); - numindices.push_back(3); - conn.push_back(0); - conn.push_back(1); - conn.push_back(3); - - shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); - numindices.push_back(3); - conn.push_back(1); - conn.push_back(2); - conn.push_back(3); - - shapes.push_back(vtkm::CELL_SHAPE_QUAD); - numindices.push_back(4); - conn.push_back(4); - conn.push_back(5); - conn.push_back(6); - conn.push_back(7); - - shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); - numindices.push_back(3); - conn.push_back(0); - conn.push_back(4); - conn.push_back(1); - - shapes.push_back(vtkm::CELL_SHAPE_TRIANGLE); - numindices.push_back(3); - conn.push_back(4); - conn.push_back(7); - conn.push_back(1); - - shapes.push_back(vtkm::CELL_SHAPE_POLYGON); - numindices.push_back(4); - conn.push_back(3); - conn.push_back(2); - conn.push_back(6); - conn.push_back(5); - - shapes.push_back(vtkm::CELL_SHAPE_QUAD); - numindices.push_back(4); - conn.push_back(0); - conn.push_back(3); - conn.push_back(5); - conn.push_back(4); - - shapes.push_back(vtkm::CELL_SHAPE_POLYGON); - numindices.push_back(4); - conn.push_back(1); - conn.push_back(7); - conn.push_back(6); - conn.push_back(2); - - dataSet = dsb.Create(coords, shapes, numindices, conn, "coordinates", "cells"); - - // Field data - vtkm::Float32 pointvar[nVerts] = { 100.0f, 78.0f, 49.0f, 17.0f, 94.0f, 71.0f, 47.0f, 33.0f }; - vtkm::Float32 cellvar[nCells] = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f }; - - dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts); - dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells"); - - return dataSet; -} - -inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetCowNose() -{ - // prepare data array - const int nVerts = 17; - using CoordType = vtkm::Vec3f_64; - CoordType coordinates[nVerts] = { - CoordType(0.0480879, 0.151874, 0.107334), CoordType(0.0293568, 0.245532, 0.125337), - CoordType(0.0224398, 0.246495, 0.1351), CoordType(0.0180085, 0.20436, 0.145316), - CoordType(0.0307091, 0.152142, 0.0539249), CoordType(0.0270341, 0.242992, 0.107567), - CoordType(0.000684071, 0.00272505, 0.175648), CoordType(0.00946217, 0.077227, 0.187097), - CoordType(-0.000168991, 0.0692243, 0.200755), CoordType(-0.000129414, 0.00247137, 0.176561), - CoordType(0.0174172, 0.137124, 0.124553), CoordType(0.00325994, 0.0797155, 0.184912), - CoordType(0.00191765, 0.00589327, 0.16608), CoordType(0.0174716, 0.0501928, 0.0930275), - CoordType(0.0242103, 0.250062, 0.126256), CoordType(0.0108188, 0.152774, 0.167914), - CoordType(5.41687e-05, 0.00137834, 0.175119) - }; - const int connectivitySize = 57; - vtkm::Id pointId[connectivitySize] = { 0, 1, 3, 2, 3, 1, 4, 5, 0, 1, 0, 5, 7, 8, 6, - 9, 6, 8, 0, 10, 7, 11, 7, 10, 0, 6, 13, 12, 13, 6, - 1, 5, 14, 1, 14, 2, 0, 3, 15, 0, 13, 4, 6, 16, 12, - 6, 9, 16, 7, 11, 8, 0, 15, 10, 7, 6, 0 }; - - // create DataSet - vtkm::cont::DataSet dataSet; - dataSet.AddCoordinateSystem( - vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On)); - - vtkm::cont::ArrayHandle connectivity; - connectivity.Allocate(connectivitySize); - - for (vtkm::Id i = 0; i < connectivitySize; ++i) - { - connectivity.GetPortalControl().Set(i, pointId[i]); - } - vtkm::cont::CellSetSingleType<> cellSet("cells"); - cellSet.Fill(nVerts, vtkm::CELL_SHAPE_TRIANGLE, 3, connectivity); - dataSet.AddCellSet(cellSet); - - std::vector pointvar(nVerts); - std::iota(pointvar.begin(), pointvar.end(), 15.f); - std::vector cellvar(connectivitySize / 3); - std::iota(cellvar.begin(), cellvar.end(), 132.f); - - vtkm::cont::ArrayHandle pointvec; - pointvec.Allocate(nVerts); - SetPortal(pointvec.GetPortalControl()); - - vtkm::cont::ArrayHandle cellvec; - cellvec.Allocate(connectivitySize / 3); - SetPortal(cellvec.GetPortalControl()); - - vtkm::cont::DataSetFieldAdd dsf; - dsf.AddPointField(dataSet, "pointvar", pointvar); - dsf.AddCellField(dataSet, "cellvar", cellvar, "cells"); - dsf.AddPointField(dataSet, "point_vectors", pointvec); - dsf.AddCellField(dataSet, "cell_vectors", cellvec, "cells"); - - return dataSet; -} } } } // namespace vtkm::cont::testing diff --git a/vtkm/cont/testing/UnitTestDataSetPermutation.cxx b/vtkm/cont/testing/UnitTestDataSetPermutation.cxx index 1e46b8f87e43439a18c971e07776d70b7ce83e78..a9614d3f258e1a0f0651ae1839c1ec95058d62d8 100644 --- a/vtkm/cont/testing/UnitTestDataSetPermutation.cxx +++ b/vtkm/cont/testing/UnitTestDataSetPermutation.cxx @@ -11,6 +11,7 @@ #include #include #include +#include #include #include diff --git a/vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx b/vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx index 5024de3ce133468993464b6d498b8bf52e84a7cf..c3ab97bcdaa753721fd8b259dacdf8f6d2d03c4f 100644 --- a/vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx +++ b/vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx @@ -10,6 +10,7 @@ #include +#include #include #include diff --git a/vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx b/vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx index 67716ca80f08417f91901b88e25f558f8eb6868e..823bbb5174653370e4c50a3a0008850ea6c3165d 100644 --- a/vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx +++ b/vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx @@ -10,6 +10,7 @@ #include +#include #include #include diff --git a/vtkm/filter/testing/UnitTestMultiBlockFilters.cxx b/vtkm/filter/testing/UnitTestMultiBlockFilters.cxx index 222263c15d8b6ed5100de2980e6e96d7d0fc0d1b..8290ea123a62e30ae7c99f82a116c6eb91e653bc 100644 --- a/vtkm/filter/testing/UnitTestMultiBlockFilters.cxx +++ b/vtkm/filter/testing/UnitTestMultiBlockFilters.cxx @@ -19,6 +19,7 @@ #include #include +#include #include #include #include diff --git a/vtkm/filter/testing/UnitTestSplitSharpEdgesFilter.cxx b/vtkm/filter/testing/UnitTestSplitSharpEdgesFilter.cxx index be6d1e8b86d9ef5a85222c92767c94f103861f2b..2a8b70714ec83f699f564cff48660299031635a7 100644 --- a/vtkm/filter/testing/UnitTestSplitSharpEdgesFilter.cxx +++ b/vtkm/filter/testing/UnitTestSplitSharpEdgesFilter.cxx @@ -12,6 +12,7 @@ #include #include +#include #include #include diff --git a/vtkm/rendering/testing/UnitTestMapperWireframer.cxx b/vtkm/rendering/testing/UnitTestMapperWireframer.cxx index b05b382e93ee9e8cfa928d51a952044074c3092f..41ccf09406cb3a9f5e93667be1e0f7ac4c06be00 100644 --- a/vtkm/rendering/testing/UnitTestMapperWireframer.cxx +++ b/vtkm/rendering/testing/UnitTestMapperWireframer.cxx @@ -9,6 +9,7 @@ //============================================================================ #include +#include #include #include #include diff --git a/vtkm/worklet/testing/UnitTestImageConnectivity.cxx b/vtkm/worklet/testing/UnitTestImageConnectivity.cxx index b05bc93b8807c2b10f4346a08c353af990d30e3c..e75dc154e874f6b70a8676343ae0349972c35909 100644 --- a/vtkm/worklet/testing/UnitTestImageConnectivity.cxx +++ b/vtkm/worklet/testing/UnitTestImageConnectivity.cxx @@ -7,6 +7,7 @@ // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notice for more information. //============================================================================ +#include #include #include #include diff --git a/vtkm/worklet/testing/UnitTestSplitSharpEdges.cxx b/vtkm/worklet/testing/UnitTestSplitSharpEdges.cxx index 0a671051cb6377ccb254a48f309f7ea664e16bc0..29a89e14bcc5d4c223e2c5a29472a61c98532ba5 100644 --- a/vtkm/worklet/testing/UnitTestSplitSharpEdges.cxx +++ b/vtkm/worklet/testing/UnitTestSplitSharpEdges.cxx @@ -10,6 +10,7 @@ #include #include +#include #include #include #include