Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 10:35:42 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Merge branch 'regular-to-uniform' into 'master'

Browse Source 
Change Regular to Uniform

There was an inconsistency in naming classes where axes-aligned grids
with even spacing were sometimes called "uniform" and sometimes called
"regular". Maintain consistency by always calling them uniform.

See merge request !322
This commit is contained in:
Kenneth Moreland 2016-01-20 11:04:44 -05:00
commit dec61fe51a
15 changed files with 106 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vtkm/cont/CMakeLists.txt
View File

@ -47,7 +47,7 @@ set(headers
DataSet.h
DataSetBuilderExplicit.h
DataSetBuilderRectilinear.h
DataSetBuilderRegular.h
DataSetBuilderUniform.h
DataSetFieldAdd.h
DeviceAdapter.h
DeviceAdapterAlgorithm.h

18
vtkm/cont/DataSetBuilderRegular.h → vtkm/cont/DataSetBuilderUniform.h
View File

@ -17,8 +17,8 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_DataSetBuilderRegular_h
#define vtk_m_cont_DataSetBuilderRegular_h
#ifndef vtk_m_cont_DataSetBuilderUniform_h
#define vtk_m_cont_DataSetBuilderUniform_h
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/CoordinateSystem.h>
@ -27,13 +27,13 @@
namespace vtkm {
namespace cont {
class DataSetBuilderRegular
class DataSetBuilderUniform
{
public:
VTKM_CONT_EXPORT
DataSetBuilderRegular() {}
DataSetBuilderUniform() {}
//2D regular grids.
//2D uniform grids.
VTKM_CONT_EXPORT
vtkm::cont::DataSet
Create(const vtkm::Id2 &dimensions,
@ -47,7 +47,7 @@ public:
coordNm, cellNm);
}
//3D regular grids.
//3D uniform grids.
VTKM_CONT_EXPORT
vtkm::cont::DataSet
Create(const vtkm::Id3 &dimensions,
@ -79,10 +79,10 @@ private:
coords(vtkm::Id3(nx, ny, nz),
vtkm::Vec<T,3>(originX, originY,originZ),
vtkm::Vec<T,3>(spacingX, spacingY,spacingZ));
vtkm::cont::CoordinateSystem cs(coordNm, 1, coords);
dataSet.AddCoordinateSystem(cs);
if (dim == 2)
{
vtkm::cont::CellSetStructured<2> cellSet(cellNm);
@ -105,4 +105,4 @@ private:
} // namespace vtkm
#endif //vtk_m_cont_DataSetBuilderRegular_h
#endif //vtk_m_cont_DataSetBuilderUniform_h

4
vtkm/cont/testing/CMakeLists.txt
View File

@ -48,12 +48,12 @@ set(unit_tests
UnitTestComputeBoundsSerial.cxx
UnitTestDataSetBuilderExplicit.cxx
UnitTestDataSetBuilderRectilinear.cxx
UnitTestDataSetBuilderRegular.cxx
UnitTestDataSetRegular.cxx
UnitTestDataSetBuilderUniform.cxx
UnitTestDataSetRectilinear.cxx
UnitTestDataSetExplicit.cxx
UnitTestDataSetSingleType.cxx
UnitTestDataSetPermutation.cxx
UnitTestDataSetUniform.cxx
UnitTestDeviceAdapterAlgorithmDependency.cxx
UnitTestDeviceAdapterAlgorithmGeneral.cxx
UnitTestDeviceAdapterSerial.cxx

30
vtkm/cont/testing/MakeTestDataSet.h
View File

@ -23,9 +23,9 @@
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetBuilderRegular.h>
#include <vtkm/cont/DataSetBuilderRectilinear.h>
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetBuilderRectilinear.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
namespace vtkm {
@ -35,11 +35,11 @@ namespace testing {
class MakeTestDataSet
{
public:
// 2D regular datasets.
vtkm::cont::DataSet Make2DRegularDataSet0();
// 2D uniform datasets.
vtkm::cont::DataSet Make2DUniformDataSet0();
// 3D regular datasets.
vtkm::cont::DataSet Make3DRegularDataSet0();
// 3D uniform datasets.
vtkm::cont::DataSet Make3DUniformDataSet0();
//2D rectilinear
vtkm::cont::DataSet Make2DRectilinearDataSet0();
@ -54,12 +54,12 @@ public:
};
//Make a simple 2D, 2 cell regular dataset.
//Make a simple 2D, 2 cell uniform dataset.
inline vtkm::cont::DataSet
MakeTestDataSet::Make2DRegularDataSet0()
MakeTestDataSet::Make2DUniformDataSet0()
{
vtkm::cont::DataSetBuilderRegular dsb;
vtkm::cont::DataSetBuilderUniform dsb;
vtkm::Id2 dimensions(3,2);
vtkm::cont::DataSet dataSet = dsb.Create(dimensions);
@ -76,9 +76,9 @@ MakeTestDataSet::Make2DRegularDataSet0()
}
inline vtkm::cont::DataSet
MakeTestDataSet::Make3DRegularDataSet0()
MakeTestDataSet::Make3DUniformDataSet0()
{
vtkm::cont::DataSetBuilderRegular dsb;
vtkm::cont::DataSetBuilderUniform dsb;
vtkm::Id3 dimensions(3,2,3);
vtkm::cont::DataSet dataSet = dsb.Create(dimensions);
@ -116,13 +116,13 @@ MakeTestDataSet::Make2DRectilinearDataSet0()
const vtkm::Id nVerts = 6;
vtkm::Float32 var[nVerts];
for (int i = 0; i < nVerts; i++)
var[i] = (vtkm::Float32)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;
cellvar[i] = (vtkm::Float32)i;
dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells");
return dataSet;
@ -149,13 +149,13 @@ MakeTestDataSet::Make3DRectilinearDataSet0()
const vtkm::Id nVerts = 18;
vtkm::Float32 var[nVerts];
for (int i = 0; i < nVerts; i++)
var[i] = (vtkm::Float32)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;
cellvar[i] = (vtkm::Float32)i;
dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells");
return dataSet;

24
vtkm/cont/testing/UnitTestDataSetBuilderRegular.cxx → vtkm/cont/testing/UnitTestDataSetBuilderUniform.cxx
View File

@ -20,7 +20,7 @@
//
//=============================================================================
#include <vtkm/cont/DataSetBuilderRegular.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
@ -38,7 +38,7 @@ VTKM_THIRDPARTY_POST_INCLUDE
#include <vector>
namespace DataSetBuilderRegularNamespace {
namespace DataSetBuilderUniformNamespace {
boost::mt19937 g_RandomGenerator;
@ -125,13 +125,13 @@ void FillMethod(vtkm::IdComponent method,
template <typename T>
void
RegularTests()
UniformTests()
{
const vtkm::Id NUM_TRIALS = 10;
const vtkm::Id MAX_DIM_SIZE = 20;
const vtkm::Id NUM_FILL_METHODS = 5;
vtkm::cont::DataSetBuilderRegular dataSetBuilder;
vtkm::cont::DataSetBuilderUniform dataSetBuilder;
vtkm::cont::DataSet dataSet;
boost::random::uniform_int_distribution<vtkm::Id>
@ -195,7 +195,7 @@ RegularTests()
}
#if 0
vtkm::cont::DataSetBuilderRegular dsb;
vtkm::cont::DataSetBuilderUniform dsb;
vtkm::cont::DataSet ds;
vtkm::Id nx = 12, ny = 12, nz = 12;
@ -239,22 +239,22 @@ RegularTests()
}
void
TestDataSetBuilderRegular()
TestDataSetBuilderUniform()
{
vtkm::UInt32 seed = static_cast<vtkm::UInt32>(time(NULL));
std::cout << "Seed: " << seed << std::endl;
g_RandomGenerator.seed(seed);
std::cout << "======== Float32 ==========================" << std::endl;
RegularTests<vtkm::Float32>();
UniformTests<vtkm::Float32>();
std::cout << "======== Float64 ==========================" << std::endl;
RegularTests<vtkm::Float64>();
UniformTests<vtkm::Float64>();
}
} // namespace DataSetBuilderRegularNamespace
} // namespace DataSetBuilderUniformNamespace
int UnitTestDataSetBuilderRegular(int, char *[])
int UnitTestDataSetBuilderUniform(int, char *[])
{
using namespace DataSetBuilderRegularNamespace;
return vtkm::cont::testing::Testing::Run(TestDataSetBuilderRegular);
using namespace DataSetBuilderUniformNamespace;
return vtkm::cont::testing::Testing::Run(TestDataSetBuilderUniform);
}

8
vtkm/cont/testing/UnitTestDataSetPermutation.cxx
View File

@ -144,7 +144,7 @@ void TestDataSet_Structured2D()
{
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
std::vector<vtkm::Id> validIds;
validIds.push_back(1); //iterate the 2nd cell 4 times
@ -158,7 +158,7 @@ void TestDataSet_Structured2D()
vtkm::cont::CellSetStructured<2> cellSet;
dataSet.GetCellSet(0).CopyTo(cellSet);
//verify that we can create a subset of a 2d RegularDataSet
//verify that we can create a subset of a 2d UniformDataSet
vtkm::cont::CellSetPermutation<vtkm::cont::ArrayHandle<vtkm::Id>,
vtkm::cont::CellSetStructured<2> > subset;
subset.Fill(validCellIds,cellSet);
@ -192,7 +192,7 @@ void TestDataSet_Structured3D()
{
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
std::vector<vtkm::Id> validIds;
validIds.push_back(1); //iterate the 2nd cell 4 times
@ -205,7 +205,7 @@ void TestDataSet_Structured3D()
vtkm::cont::CellSetStructured<3> cellSet;
dataSet.GetCellSet(0).CopyTo(cellSet);
//verify that we can create a subset of a 2d RegularDataSet
//verify that we can create a subset of a 2d UniformDataSet
vtkm::cont::CellSetPermutation<vtkm::cont::ArrayHandle<vtkm::Id>,
vtkm::cont::CellSetStructured<3> > subset;
subset.Fill(validCellIds,cellSet);

30
vtkm/cont/testing/UnitTestDataSetRegular.cxx → vtkm/cont/testing/UnitTestDataSetUniform.cxx
View File

@ -29,25 +29,25 @@
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/cont/testing/MakeTestDataSet.h>
static void TwoDimRegularTest();
static void ThreeDimRegularTest();
static void TwoDimUniformTest();
static void ThreeDimUniformTest();
void TestDataSet_Regular()
void TestDataSet_Uniform()
{
std::cout << std::endl;
std::cout << "--TestDataSet_Regular--" << std::endl << std::endl;
std::cout << "--TestDataSet_Uniform--" << std::endl << std::endl;
TwoDimRegularTest();
ThreeDimRegularTest();
TwoDimUniformTest();
ThreeDimUniformTest();
}
static void
TwoDimRegularTest()
TwoDimUniformTest()
{
std::cout<<"2D Regular data set"<<std::endl;
std::cout<<"2D Uniform data set"<<std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
dataSet.PrintSummary(std::cout);
@ -152,12 +152,12 @@ TwoDimRegularTest()
}
static void
ThreeDimRegularTest()
ThreeDimUniformTest()
{
std::cout<<"3D Regular data set"<<std::endl;
std::cout<<"3D Uniform data set"<<std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
dataSet.PrintSummary(std::cout);
@ -207,7 +207,7 @@ ThreeDimRegularTest()
"Incorrect element type.");
}
//Test regular connectivity.
//Test uniform connectivity.
vtkm::exec::ConnectivityStructured<
vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell,
@ -251,7 +251,7 @@ ThreeDimRegularTest()
}
}
int UnitTestDataSetRegular(int, char *[])
int UnitTestDataSetUniform(int, char *[])
{
return vtkm::cont::testing::Testing::Run(TestDataSet_Regular);
return vtkm::cont::testing::Testing::Run(TestDataSet_Uniform);
}

6
vtkm/internal/ConnectivityStructuredInternals.h
View File

@ -145,7 +145,7 @@ public:
VTKM_CONT_EXPORT
void PrintSummary(std::ostream &out) const
{
out<<" RegularConnectivity<1> ";
out<<" UniformConnectivity<1> ";
out<<"this->PointDimensions["<<this->PointDimensions<<"] ";
out<<"\n";
}
@ -315,7 +315,7 @@ public:
VTKM_CONT_EXPORT
void PrintSummary(std::ostream &out) const
{
out<<" RegularConnectivity<2> ";
out<<" UniformConnectivity<2> ";
out<<"pointDim["<<this->PointDimensions[0]<<" "<<this->PointDimensions[1]<<"] ";
out<<std::endl;
}
@ -498,7 +498,7 @@ public:
VTKM_CONT_EXPORT
void PrintSummary(std::ostream &out) const
{
out<<" RegularConnectivity<3> ";
out<<" UniformConnectivity<3> ";
out<<"pointDim["<<this->PointDimensions[0]<<" "<<this->PointDimensions[1]<<" "<<this->PointDimensions[2]<<"] ";
out<<std::endl;
}

10
vtkm/io/writer/testing/UnitTestVTKDataSetWriter.cxx
View File

@ -59,31 +59,31 @@ void TestVTKExplicitWrite()
out4.close();
}
void TestVTKRegularWrite()
void TestVTKUniformWrite()
{
vtkm::cont::testing::MakeTestDataSet tds;
std::ofstream out1("fileB1.vtk");
vtkm::io::writer::VTKDataSetWriter::Write(out1,
tds.Make2DRegularDataSet0());
tds.Make2DUniformDataSet0());
out1.close();
std::ofstream out2("fileB2.vtk");
vtkm::io::writer::VTKDataSetWriter::Write(out2,
tds.Make3DRegularDataSet0());
tds.Make3DUniformDataSet0());
out2.close();
// force it to output an explicit grid as points
std::ofstream out3("fileB3.vtk");
vtkm::io::writer::VTKDataSetWriter::Write(out3,
tds.Make3DRegularDataSet0(), -1);
tds.Make3DUniformDataSet0(), -1);
out3.close();
}
void TestVTKWrite()
{
TestVTKExplicitWrite();
TestVTKRegularWrite();
TestVTKUniformWrite();
}
} //Anonymous namespace

2
vtkm/worklet/testing/CMakeLists.txt
View File

@ -36,7 +36,7 @@ set(unit_tests
UnitTestWorkletMapFieldExecArg.cxx
UnitTestWorkletMapFieldWholeArray.cxx
UnitTestWorkletMapTopologyExplicit.cxx
UnitTestWorkletMapTopologyRegular.cxx
UnitTestWorkletMapTopologyUniform.cxx
UnitTestVertexClustering.cxx
)

16
vtkm/worklet/testing/UnitTestCellAverage.cxx
View File

@ -30,12 +30,12 @@ VTKM_THIRDPARTY_POST_INCLUDE
namespace {
void TestCellAverageRegular3D()
void TestCellAverageUniform3D()
{
std::cout << "Testing CellAverage Worklet on 3D strucutred data" << std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
vtkm::cont::Field result("avgvals",
1,
@ -55,16 +55,16 @@ void TestCellAverageRegular3D()
for (int i = 0; i < 4; ++i)
{
VTKM_TEST_ASSERT(test_equal(resultArrayHandle.GetPortalConstControl().Get(i),
expected[i]), "Wrong result for CellAverage worklet on 3D regular data");
expected[i]), "Wrong result for CellAverage worklet on 3D uniform data");
}
}
void TestCellAverageRegular2D()
void TestCellAverageUniform2D()
{
std::cout << "Testing CellAverage Worklet on 2D strucutred data" << std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
vtkm::cont::Field result("avgvals",
1,
@ -84,7 +84,7 @@ void TestCellAverageRegular2D()
for (int i = 0; i < 2; ++i)
{
VTKM_TEST_ASSERT(test_equal(resultArrayHandle.GetPortalConstControl().Get(i),
expected[i]), "Wrong result for CellAverage worklet on 2D regular data");
expected[i]), "Wrong result for CellAverage worklet on 2D uniform data");
}
}
@ -120,8 +120,8 @@ void TestCellAverageExplicit()
void TestCellAverage()
{
TestCellAverageRegular2D();
TestCellAverageRegular3D();
TestCellAverageUniform2D();
TestCellAverageUniform3D();
TestCellAverageExplicit();
}

4
vtkm/worklet/testing/UnitTestClipping.cxx
View File

@ -26,7 +26,7 @@
#include <vtkm/cont/CoordinateSystem.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetBuilderRegular.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/Field.h>
@ -104,7 +104,7 @@ vtkm::cont::DataSet MakeTestDatasetStructured()
scalars[4] = 0.0f;
vtkm::cont::DataSet ds;
vtkm::cont::DataSetBuilderRegular builder;
vtkm::cont::DataSetBuilderUniform builder;
ds = builder.Create(dim);
vtkm::cont::DataSetFieldAdd fieldAdder;

14
vtkm/worklet/testing/UnitTestFieldStatistics.cxx
View File

@ -28,7 +28,7 @@
//
// Make a simple 2D, 10 cell dataset
//
vtkm::cont::DataSet Make2DRegularStatDataSet0()
vtkm::cont::DataSet Make2DUniformStatDataSet0()
{
vtkm::cont::DataSet dataSet;
@ -53,7 +53,7 @@ vtkm::cont::DataSet Make2DRegularStatDataSet0()
vtkm::cont::CellSetStructured<dimension> cellSet("cells");
//Set regular structure
//Set uniform structure
cellSet.SetPointDimensions(vtkm::make_Vec(xVerts, yVerts));
dataSet.AddCellSet(cellSet);
@ -63,7 +63,7 @@ vtkm::cont::DataSet Make2DRegularStatDataSet0()
//
// Make a simple 2D, 1000 point dataset populated with stat distributions
//
vtkm::cont::DataSet Make2DRegularStatDataSet1()
vtkm::cont::DataSet Make2DUniformStatDataSet1()
{
vtkm::cont::DataSet dataSet;
@ -319,7 +319,7 @@ vtkm::cont::DataSet Make2DRegularStatDataSet1()
vtkm::cont::CellSetStructured<dimension> cellSet("cells");
//Set regular structure
//Set uniform structure
cellSet.SetPointDimensions(vtkm::make_Vec(xVerts, yVerts));
dataSet.AddCellSet(cellSet);
@ -350,7 +350,7 @@ void PrintStatInfo(vtkm::worklet::FieldStatistics<vtkm::Float32, VTKM_DEFAULT_DE
}
//
// Test simple dataset 2D Regular with 10 cells
// Test simple dataset 2D Uniform with 10 cells
//
void TestFieldSimple()
{
@ -358,7 +358,7 @@ void TestFieldSimple()
vtkm::worklet::FieldStatistics<vtkm::Float32, VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::StatInfo statinfo;
// Data attached is [1:10]
vtkm::cont::DataSet ds = Make2DRegularStatDataSet0();
vtkm::cont::DataSet ds = Make2DUniformStatDataSet0();
// Cell data
vtkm::cont::ArrayHandle<vtkm::Float32> data;
@ -389,7 +389,7 @@ void TestFieldStandardDistributions()
vtkm::worklet::FieldStatistics<vtkm::Float32, VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::StatInfo statinfo;
// Data attached is the poisson distribution
vtkm::cont::DataSet ds = Make2DRegularStatDataSet1();
vtkm::cont::DataSet ds = Make2DUniformStatDataSet1();
// Point data
vtkm::cont::ArrayHandle<vtkm::Float32> p_poisson;

16
vtkm/worklet/testing/UnitTestThreshold.cxx
View File

@ -55,9 +55,9 @@ template <typename DeviceAdapter>
class TestingThreshold
{
public:
void TestRegular2D() const
void TestUniform2D() const
{
std::cout << "Testing threshold on 2D regular dataset" << std::endl;
std::cout << "Testing threshold on 2D uniform dataset" << std::endl;
typedef vtkm::cont::CellSetStructured<2> CellSetType;
typedef vtkm::cont::CellSetPermutation<vtkm::cont::ArrayHandle<vtkm::Id>,
@ -66,7 +66,7 @@ public:
vtkm::cont::ArrayHandle<vtkm::Id>,
vtkm::cont::ArrayHandle<vtkm::Float32> > OutCellFieldArrayHandleType;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make2DRegularDataSet0();
vtkm::cont::DataSet dataset = MakeTestDataSet().Make2DUniformDataSet0();
CellSetType cellset;
dataset.GetCellSet(0).CopyTo(cellset);
@ -89,9 +89,9 @@ public:
"Wrong cell field data");
}
void TestRegular3D() const
void TestUniform3D() const
{
std::cout << "Testing threshold on 3D regular dataset" << std::endl;
std::cout << "Testing threshold on 3D uniform dataset" << std::endl;
typedef vtkm::cont::CellSetStructured<3> CellSetType;
typedef vtkm::cont::CellSetPermutation<vtkm::cont::ArrayHandle<vtkm::Id>,
@ -100,7 +100,7 @@ public:
vtkm::cont::ArrayHandle<vtkm::Id>,
vtkm::cont::ArrayHandle<vtkm::Float32> > OutCellFieldArrayHandleType;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DRegularDataSet0();
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet0();
CellSetType cellset;
dataset.GetCellSet(0).CopyTo(cellset);
@ -160,8 +160,8 @@ public:
void operator()() const
{
this->TestRegular2D();
this->TestRegular3D();
this->TestUniform2D();
this->TestUniform3D();
this->TestExplicit3D();
}
};

28
vtkm/worklet/testing/UnitTestWorkletMapTopologyRegular.cxx → vtkm/worklet/testing/UnitTestWorkletMapTopologyUniform.cxx
View File

@ -28,7 +28,7 @@
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/cont/testing/MakeTestDataSet.h>
namespace test_regular {
namespace test_uniform {
class MaxPointOrCellValue :
public vtkm::worklet::WorkletMapPointToCell
@ -162,11 +162,11 @@ static void TestAvgPointToCell();
static void TestAvgCellToPoint();
static void TestStructuredUniformPointCoords();
void TestWorkletMapTopologyRegular()
void TestWorkletMapTopologyUniform()
{
typedef vtkm::cont::DeviceAdapterTraits<
VTKM_DEFAULT_DEVICE_ADAPTER_TAG> DeviceAdapterTraits;
std::cout << "Testing Topology Worklet ( Regular ) on device adapter: "
std::cout << "Testing Topology Worklet ( Uniform ) on device adapter: "
<< DeviceAdapterTraits::GetName() << std::endl;
TestMaxPointOrCell();
@ -180,7 +180,7 @@ TestMaxPointOrCell()
{
std::cout<<"Testing MaxPointOfCell worklet"<<std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
//Run a worklet to populate a cell centered field.
//Here, we're filling it with test values.
@ -197,7 +197,7 @@ TestMaxPointOrCell()
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfFields(), 3),
"Incorrect number of fields");
vtkm::worklet::DispatcherMapTopology< ::test_regular::MaxPointOrCellValue > dispatcher;
vtkm::worklet::DispatcherMapTopology< ::test_uniform::MaxPointOrCellValue > dispatcher;
dispatcher.Invoke(dataSet.GetField("cellvar").GetData(),
dataSet.GetField("pointvar").GetData(),
// We know that the cell set is a structured 2D grid and
@ -223,7 +223,7 @@ TestAvgPointToCell()
{
std::cout<<"Testing AvgPointToCell worklet"<<std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
//Run a worklet to populate a cell centered field.
//Here, we're filling it with test values.
@ -240,7 +240,7 @@ TestAvgPointToCell()
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfFields(), 3),
"Incorrect number of fields");
vtkm::worklet::DispatcherMapTopology< ::test_regular::AveragePointToCellValue > dispatcher;
vtkm::worklet::DispatcherMapTopology< ::test_uniform::AveragePointToCellValue > dispatcher;
dispatcher.Invoke(dataSet.GetField("pointvar").GetData(),
// We know that the cell set is a structured 2D grid and
// The worklet does not work with general types because
@ -266,7 +266,7 @@ TestAvgCellToPoint()
std::cout<<"Testing AvgCellToPoint worklet"<<std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
//Run a worklet to populate a point centered field.
//Here, we're filling it with test values.
@ -283,7 +283,7 @@ TestAvgCellToPoint()
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfFields(), 3),
"Incorrect number of fields");
vtkm::worklet::DispatcherMapTopology< ::test_regular::AverageCellToPointValue > dispatcher;
vtkm::worklet::DispatcherMapTopology< ::test_uniform::AverageCellToPointValue > dispatcher;
dispatcher.Invoke(dataSet.GetField("cellvar").GetData(),
// We know that the cell set is a structured 2D grid and
// The worklet does not work with general types because
@ -312,20 +312,20 @@ TestStructuredUniformPointCoords()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::worklet::DispatcherMapTopology<
::test_regular::CheckStructuredUniformPointCoords> dispatcher;
::test_uniform::CheckStructuredUniformPointCoords> dispatcher;
vtkm::cont::DataSet dataSet3D = testDataSet.Make3DRegularDataSet0();
vtkm::cont::DataSet dataSet3D = testDataSet.Make3DUniformDataSet0();
dispatcher.Invoke(dataSet3D.GetCellSet(),
dataSet3D.GetCoordinateSystem().GetData());
vtkm::cont::DataSet dataSet2D = testDataSet.Make2DRegularDataSet0();
vtkm::cont::DataSet dataSet2D = testDataSet.Make2DUniformDataSet0();
dispatcher.Invoke(dataSet2D.GetCellSet(),
dataSet2D.GetCoordinateSystem().GetData());
}
} // anonymous namespace
int UnitTestWorkletMapTopologyRegular(int, char *[])
int UnitTestWorkletMapTopologyUniform(int, char *[])
{
return vtkm::cont::testing::Testing::Run(TestWorkletMapTopologyRegular);
return vtkm::cont::testing::Testing::Run(TestWorkletMapTopologyUniform);
}