mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-09-19 18:45:43 +00:00
198 lines
7.1 KiB
C++
198 lines
7.1 KiB
C++
//============================================================================
|
|
// 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.
|
|
//
|
|
// Copyright 2014 Sandia Corporation.
|
|
// Copyright 2014 UT-Battelle, LLC.
|
|
// Copyright 2014 Los Alamos National Security.
|
|
//
|
|
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
|
|
// the U.S. Government retains certain rights in this software.
|
|
//
|
|
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
|
|
// Laboratory (LANL), the U.S. Government retains certain rights in
|
|
// this software.
|
|
//============================================================================
|
|
|
|
#include <vtkm/Extent.h>
|
|
|
|
#include <vtkm/testing/Testing.h>
|
|
|
|
namespace {
|
|
|
|
const vtkm::Id MIN_VALUES[] = { -5, 8, 40, -8, -3 };
|
|
const vtkm::Id MAX_VALUES[] = { 10, 25, 44, -2, 1 };
|
|
const vtkm::Id POINT_DIMS[] = { 16, 18, 5, 7, 5 };
|
|
const vtkm::Id CELL_DIMS[] = { 15, 17, 4, 6, 4 };
|
|
const vtkm::Id NUM_POINTS[] = { 0, 16, 288, 1440, 10080, 50400 };
|
|
const vtkm::Id NUM_CELLS[] = { 0, 15, 255, 1020, 6120, 24480 };
|
|
|
|
template<vtkm::IdComponent Dimensions>
|
|
void TestDimensions(vtkm::Extent<Dimensions>)
|
|
{
|
|
std::cout << "Testing Dimension sizes for " << Dimensions << " dimensions"
|
|
<< std::endl;
|
|
|
|
vtkm::Extent<Dimensions> extent;
|
|
vtkm::Vec<vtkm::Id,Dimensions> pointDims;
|
|
vtkm::Vec<vtkm::Id,Dimensions> cellDims;
|
|
vtkm::Id numPoints;
|
|
vtkm::Id numCells;
|
|
|
|
for (vtkm::IdComponent dimIndex = 0; dimIndex < Dimensions; dimIndex++)
|
|
{
|
|
extent.Min[dimIndex] = 0; extent.Max[dimIndex] = 10;
|
|
}
|
|
pointDims = vtkm::ExtentPointDimensions(extent);
|
|
cellDims = vtkm::ExtentCellDimensions(extent);
|
|
for (vtkm::IdComponent dimIndex = 0; dimIndex < Dimensions; dimIndex++)
|
|
{
|
|
VTKM_TEST_ASSERT(pointDims[dimIndex] == 11,
|
|
"Got incorrect point dimensions for extent.");
|
|
VTKM_TEST_ASSERT(cellDims[dimIndex] == 10,
|
|
"Got incorrect point dimensions for extent.");
|
|
}
|
|
|
|
for (vtkm::IdComponent dimIndex = 0; dimIndex < Dimensions; dimIndex++)
|
|
{
|
|
extent.Min[dimIndex] = MIN_VALUES[dimIndex];
|
|
extent.Max[dimIndex] = MAX_VALUES[dimIndex];
|
|
}
|
|
pointDims = vtkm::ExtentPointDimensions(extent);
|
|
cellDims = vtkm::ExtentCellDimensions(extent);
|
|
for (vtkm::IdComponent dimIndex = 0; dimIndex < Dimensions; dimIndex++)
|
|
{
|
|
VTKM_TEST_ASSERT(pointDims[dimIndex] == POINT_DIMS[dimIndex],
|
|
"Got incorrect point dimensions for extent.");
|
|
VTKM_TEST_ASSERT(cellDims[dimIndex] == CELL_DIMS[dimIndex],
|
|
"Got incorrect point dimensions for extent.");
|
|
}
|
|
numPoints = vtkm::ExtentNumberOfPoints(extent);
|
|
numCells = vtkm::ExtentNumberOfCells(extent);
|
|
VTKM_TEST_ASSERT(numPoints == NUM_POINTS[Dimensions],
|
|
"Got wrong number of points.");
|
|
VTKM_TEST_ASSERT(numCells == NUM_CELLS[Dimensions],
|
|
"Got wrong number of cells.");
|
|
}
|
|
|
|
template<vtkm::IdComponent Dimensions>
|
|
void TryIndexConversion(const vtkm::Extent<Dimensions> &extent)
|
|
{
|
|
typedef vtkm::Vec<vtkm::Id,Dimensions> IdX;
|
|
vtkm::Id lastFlatIndex;
|
|
IdX correctTopologyIndex;
|
|
|
|
std::cout << " Testing point index conversion" << std::endl;
|
|
correctTopologyIndex = IdX(100000);
|
|
lastFlatIndex = vtkm::ExtentNumberOfPoints(extent);
|
|
for (vtkm::Id correctFlatIndex = 0;
|
|
correctFlatIndex < lastFlatIndex;
|
|
correctFlatIndex++)
|
|
{
|
|
// Increment topology index
|
|
for (vtkm::IdComponent dimIndex = 0; dimIndex < Dimensions; dimIndex++)
|
|
{
|
|
correctTopologyIndex[dimIndex]++;
|
|
if (correctTopologyIndex[dimIndex] <= extent.Max[dimIndex]) { break; }
|
|
correctTopologyIndex[dimIndex] = extent.Min[dimIndex];
|
|
// Iterate to increment the next index.
|
|
}
|
|
|
|
vtkm::Id computedFlatIndex =
|
|
vtkm::ExtentPointTopologyIndexToFlatIndex(correctTopologyIndex, extent);
|
|
VTKM_TEST_ASSERT(computedFlatIndex == correctFlatIndex,
|
|
"Got incorrect flat index.");
|
|
|
|
IdX computedTopologyIndex =
|
|
vtkm::ExtentPointFlatIndexToTopologyIndex(correctFlatIndex, extent);
|
|
VTKM_TEST_ASSERT(computedTopologyIndex == correctTopologyIndex,
|
|
"Got incorrect topology index.");
|
|
}
|
|
// Sanity check to make sure we got to the last topology index.
|
|
VTKM_TEST_ASSERT(correctTopologyIndex == extent.Max,
|
|
"Test code error. Indexing problem.");
|
|
|
|
std::cout << " Testing cell index conversion" << std::endl;
|
|
correctTopologyIndex = IdX(100000);
|
|
lastFlatIndex = vtkm::ExtentNumberOfCells(extent);
|
|
for (vtkm::Id correctFlatIndex = 0;
|
|
correctFlatIndex < lastFlatIndex;
|
|
correctFlatIndex++)
|
|
{
|
|
// Increment topology index
|
|
for (vtkm::IdComponent dimIndex = 0; dimIndex < Dimensions; dimIndex++)
|
|
{
|
|
correctTopologyIndex[dimIndex]++;
|
|
if (correctTopologyIndex[dimIndex] < extent.Max[dimIndex]) { break; }
|
|
correctTopologyIndex[dimIndex] = extent.Min[dimIndex];
|
|
// Iterate to increment the next index.
|
|
}
|
|
|
|
vtkm::Id computedFlatIndex =
|
|
vtkm::ExtentCellTopologyIndexToFlatIndex(correctTopologyIndex, extent);
|
|
VTKM_TEST_ASSERT(computedFlatIndex == correctFlatIndex,
|
|
"Got incorrect flat index.");
|
|
|
|
IdX computedTopologyIndex =
|
|
vtkm::ExtentCellFlatIndexToTopologyIndex(correctFlatIndex, extent);
|
|
VTKM_TEST_ASSERT(computedTopologyIndex == correctTopologyIndex,
|
|
"Got incorrect topology index.");
|
|
|
|
vtkm::Id expectedFirstPointIndex =
|
|
vtkm::ExtentPointTopologyIndexToFlatIndex(correctTopologyIndex, extent);
|
|
vtkm::Id computedFirstPointIndex =
|
|
vtkm::ExtentFirstPointOnCell(correctFlatIndex, extent);
|
|
VTKM_TEST_ASSERT(computedFirstPointIndex == expectedFirstPointIndex,
|
|
"Got wrong first point index.");
|
|
}
|
|
// Sanity check to make sure we got to the last topology index.
|
|
VTKM_TEST_ASSERT(correctTopologyIndex == extent.Max - IdX(1),
|
|
"Test code error. Indexing problem.");
|
|
}
|
|
|
|
template<vtkm::IdComponent Dimensions>
|
|
void TestIndexConversion(vtkm::Extent<Dimensions>)
|
|
{
|
|
std::cout << "Testing index conversion for " << Dimensions << " dimensions."
|
|
<< std::endl;
|
|
|
|
vtkm::Extent<Dimensions> extent;
|
|
|
|
for (vtkm::IdComponent dimIndex = 0; dimIndex < Dimensions; dimIndex++)
|
|
{
|
|
extent.Min[dimIndex] = 0; extent.Max[dimIndex] = 10;
|
|
}
|
|
TryIndexConversion(extent);
|
|
|
|
for (vtkm::IdComponent dimIndex = 0; dimIndex < Dimensions; dimIndex++)
|
|
{
|
|
extent.Min[dimIndex] = MIN_VALUES[dimIndex];
|
|
extent.Max[dimIndex] = MAX_VALUES[dimIndex];
|
|
}
|
|
TryIndexConversion(extent);
|
|
}
|
|
|
|
void ExtentTests()
|
|
{
|
|
TestDimensions(vtkm::Extent<1>());
|
|
TestDimensions(vtkm::Extent2());
|
|
TestDimensions(vtkm::Extent3());
|
|
TestDimensions(vtkm::Extent<5>());
|
|
|
|
TestIndexConversion(vtkm::Extent<1>());
|
|
TestIndexConversion(vtkm::Extent2());
|
|
TestIndexConversion(vtkm::Extent3());
|
|
TestIndexConversion(vtkm::Extent<5>());
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
int UnitTestExtent(int, char *[])
|
|
{
|
|
return vtkm::testing::Testing::Run(ExtentTests);
|
|
}
|