Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Deprecate DataSetFieldAdd.

Browse Source
This commit is contained in:
NAThompson 2020-05-27 15:27:47 -04:00
parent cdc1b7c256
commit fe4f71ab92
48 changed files with 228 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
docs/changelog/deprecate-dataset-field-add.md Normal file
View File

@ -0,0 +1,18 @@
# Deprecate `DataSetFieldAdd`
The class `vtkm::cont::DataSetFieldAdd` is now deprecated.
Its methods, `AddPointField` and `AddCellField` have been moved to member functions
of `vtkm::cont::DataSet`, which simplifies many calls.
For example, the following code
```cpp
vtkm::cont::DataSetFieldAdd fieldAdder;
fieldAdder.AddCellField(dataSet, "cellvar", values);
```
would now be
```cpp
dataSet.AddCellField("cellvar", values);
```

56
vtkm/cont/DataSet.h
View File

@ -132,6 +132,62 @@ public:
}
//@}
VTKM_CONT
void AddPointField(const std::string& fieldName, const vtkm::cont::VariantArrayHandle& field)
{
this->AddField(make_FieldPoint(fieldName, field));
}
template <typename T, typename Storage>
VTKM_CONT void AddPointField(const std::string& fieldName,
const vtkm::cont::ArrayHandle<T, Storage>& field)
{
this->AddField(make_FieldPoint(fieldName, field));
}
template <typename T>
VTKM_CONT void AddPointField(const std::string& fieldName, const std::vector<T>& field)
{
this->AddField(
make_Field(fieldName, vtkm::cont::Field::Association::POINTS, field, vtkm::CopyFlag::On));
}
template <typename T>
VTKM_CONT void AddPointField(const std::string& fieldName, const T* field, const vtkm::Id& n)
{
this->AddField(
make_Field(fieldName, vtkm::cont::Field::Association::POINTS, field, n, vtkm::CopyFlag::On));
}
//Cell centered field
VTKM_CONT
void AddCellField(const std::string& fieldName, const vtkm::cont::VariantArrayHandle& field)
{
this->AddField(make_FieldCell(fieldName, field));
}
template <typename T, typename Storage>
VTKM_CONT void AddCellField(const std::string& fieldName,
const vtkm::cont::ArrayHandle<T, Storage>& field)
{
this->AddField(make_FieldCell(fieldName, field));
}
template <typename T>
VTKM_CONT void AddCellField(const std::string& fieldName, const std::vector<T>& field)
{
this->AddField(
make_Field(fieldName, vtkm::cont::Field::Association::CELL_SET, field, vtkm::CopyFlag::On));
}
template <typename T>
VTKM_CONT void AddCellField(const std::string& fieldName, const T* field, const vtkm::Id& n)
{
this->AddField(make_Field(
fieldName, vtkm::cont::Field::Association::CELL_SET, field, n, vtkm::CopyFlag::On));
}
VTKM_CONT
void AddCoordinateSystem(const vtkm::cont::CoordinateSystem& cs)
{

5
vtkm/cont/DataSetFieldAdd.h
View File

@ -10,6 +10,7 @@
#ifndef vtk_m_cont_DataSetFieldAdd_h
#define vtk_m_cont_DataSetFieldAdd_h
#include <vtkm/Deprecated.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/Field.h>
@ -18,7 +19,9 @@ namespace vtkm
namespace cont
{
class DataSetFieldAdd
class VTKM_DEPRECATED(1.6,
"The AddPointField and AddCellField methods should now be called "
"directly on the vtkm::cont::DataSet object") DataSetFieldAdd
{
public:
VTKM_CONT

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

@ -16,7 +16,6 @@
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetBuilderRectilinear.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
@ -84,11 +83,10 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet0()
const 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);
dataSet.AddPointField("pointvar", var, nVerts);
dataSet.AddPointField("pointvar2", var2, nVerts);
return dataSet;
}
@ -100,9 +98,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet1()
const 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);
dataSet.AddPointField("pointvar", var, nVerts);
return dataSet;
}
@ -115,7 +112,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet2()
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);
@ -129,7 +125,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make1DUniformDataSet2()
idx++;
}
dsf.AddPointField(dataSet, "pointvar", pointvar, dims);
dataSet.AddPointField("pointvar", pointvar, dims);
return dataSet;
}
@ -158,10 +154,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make1DExplicitDataSet0()
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);
dataSet.AddPointField("pointvar", var, nVerts);
return dataSet;
}
@ -172,14 +166,13 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet0()
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);
dataSet.AddPointField("pointvar", var, nVerts);
constexpr vtkm::Float32 cellvar[2] = { 100.1f, 200.1f };
dsf.AddCellField(dataSet, "cellvar", cellvar, 2);
dataSet.AddCellField("cellvar", cellvar, 2);
return dataSet;
}
@ -191,7 +184,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet1()
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,
@ -203,8 +195,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet1()
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);
dataSet.AddPointField("pointvar", pointvar, nVerts);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}
@ -216,7 +208,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet2()
constexpr 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];
constexpr vtkm::Float64 dx = vtkm::Float64(4.0 * vtkm::Pi()) / vtkm::Float64(dims[0] - 1);
@ -238,7 +229,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make2DUniformDataSet2()
}
} // y
dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts);
dataSet.AddPointField("pointvar", pointvar, nVerts);
return dataSet;
}
@ -249,17 +240,16 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet0()
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);
dataSet.AddPointField("pointvar", vars, nVerts);
constexpr vtkm::Float32 cellvar[4] = { 100.1f, 100.2f, 100.3f, 100.4f };
dsf.AddCellField(dataSet, "cellvar", cellvar, 4);
dataSet.AddCellField("cellvar", cellvar, 4);
return dataSet;
}
@ -271,7 +261,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet1()
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] = {
@ -304,8 +293,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet1()
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);
dataSet.AddPointField("pointvar", pointvar, nVerts);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}
@ -317,7 +306,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet2()
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;
vtkm::Float32* pointvar = new vtkm::Float32[nVerts];
@ -329,7 +317,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet2()
pointvar[index] = vtkm::Sqrt(vtkm::Float32(x * x + y * y + z * z));
}
dsf.AddPointField(dataSet, "pointvar", pointvar, nVerts);
dataSet.AddPointField("pointvar", pointvar, nVerts);
delete[] pointvar;
@ -373,14 +361,11 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DUniformDataSet3(const vtkm::Id
} // y
} // z
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddPointField(dataSet, "pointvar", pointvar);
dataSet.AddPointField("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));
dataSet.AddCellField(
"cellvar", vtkm::cont::make_ArrayHandleCounting(vtkm::Float64(0), vtkm::Float64(1), numCells));
return dataSet;
}
@ -398,18 +383,17 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make2DRectilinearDataSet0()
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);
dataSet.AddPointField("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);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}
@ -486,18 +470,17 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DRectilinearDataSet0()
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);
dataSet.AddPointField("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);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}
@ -507,7 +490,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make2DExplicitDataSet0()
{
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSetFieldAdd dsf;
// Coordinates
const int nVerts = 16;
@ -592,8 +574,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make2DExplicitDataSet0()
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);
dataSet.AddPointField("pointvar", pointvar, nVerts);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}
@ -638,9 +620,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet0()
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);
dataSet.AddPointField("pointvar", vars, nVerts);
dataSet.AddCellField("cellvar", cellvar, 2);
return dataSet;
}
@ -926,7 +907,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet6()
{
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSetFieldAdd dsf;
// Coordinates
const int nVerts = 8;
@ -993,8 +973,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet6()
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);
dataSet.AddPointField("pointvar", pointvar, nVerts);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}
@ -1003,7 +983,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetZoo()
{
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSetFieldAdd dsf;
// Coordinates
constexpr int nVerts = 30;
@ -1241,8 +1220,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetZoo()
{ 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);
dataSet.AddPointField("pointvar", pointvar, nVerts);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}
@ -1251,7 +1230,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet7()
{
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSetFieldAdd dsf;
// Coordinates
const int nVerts = 8;
@ -1308,8 +1286,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet7()
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);
dataSet.AddPointField("pointvar", pointvar, nVerts);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}
@ -1318,7 +1296,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet8()
{
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSetFieldAdd dsf;
// Coordinates
const int nVerts = 8;
@ -1388,8 +1365,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet8()
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);
dataSet.AddPointField("pointvar", pointvar, nVerts);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}
@ -1397,7 +1374,6 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetPolygonal()
{
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSetFieldAdd dsf;
// Coordinates
const int nVerts = 8;
@ -1471,8 +1447,8 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetPolygonal()
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);
dataSet.AddPointField("pointvar", pointvar, nVerts);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}
@ -1528,11 +1504,10 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetCowNose()
cellvec.Allocate(connectivitySize / 3);
SetPortal(cellvec.WritePortal());
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);
dataSet.AddPointField("pointvar", pointvar);
dataSet.AddCellField("cellvar", cellvar);
dataSet.AddPointField("point_vectors", pointvec);
dataSet.AddCellField("cell_vectors", cellvec);
return dataSet;
}

4
vtkm/cont/testing/TestingDataSetSingleType.h
View File

@ -14,7 +14,6 @@
#include <vtkm/cont/CellSetSingleType.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/testing/Testing.h>
@ -89,8 +88,7 @@ private:
const int nVerts = 5;
vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f };
vtkm::cont::DataSetFieldAdd fieldAdder;
fieldAdder.AddPointField(ds, "pointvar", vars, nVerts);
ds.AddPointField("pointvar", vars, nVerts);
return ds;
}

18
vtkm/cont/testing/UnitTestDataSetBuilderExplicit.cxx
View File

@ -99,7 +99,6 @@ vtkm::cont::DataSet CreateDataSetArr(bool useSeparatedCoords,
const vtkm::UInt8* shape)
{
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetFieldAdd dsf;
vtkm::cont::DataSetBuilderExplicit dsb;
float f = 0.0f;
if (useSeparatedCoords)
@ -126,8 +125,8 @@ vtkm::cont::DataSet CreateDataSetArr(bool useSeparatedCoords,
DFA::Copy(vtkm::cont::make_ArrayHandle(varC), C);
dataSet = dsb.Create(
X, Y, Z, createAH(numCells, shape), createAH(numCells, indices), createAH(numConn, conn));
dsf.AddPointField(dataSet, "pointvar", P);
dsf.AddCellField(dataSet, "cellvar", C);
dataSet.AddPointField("pointvar", P);
dataSet.AddCellField("cellvar", C);
return dataSet;
}
else
@ -150,8 +149,8 @@ vtkm::cont::DataSet CreateDataSetArr(bool useSeparatedCoords,
DFA::Copy(vtkm::cont::make_ArrayHandle(tmp), pts);
dataSet = dsb.Create(
pts, createAH(numCells, shape), createAH(numCells, indices), createAH(numConn, conn));
dsf.AddPointField(dataSet, "pointvar", varP);
dsf.AddCellField(dataSet, "cellvar", varC);
dataSet.AddPointField("pointvar", varP);
dataSet.AddCellField("cellvar", varC);
return dataSet;
}
}
@ -167,7 +166,6 @@ vtkm::cont::DataSet CreateDataSetVec(bool useSeparatedCoords,
const vtkm::UInt8* shape)
{
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetFieldAdd dsf;
vtkm::cont::DataSetBuilderExplicit dsb;
float f = 0.0f;
@ -188,8 +186,8 @@ vtkm::cont::DataSet CreateDataSetVec(bool useSeparatedCoords,
}
dataSet = dsb.Create(
X, Y, Z, createVec(numCells, shape), createVec(numCells, indices), createVec(numConn, conn));
dsf.AddPointField(dataSet, "pointvar", varP);
dsf.AddCellField(dataSet, "cellvar", varC);
dataSet.AddPointField("pointvar", varP);
dataSet.AddCellField("cellvar", varC);
return dataSet;
}
else
@ -210,8 +208,8 @@ vtkm::cont::DataSet CreateDataSetVec(bool useSeparatedCoords,
}
dataSet = dsb.Create(
pts, createVec(numCells, shape), createVec(numCells, indices), createVec(numConn, conn));
dsf.AddPointField(dataSet, "pointvar", varP);
dsf.AddCellField(dataSet, "cellvar", varC);
dataSet.AddPointField("pointvar", varP);
dataSet.AddCellField("cellvar", varC);
return dataSet;
}
}

29
vtkm/cont/testing/UnitTestDataSetBuilderRectilinear.cxx
View File

@ -122,7 +122,6 @@ void RectilinearTests()
vtkm::cont::DataSetBuilderRectilinear dataSetBuilder;
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetFieldAdd dsf;
std::uniform_int_distribution<vtkm::Id> randomDim(1, MAX_DIM_SIZE);
std::uniform_int_distribution<vtkm::IdComponent> randomFill(0, NUM_FILL_METHODS - 1);
@ -176,8 +175,8 @@ void RectilinearTests()
}
std::cout << " Create with std::vector" << std::endl;
dataSet = dataSetBuilder.Create(xCoordinates);
dsf.AddPointField(dataSet, "pointvar", varP1D);
dsf.AddCellField(dataSet, "cellvar", varC1D);
dataSet.AddPointField("pointvar", varP1D);
dataSet.AddCellField("cellvar", varC1D);
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
}
@ -205,22 +204,22 @@ void RectilinearTests()
}
std::cout << " Create with std::vector" << std::endl;
dataSet = dataSetBuilder.Create(xCoordinates, yCoordinates);
dsf.AddPointField(dataSet, "pointvar", varP2D);
dsf.AddCellField(dataSet, "cellvar", varC2D);
dataSet.AddPointField("pointvar", varP2D);
dataSet.AddCellField("cellvar", varC2D);
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
std::cout << " Create with C array" << std::endl;
dataSet = dataSetBuilder.Create(
dimensions[0], dimensions[1], &xCoordinates.front(), &yCoordinates.front());
dsf.AddPointField(dataSet, "pointvar", &varP2D.front(), numPoints);
dsf.AddCellField(dataSet, "cellvar", &varC2D.front(), numCells);
dataSet.AddPointField("pointvar", &varP2D.front(), numPoints);
dataSet.AddCellField("cellvar", &varC2D.front(), numCells);
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
std::cout << " Create with ArrayHandle" << std::endl;
dataSet = dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates),
vtkm::cont::make_ArrayHandle(yCoordinates));
dsf.AddPointField(dataSet, "pointvar", vtkm::cont::make_ArrayHandle(varP2D));
dsf.AddCellField(dataSet, "cellvar", vtkm::cont::make_ArrayHandle(varC2D));
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP2D));
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC2D));
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
}
@ -249,8 +248,8 @@ void RectilinearTests()
std::cout << " Create with std::vector" << std::endl;
dataSet = dataSetBuilder.Create(xCoordinates, yCoordinates, zCoordinates);
dsf.AddPointField(dataSet, "pointvar", varP3D);
dsf.AddCellField(dataSet, "cellvar", varC3D);
dataSet.AddPointField("pointvar", varP3D);
dataSet.AddCellField("cellvar", varC3D);
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
std::cout << " Create with C array" << std::endl;
@ -260,16 +259,16 @@ void RectilinearTests()
&xCoordinates.front(),
&yCoordinates.front(),
&zCoordinates.front());
dsf.AddPointField(dataSet, "pointvar", vtkm::cont::make_ArrayHandle(varP3D));
dsf.AddCellField(dataSet, "cellvar", vtkm::cont::make_ArrayHandle(varC3D));
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP3D));
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC3D));
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
std::cout << " Create with ArrayHandle" << std::endl;
dataSet = dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates),
vtkm::cont::make_ArrayHandle(yCoordinates),
vtkm::cont::make_ArrayHandle(zCoordinates));
dsf.AddPointField(dataSet, "pointvar", vtkm::cont::make_ArrayHandle(varP3D));
dsf.AddCellField(dataSet, "cellvar", vtkm::cont::make_ArrayHandle(varC3D));
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP3D));
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC3D));
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
}
}

25
vtkm/cont/testing/UnitTestDataSetBuilderUniform.cxx
View File

@ -138,7 +138,6 @@ void UniformTests()
const vtkm::Id NUM_FILL_METHODS = 5;
vtkm::cont::DataSetBuilderUniform dataSetBuilder;
vtkm::cont::DataSetFieldAdd dsf;
std::uniform_int_distribution<vtkm::Id> randomDim(2, MAX_DIM_SIZE);
std::uniform_int_distribution<vtkm::IdComponent> randomFill(0, NUM_FILL_METHODS - 1);
@ -184,8 +183,8 @@ void UniformTests()
vtkm::cont::DataSet dataSet;
dataSet = dataSetBuilder.Create(dims, origin, spacing);
dsf.AddPointField(dataSet, "pointvar", pointvar);
dsf.AddCellField(dataSet, "cellvar", cellvar);
dataSet.AddPointField("pointvar", pointvar);
dataSet.AddCellField("cellvar", cellvar);
ValidateDataSet(dataSet, 3, numPoints, numCells, bounds);
}
@ -212,8 +211,8 @@ void UniformTests()
vtkm::cont::DataSet dataSet;
dataSet = dataSetBuilder.Create(dims, org, spc);
dsf.AddPointField(dataSet, "pointvar", pointvar);
dsf.AddCellField(dataSet, "cellvar", cellvar);
dataSet.AddPointField("pointvar", pointvar);
dataSet.AddCellField("cellvar", cellvar);
ValidateDataSet(dataSet, 2, numPoints, numCells, bounds);
}
@ -242,8 +241,8 @@ void UniformTests()
vtkm::cont::DataSet dataSet;
dataSet = dataSetBuilder.Create(dims, origin, spacing);
dsf.AddPointField(dataSet, "pointvar", pointvar);
dsf.AddCellField(dataSet, "cellvar", cellvar);
dataSet.AddPointField("pointvar", pointvar);
dataSet.AddCellField("cellvar", cellvar);
ValidateDataSet(dataSet, 2, numPoints, numCells, bounds);
}
@ -267,8 +266,8 @@ void UniformTests()
vtkm::cont::DataSet dataSet;
dataSet = dataSetBuilder.Create(dimensions[0], origin[0], spacing[0]);
dsf.AddPointField(dataSet, "pointvar", pointvar);
dsf.AddCellField(dataSet, "cellvar", cellvar);
dataSet.AddPointField("pointvar", pointvar);
dataSet.AddCellField("cellvar", cellvar);
ValidateDataSet(dataSet, 1, numPoints, numCells, bounds);
}
@ -299,8 +298,8 @@ void UniformTests()
vtkm::cont::DataSet dataSet;
dataSet = dataSetBuilder.Create(dims, org, spc);
dsf.AddPointField(dataSet, "pointvar", pointvar);
dsf.AddCellField(dataSet, "cellvar", cellvar);
dataSet.AddPointField("pointvar", pointvar);
dataSet.AddCellField("cellvar", cellvar);
ValidateDataSet(dataSet, 1, numPoints, numCells, bounds);
}
@ -332,8 +331,8 @@ void UniformTests()
vtkm::cont::DataSet dataSet;
dataSet = dataSetBuilder.Create(dims, origin, spacing);
dsf.AddPointField(dataSet, "pointvar", pointvar);
dsf.AddCellField(dataSet, "cellvar", cellvar);
dataSet.AddPointField("pointvar", pointvar);
dataSet.AddCellField("cellvar", cellvar);
ValidateDataSet(dataSet, 1, numPoints, numCells, bounds);
}

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

@ -76,7 +76,7 @@ inline vtkm::cont::DataSet make_SingleTypeDataSet()
const int nVerts = 5;
vtkm::Float32 vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f };
vtkm::cont::DataSetFieldAdd::AddPointField(ds, "pointvar", vars, nVerts);
ds.AddPointField("pointvar", vars, nVerts);
return ds;
}

7
vtkm/cont/testing/UnitTestFieldRangeCompute.cxx
View File

@ -9,7 +9,6 @@
//============================================================================
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/FieldRangeCompute.h>
#include <vtkm/cont/testing/Testing.h>
@ -110,8 +109,7 @@ void TryRangeComputeDS(const ValueType& min, const ValueType& max)
std::cout << "Trying type (dataset): " << vtkm::testing::TypeName<ValueType>::Name() << std::endl;
// let's create a dummy dataset with a bunch of fields.
vtkm::cont::DataSet dataset;
vtkm::cont::DataSetFieldAdd::AddPointField(
dataset,
dataset.AddPointField(
"pointvar",
CreateArray(min, max, ARRAY_SIZE, typename vtkm::TypeTraits<ValueType>::DimensionalityTag()));
@ -130,8 +128,7 @@ void TryRangeComputePDS(const ValueType& min, const ValueType& max)
{
// let's create a dummy dataset with a bunch of fields.
vtkm::cont::DataSet dataset;
vtkm::cont::DataSetFieldAdd::AddPointField(
dataset,
dataset.AddPointField(
"pointvar",
CreateArray(min, max, ARRAY_SIZE, typename vtkm::TypeTraits<ValueType>::DimensionalityTag()));
mb.AppendPartition(dataset);

7
vtkm/cont/testing/UnitTestFieldRangeGlobalCompute.cxx
View File

@ -9,7 +9,6 @@
//============================================================================
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/EnvironmentTracker.h>
#include <vtkm/cont/FieldRangeGlobalCompute.h>
#include <vtkm/cont/testing/Testing.h>
@ -153,8 +152,7 @@ void TryRangeGlobalComputeDS(const ValueType& min, const ValueType& max)
// let's create a dummy dataset with a bunch of fields.
vtkm::cont::DataSet dataset;
vtkm::cont::DataSetFieldAdd::AddPointField(
dataset,
dataset.AddPointField(
"pointvar",
CreateArray(lmin, lmax, ARRAY_SIZE, typename vtkm::TypeTraits<ValueType>::DimensionalityTag()));
@ -174,8 +172,7 @@ void TryRangeGlobalComputePDS(const ValueType& min, const ValueType& max)
{
// let's create a dummy dataset with a bunch of fields.
vtkm::cont::DataSet dataset;
vtkm::cont::DataSetFieldAdd::AddPointField(
dataset,
dataset.AddPointField(
"pointvar",
CreateArray(min, max, ARRAY_SIZE, typename vtkm::TypeTraits<ValueType>::DimensionalityTag()));
mb.AppendPartition(dataset);

1
vtkm/cont/testing/UnitTestPartitionedDataSet.cxx
View File

@ -16,7 +16,6 @@
#include <vtkm/cont/BoundsCompute.h>
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/FieldRangeCompute.h>
#include <vtkm/cont/PartitionedDataSet.h>
#include <vtkm/cont/serial/DeviceAdapterSerial.h>

6
vtkm/filter/Lagrangian.hxx
View File

@ -19,7 +19,6 @@
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetBuilderRectilinear.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/DeviceAdapter.h>
#include <vtkm/cont/ErrorFilterExecution.h>
#include <vtkm/worklet/ParticleAdvection.h>
@ -300,9 +299,8 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
std::vector<Float64> xC, yC, zC;
InitializeCoordinates(input, xC, yC, zC);
outputData = dataSetBuilder.Create(xC, yC, zC);
vtkm::cont::DataSetFieldAdd dataSetFieldAdd;
dataSetFieldAdd.AddPointField(outputData, "valid", BasisParticlesValidity);
dataSetFieldAdd.AddPointField(outputData, "displacement", BasisParticlesDisplacement);
outputData.AddPointField("valid", BasisParticlesValidity);
outputData.AddPointField("displacement", BasisParticlesDisplacement);
if (this->resetParticles)
{

1
vtkm/filter/LagrangianStructures.h
View File

@ -12,7 +12,6 @@
#define vtk_m_filter_LagrangianStructures_h
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/filter/FilterDataSetWithField.h>

3
vtkm/filter/LagrangianStructures.hxx
View File

@ -147,10 +147,9 @@ inline VTKM_CONT vtkm::cont::DataSet LagrangianStructures::DoExecute(
}
vtkm::cont::DataSet output;
vtkm::cont::DataSetFieldAdd fieldAdder;
output.AddCoordinateSystem(lcsInput.GetCoordinateSystem());
output.SetCellSet(lcsInput.GetCellSet());
fieldAdder.AddPointField(output, this->GetOutputFieldName(), outputField);
output.AddPointField(this->GetOutputFieldName(), outputField);
return output;
}

3
vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx
View File

@ -43,8 +43,7 @@ vtkm::cont::DataSet MakeTestDatasetExplicit()
values.push_back(2.0);
values.push_back(1.0);
values.push_back(0.0);
vtkm::cont::DataSetFieldAdd fieldAdder;
fieldAdder.AddPointField(ds, "scalars", values);
ds.AddPointField("scalars", values);
return ds;
}

3
vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx
View File

@ -35,8 +35,7 @@ vtkm::cont::DataSet MakeTestDatasetStructured()
vtkm::cont::DataSetBuilderUniform builder;
ds = builder.Create(dim);
vtkm::cont::DataSetFieldAdd fieldAdder;
fieldAdder.AddPointField(ds, "scalars", scalars, numVerts);
ds.AddPointField("scalars", scalars, numVerts);
return ds;
}

4
vtkm/filter/testing/UnitTestContourFilterNormals.cxx
View File

@ -11,7 +11,6 @@
#include <vtkm/Math.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/CleanGrid.h>
@ -28,7 +27,6 @@ vtkm::cont::DataSet MakeNormalsTestDataSet()
vtkm::Id3 dimensions(3, 4, 4);
vtkm::cont::DataSet dataSet = dsb.Create(dimensions);
vtkm::cont::DataSetFieldAdd dsf;
const int nVerts = 48;
vtkm::Float32 vars[nVerts] = { 60.764f, 107.555f, 80.524f, 63.639f, 131.087f, 83.4f,
98.161f, 165.608f, 117.921f, 37.353f, 84.145f, 57.114f,
@ -40,7 +38,7 @@ vtkm::cont::DataSet MakeNormalsTestDataSet()
98.161f, 165.608f, 117.921f, 37.353f, 84.145f, 57.114f };
//Set point and cell scalar
dsf.AddPointField(dataSet, "pointvar", vars, nVerts);
dataSet.AddPointField("pointvar", vars, nVerts);
return dataSet;
}

4
vtkm/filter/testing/UnitTestCrossProductFilter.cxx
View File

@ -132,8 +132,8 @@ void TestCrossProduct()
field1 = vtkm::cont::make_ArrayHandle(vecs1);
field2 = vtkm::cont::make_ArrayHandle(vecs2);
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec1", field1);
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec2", field2);
dataSet.AddPointField("vec1", field1);
dataSet.AddPointField("vec2", field2);
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("vecA", field1));
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("vecB", field2));

4
vtkm/filter/testing/UnitTestDotProductFilter.cxx
View File

@ -121,8 +121,8 @@ void TestDotProduct()
field1 = vtkm::cont::make_ArrayHandle(vecs1);
field2 = vtkm::cont::make_ArrayHandle(vecs2);
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec1", field1);
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec2", field2);
dataSet.AddPointField("vec1", field1);
dataSet.AddPointField("vec2", field2);
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("vecA", field1));
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("vecB", field2));

3
vtkm/filter/testing/UnitTestFieldToColors.cxx
View File

@ -29,8 +29,7 @@ void TestFieldToColors()
table.SetBelowRangeColor(vtkm::Vec<float, 3>{ 0.0f, 0.0f, 1.0f }); //green
vtkm::cont::DataSet ds = vtkm::cont::testing::MakeTestDataSet().Make3DExplicitDataSetPolygonal();
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddPointField(ds, "faux", data, nvals);
ds.AddPointField("faux", data, nvals);
vtkm::filter::FieldToColors ftc(table);
ftc.SetOutputToRGBA();

1
vtkm/filter/testing/UnitTestGhostCellClassify.cxx
View File

@ -12,7 +12,6 @@
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetBuilderRectilinear.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/GhostCellClassify.h>

10
vtkm/filter/testing/UnitTestGhostCellRemove.cxx
View File

@ -12,7 +12,6 @@
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetBuilderRectilinear.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/GhostCellRemove.h>
@ -96,8 +95,7 @@ static vtkm::cont::DataSet MakeUniform(vtkm::Id numI,
ds = dsb.Create(vtkm::Id3(numI + 1, numJ + 1, numK + 1));
auto ghosts = StructuredGhostCellArray(numI, numJ, numK, numLayers, addMidGhost);
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddCellField(ds, "vtkmGhostCells", ghosts);
ds.AddCellField("vtkmGhostCells", ghosts);
return ds;
}
@ -132,8 +130,7 @@ static vtkm::cont::DataSet MakeRectilinear(vtkm::Id numI,
auto ghosts = StructuredGhostCellArray(numI, numJ, numK, numLayers, addMidGhost);
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddCellField(ds, "vtkmGhostCells", ghosts);
ds.AddCellField("vtkmGhostCells", ghosts);
return ds;
}
@ -209,8 +206,7 @@ static vtkm::cont::DataSet MakeExplicit(vtkm::Id numI, vtkm::Id numJ, vtkm::Id n
auto ghosts = StructuredGhostCellArray(numI, numJ, numK, numLayers);
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddCellField(ds, "vtkmGhostCells", ghosts);
ds.AddCellField("vtkmGhostCells", ghosts);
return ds;
}

4
vtkm/filter/testing/UnitTestGradientUniform.cxx
View File

@ -61,7 +61,7 @@ void TestCellGradientUniform3DWithVectorField()
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec_pointvar", input);
dataSet.AddPointField("vec_pointvar", input);
//we need to add Vec3 array to the dataset
vtkm::filter::Gradient gradient;
@ -119,7 +119,7 @@ void TestPointGradientUniform3DWithVectorField()
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec_pointvar", input);
dataSet.AddPointField("vec_pointvar", input);
//we need to add Vec3 array to the dataset
vtkm::filter::Gradient gradient;

4
vtkm/filter/testing/UnitTestImageConnectivityFilter.cxx
View File

@ -13,7 +13,6 @@
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
namespace
@ -31,8 +30,7 @@ vtkm::cont::DataSet MakeTestDataSet()
vtkm::cont::DataSetBuilderUniform builder;
vtkm::cont::DataSet dataSet = builder.Create(vtkm::Id3(8, 8, 1));
vtkm::cont::DataSetFieldAdd dataSetFieldAdd;
dataSetFieldAdd.AddPointField(dataSet, "color", pixels);
dataSet.AddPointField("color", pixels);
return dataSet;
}

4
vtkm/filter/testing/UnitTestLagrangianFilter.cxx
View File

@ -11,7 +11,6 @@
#include <iostream>
#include <vtkm/cont/CellLocatorBoundingIntervalHierarchy.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/Lagrangian.h>
@ -39,7 +38,6 @@ vtkm::cont::DataSet MakeTestUniformDataSet()
vtkm::Vec3f_64 SPACING(xdiff, ydiff, zdiff);
vtkm::cont::DataSet dataset = dsb.Create(DIMS, ORIGIN, SPACING);
vtkm::cont::DataSetFieldAdd dsf;
vtkm::Id numPoints = DIMS[0] * DIMS[1] * DIMS[2];
@ -59,7 +57,7 @@ vtkm::cont::DataSet MakeTestUniformDataSet()
}
}
}
dsf.AddPointField(dataset, "velocity", velocityField);
dataset.AddPointField("velocity", velocityField);
return dataset;
}

7
vtkm/filter/testing/UnitTestLagrangianStructuresFilter.cxx
View File

@ -10,7 +10,6 @@
#include <iostream>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/LagrangianStructures.h>
@ -331,8 +330,7 @@ void Test2DLCS()
vtkm::cont::ArrayHandle<vtkm::FloatDefault> diffHandle = vtkm::cont::make_ArrayHandle(diffVec);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> visitHandle = vtkm::cont::make_ArrayHandle(visitVec);
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldHandle = vtkm::cont::make_ArrayHandle(fieldVec);
vtkm::cont::DataSetFieldAdd fieldAdder;
fieldAdder.AddPointField(inputData, "velocity", fieldHandle);
inputData.AddPointField("velocity", fieldHandle);
vtkm::filter::LagrangianStructures lagrangianStructures;
lagrangianStructures.SetStepSize(0.025f);
@ -368,8 +366,7 @@ void Test3DLCS()
vtkm::cont::ArrayHandle<vtkm::FloatDefault> diffHandle = vtkm::cont::make_ArrayHandle(diffVec);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> visitHandle = vtkm::cont::make_ArrayHandle(visitVec);
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldHandle = vtkm::cont::make_ArrayHandle(fieldVec);
vtkm::cont::DataSetFieldAdd fieldAdder;
fieldAdder.AddPointField(inputData, "velocity", fieldHandle);
inputData.AddPointField("velocity", fieldHandle);
vtkm::filter::LagrangianStructures lagrangianStructures;
lagrangianStructures.SetStepSize(0.01f);

6
vtkm/filter/testing/UnitTestPartitionedDataSetFilters.cxx
View File

@ -13,7 +13,6 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/PartitionedDataSet.h>
#include <vtkm/cont/serial/DeviceAdapterSerial.h>
@ -30,7 +29,6 @@ vtkm::cont::PartitionedDataSet PartitionedDataSetBuilder(std::size_t partitionNu
{
vtkm::cont::DataSetBuilderUniform dataSetBuilder;
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetFieldAdd dsf;
vtkm::Vec<T, 2> origin(0);
vtkm::Vec<T, 2> spacing(1);
@ -51,7 +49,7 @@ vtkm::cont::PartitionedDataSet PartitionedDataSetBuilder(std::size_t partitionNu
dataSet = dataSetBuilder.Create(vtkm::Id2(dimensions[0], dimensions[1]),
vtkm::Vec<T, 2>(origin[0], origin[1]),
vtkm::Vec<T, 2>(spacing[0], spacing[1]));
dsf.AddCellField(dataSet, "cellvar", varC2D);
dataSet.AddCellField("cellvar", varC2D);
}
if (fieldName == "pointvar")
@ -65,7 +63,7 @@ vtkm::cont::PartitionedDataSet PartitionedDataSetBuilder(std::size_t partitionNu
dataSet = dataSetBuilder.Create(vtkm::Id2(dimensions[0], dimensions[1]),
vtkm::Vec<T, 2>(origin[0], origin[1]),
vtkm::Vec<T, 2>(spacing[0], spacing[1]));
dsf.AddPointField(dataSet, "pointvar", varP2D);
dataSet.AddPointField("pointvar", varP2D);
}
partitions.AppendPartition(dataSet);

5
vtkm/filter/testing/UnitTestProbe.cxx
View File

@ -11,7 +11,6 @@
#include <vtkm/cont/ArrayCopy.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/worklet/CellDeepCopy.h>
@ -33,8 +32,8 @@ vtkm::cont::DataSet MakeInputDataSet()
auto input = vtkm::cont::DataSetBuilderUniform::Create(
vtkm::Id2(4, 4), vtkm::make_Vec(0.0f, 0.0f), vtkm::make_Vec(1.0f, 1.0f));
vtkm::cont::DataSetFieldAdd::AddPointField(input, "pointdata", pvec);
vtkm::cont::DataSetFieldAdd::AddCellField(input, "celldata", cvec);
input.AddPointField("pointdata", pvec);
input.AddCellField("celldata", cvec);
return input;
}

5
vtkm/filter/testing/UnitTestSplitSharpEdgesFilter.cxx
View File

@ -105,9 +105,8 @@ vtkm::cont::DataSet Make3DExplicitSimpleCube()
vtkm::FloatDefault vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f, 60.3f, 70.3f, 80.3f };
vtkm::FloatDefault cellvar[nCells] = { 100.1f, 200.2f, 300.3f, 400.4f, 500.5f, 600.6f };
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddPointField(dataSet, "pointvar", vars, nVerts);
dsf.AddCellField(dataSet, "cellvar", cellvar, nCells);
dataSet.AddPointField("pointvar", vars, nVerts);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}

5
vtkm/filter/testing/UnitTestStreamSurfaceFilter.cxx
View File

@ -9,7 +9,6 @@
//============================================================================
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/StreamSurface.h>
@ -25,10 +24,8 @@ vtkm::cont::DataSet CreateDataSet(const vtkm::Id3& dims, const vtkm::Vec3f& vec)
vectorField[i] = vec;
vtkm::cont::DataSetBuilderUniform dataSetBuilder;
vtkm::cont::DataSetFieldAdd dataSetField;
vtkm::cont::DataSet ds = dataSetBuilder.Create(dims);
dataSetField.AddPointField(ds, "vector", vectorField);
ds.AddPointField("vector", vectorField);
return ds;
}

4
vtkm/filter/testing/UnitTestStreamlineFilter.cxx
View File

@ -9,7 +9,6 @@
//============================================================================
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/Pathline.h>
#include <vtkm/filter/Streamline.h>
@ -25,10 +24,9 @@ vtkm::cont::DataSet CreateDataSet(const vtkm::Id3& dims, const vtkm::Vec3f& vec)
vectorField[i] = vec;
vtkm::cont::DataSetBuilderUniform dataSetBuilder;
vtkm::cont::DataSetFieldAdd dataSetField;
vtkm::cont::DataSet ds = dataSetBuilder.Create(dims);
dataSetField.AddPointField(ds, "vector", vectorField);
ds.AddPointField("vector", vectorField);
return ds;
}

6
vtkm/filter/testing/UnitTestTubeFilter.cxx
View File

@ -9,7 +9,6 @@
//============================================================================
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/Tube.h>
@ -30,7 +29,6 @@ void TestTubeFilters()
using VecType = vtkm::Vec3f;
vtkm::cont::DataSetBuilderExplicitIterative dsb;
vtkm::cont::DataSetFieldAdd dsf;
std::vector<vtkm::Id> ids;
ids.clear();
@ -63,8 +61,8 @@ void TestTubeFilters()
cellVar.push_back(110);
cellVar.push_back(111);
dsf.AddPointField(ds, "pointVar", ptVar);
dsf.AddCellField(ds, "cellVar", cellVar);
ds.AddPointField("pointVar", ptVar);
ds.AddCellField("cellVar", cellVar);
vtkm::filter::Tube tubeFilter;
tubeFilter.SetCapping(true);

2
vtkm/filter/testing/UnitTestVectorMagnitudeFilter.cxx
View File

@ -35,7 +35,7 @@ void TestVectorMagnitude()
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> finput = vtkm::cont::make_ArrayHandle(fvec);
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "double_vec_pointvar", finput);
dataSet.AddPointField("double_vec_pointvar", finput);
vtkm::filter::VectorMagnitude vm;
vm.SetActiveField("double_vec_pointvar");

6
vtkm/filter/testing/UnitTestWarpScalarFilter.cxx
View File

@ -43,13 +43,13 @@ vtkm::cont::DataSet MakeWarpScalarTestDataSet()
dataSet.AddCoordinateSystem(
vtkm::cont::make_CoordinateSystem("coordinates", coordinates, vtkm::CopyFlag::On));
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec1", vec1);
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "scalarfactor", scalarFactor);
dataSet.AddPointField("vec1", vec1);
dataSet.AddPointField("scalarfactor", scalarFactor);
vecType normal = vtkm::make_Vec<T>(static_cast<T>(0.0), static_cast<T>(0.0), static_cast<T>(1.0));
vtkm::cont::ArrayHandleConstant<vecType> vectorAH =
vtkm::cont::make_ArrayHandleConstant(normal, dim * dim);
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "normal", vectorAH);
dataSet.AddPointField("normal", vectorAH);
return dataSet;
}

4
vtkm/filter/testing/UnitTestWarpVectorFilter.cxx
View File

@ -41,12 +41,12 @@ vtkm::cont::DataSet MakeWarpVectorTestDataSet()
dataSet.AddCoordinateSystem(
vtkm::cont::make_CoordinateSystem("coordinates", coordinates, vtkm::CopyFlag::On));
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec1", vec1);
dataSet.AddPointField("vec1", vec1);
vecType vector = vtkm::make_Vec<T>(static_cast<T>(0.0), static_cast<T>(0.0), static_cast<T>(2.0));
vtkm::cont::ArrayHandleConstant<vecType> vectorAH =
vtkm::cont::make_ArrayHandleConstant(vector, dim * dim);
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec2", vectorAH);
dataSet.AddPointField("vec2", vectorAH);
return dataSet;
}

1
vtkm/filter/testing/UnitTestZFP.cxx
View File

@ -13,7 +13,6 @@
#include <vtkm/cont/CellSetSingleType.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/ZFPCompressor1D.h>

10
vtkm/io/BOVDataSetReader.cxx
View File

@ -11,7 +11,6 @@
#include <vtkm/io/BOVDataSetReader.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/io/ErrorIO.h>
#include <fstream>
@ -213,7 +212,6 @@ void BOVDataSetReader::LoadFile()
vtkm::cont::DataSetBuilderUniform dataSetBuilder;
vtkm::cont::DataSetFieldAdd dsf;
this->DataSet = dataSetBuilder.Create(dim, origin, spacing);
vtkm::Id numTuples = dim[0] * dim[1] * dim[2];
@ -223,13 +221,13 @@ void BOVDataSetReader::LoadFile()
{
vtkm::cont::ArrayHandle<vtkm::Float32> var;
ReadScalar(fullPathDataFile, numTuples, var);
dsf.AddPointField(this->DataSet, variableName, var);
this->DataSet.AddPointField(variableName, var);
}
else if (dataFormat == DataFormat::DoubleData)
{
vtkm::cont::ArrayHandle<vtkm::Float64> var;
ReadScalar(fullPathDataFile, numTuples, var);
dsf.AddPointField(this->DataSet, variableName, var);
this->DataSet.AddPointField(variableName, var);
}
}
else if (numComponents == 3)
@ -238,13 +236,13 @@ void BOVDataSetReader::LoadFile()
{
vtkm::cont::ArrayHandle<vtkm::Vec3f_32> var;
ReadVector(fullPathDataFile, numTuples, var);
dsf.AddPointField(this->DataSet, variableName, var);
this->DataSet.AddPointField(variableName, var);
}
else if (dataFormat == DataFormat::DoubleData)
{
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> var;
ReadVector(fullPathDataFile, numTuples, var);
dsf.AddPointField(this->DataSet, variableName, var);
this->DataSet.AddPointField(variableName, var);
}
}

10
vtkm/io/ImageReader.hxx
View File

@ -12,7 +12,6 @@
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/io/ImageReader.h>
#include <vtkm/io/PixelTypes.h>
#include <vtkm/rendering/Canvas.h>
@ -50,8 +49,7 @@ vtkm::cont::DataSet BaseImageReader::CreateImageDataSet(
}
}
auto dataSet = this->InitializeImageDataSet(width, height);
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddPointField(dataSet, this->PointFieldName, fieldData);
dataSet.AddPointField(this->PointFieldName, fieldData);
return dataSet;
}
@ -102,8 +100,7 @@ vtkm::cont::DataSet PNGReader::ReadFromFile(const std::string& fileName)
}
auto dataSet = this->InitializeImageDataSet(width, height);
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddPointField(dataSet, this->PointFieldName, fieldData);
dataSet.AddPointField(this->PointFieldName, fieldData);
free(imageData);
return dataSet;
@ -164,8 +161,7 @@ vtkm::cont::DataSet PNMReader::DecodeFile(std::ifstream& inStream,
}
auto dataSet = this->InitializeImageDataSet(width, height);
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddPointField(dataSet, this->PointFieldName, fieldData);
dataSet.AddPointField(this->PointFieldName, fieldData);
return dataSet;
}
// End PNMReader Class Template Implementations

1
vtkm/io/ImageWriter.hxx
View File

@ -12,7 +12,6 @@
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/io/ImageWriter.h>
#include <vtkm/io/PixelTypes.h>

3
vtkm/io/testing/UnitTestVTKDataSetWriter.cxx
View File

@ -107,7 +107,6 @@ void TestVTKCompoundWrite()
vtkm::Float64 dt = (t_max - t_min) / vtkm::Float64(dims[1] - 1);
vtkm::Vec2f_64 spacing(dt, ds);
vtkm::cont::DataSet dataSet = dsb.Create(dims, origin, spacing);
vtkm::cont::DataSetFieldAdd dsf;
size_t nVerts = static_cast<size_t>(s_samples * s_samples);
std::vector<vtkm::Vec2f_64> points(nVerts);
@ -125,7 +124,7 @@ void TestVTKCompoundWrite()
}
}
dsf.AddPointField(dataSet, "z", points.data(), static_cast<vtkm::Id>(points.size()));
dataSet.AddPointField("z", points.data(), static_cast<vtkm::Id>(points.size()));
vtkm::io::VTKDataSetWriter writer("chirp.vtk");
writer.WriteDataSet(dataSet);
std::remove("chirp.vtk");

7
vtkm/rendering/testing/UnitTestMapperWireframer.cxx
View File

@ -33,7 +33,7 @@ vtkm::cont::DataSet Make3DUniformDataSet(vtkm::Id size = 64)
0.0f, 10.0f / static_cast<vtkm::Float32>(numValues), numValues);
vtkm::cont::ArrayHandle<vtkm::Float32> scalarField;
vtkm::cont::ArrayCopy(fieldValues, scalarField);
vtkm::cont::DataSetFieldAdd().AddPointField(dataSet, fieldName, scalarField);
dataSet.AddPointField(fieldName, scalarField);
return dataSet;
}
@ -82,9 +82,8 @@ vtkm::cont::DataSet Make2DExplicitDataSet()
cellSet.Fill(nVerts, vtkm::CELL_SHAPE_LINE, 2, connectivity);
dataSet.SetCellSet(cellSet);
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddPointField(dataSet, "pointVar", pointVar);
dsf.AddCellField(dataSet, "cellVar", cellVar);
dataSet.AddPointField("pointVar", pointVar);
dataSet.AddCellField("cellVar", cellVar);
return dataSet;
}

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

@ -17,7 +17,6 @@
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/Field.h>
#include <vtkm/cont/ImplicitFunctionHandle.h>
#include <vtkm/cont/testing/Testing.h>
@ -69,19 +68,18 @@ vtkm::cont::DataSet MakeTestDatasetExplicit()
vtkm::cont::DataSetBuilderExplicit builder;
ds = builder.Create(coords, vtkm::CellShapeTagTriangle(), 3, connectivity, "coords");
vtkm::cont::DataSetFieldAdd fieldAdder;
std::vector<vtkm::Float32> values;
values.push_back(1.0);
values.push_back(2.0);
values.push_back(1.0);
values.push_back(0.0);
fieldAdder.AddPointField(ds, "scalars", values);
ds.AddPointField("scalars", values);
values.clear();
values.push_back(100.f);
values.push_back(-100.f);
fieldAdder.AddCellField(ds, "cellvar", values);
ds.AddCellField("cellvar", values);
return ds;
}
@ -103,11 +101,10 @@ vtkm::cont::DataSet MakeTestDatasetStructured()
vtkm::cont::DataSetBuilderUniform builder;
ds = builder.Create(dim);
vtkm::cont::DataSetFieldAdd fieldAdder;
fieldAdder.AddPointField(ds, "scalars", scalars, numVerts);
ds.AddPointField("scalars", scalars, numVerts);
std::vector<vtkm::Float32> cellvar = { -100.f, 100.f, 30.f, -30.f };
fieldAdder.AddCellField(ds, "cellvar", cellvar);
ds.AddCellField("cellvar", cellvar);
return ds;
}

12
vtkm/worklet/testing/UnitTestClippingWithFunction.cxx
View File

@ -17,7 +17,6 @@
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/Field.h>
#include <vtkm/cont/ImplicitFunctionHandle.h>
#include <vtkm/cont/testing/Testing.h>
@ -70,19 +69,17 @@ vtkm::cont::DataSet MakeTestDatasetExplicit()
vtkm::cont::DataSetBuilderExplicit builder;
ds = builder.Create(coords, vtkm::CellShapeTagTriangle(), 3, connectivity, "coords");
vtkm::cont::DataSetFieldAdd fieldAdder;
std::vector<vtkm::Float32> values;
values.push_back(1.0);
values.push_back(2.0);
values.push_back(1.0);
values.push_back(0.0);
fieldAdder.AddPointField(ds, "scalars", values);
ds.AddPointField("scalars", values);
values.clear();
values.push_back(100.f);
values.push_back(-100.f);
fieldAdder.AddCellField(ds, "cellvar", values);
ds.AddCellField("cellvar", values);
return ds;
}
@ -104,11 +101,10 @@ vtkm::cont::DataSet MakeTestDatasetStructured()
vtkm::cont::DataSetBuilderUniform builder;
ds = builder.Create(dim);
vtkm::cont::DataSetFieldAdd fieldAdder;
fieldAdder.AddPointField(ds, "scalars", scalars, numVerts);
ds.AddPointField("scalars", scalars, numVerts);
std::vector<vtkm::Float32> cellvar = { -100.f, 100.f, 30.f, -30.f };
fieldAdder.AddCellField(ds, "cellvar", cellvar);
ds.AddCellField("cellvar", cellvar);
return ds;
}

23
vtkm/worklet/testing/UnitTestCosmoTools.cxx
View File

@ -18,7 +18,6 @@
#include <vtkm/cont/CellSetExplicit.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <fstream>
@ -55,7 +54,6 @@ vtkm::cont::DataSet MakeCosmo_2DDataSet_0()
{
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSetFieldAdd dsf;
// Coordinates
const int nVerts = 17;
@ -102,11 +100,11 @@ vtkm::cont::DataSet MakeCosmo_2DDataSet_0()
vtkm::Id haloId[nCells] = { 0, 0, 2, 0, 2, 0, 0, 2, 0, 0, 0, 2, 0, 0, 2, 0, 0 };
vtkm::Id mbp[nCells] = { 8, 8, 7, 8, 7, 8, 8, 7, 8, 8, 8, 7, 8, 8, 7, 8, 8 };
dsf.AddCellField(dataSet, "xLocation", xLocation, nCells);
dsf.AddCellField(dataSet, "yLocation", yLocation, nCells);
dsf.AddCellField(dataSet, "zLocation", zLocation, nCells);
dsf.AddCellField(dataSet, "haloId", haloId, nCells);
dsf.AddCellField(dataSet, "mbp", mbp, nCells);
dataSet.AddCellField("xLocation", xLocation, nCells);
dataSet.AddCellField("yLocation", yLocation, nCells);
dataSet.AddCellField("zLocation", zLocation, nCells);
dataSet.AddCellField("haloId", haloId, nCells);
dataSet.AddCellField("mbp", mbp, nCells);
return dataSet;
}
@ -117,7 +115,6 @@ vtkm::cont::DataSet MakeCosmo_3DDataSet_0()
{
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSetFieldAdd dsf;
// Coordinates
const int nVerts = 14;
@ -167,11 +164,11 @@ vtkm::cont::DataSet MakeCosmo_3DDataSet_0()
vtkm::Id haloId[nCells] = { 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1 };
vtkm::Id mbp[nCells] = { 9, 4, 4, 4, 4, 9, 9, 9, 9, 9, 4, 9, 9, 4 };
dsf.AddCellField(dataSet, "xLocation", xLocation, nCells);
dsf.AddCellField(dataSet, "yLocation", yLocation, nCells);
dsf.AddCellField(dataSet, "zLocation", zLocation, nCells);
dsf.AddCellField(dataSet, "haloId", haloId, nCells);
dsf.AddCellField(dataSet, "mbp", mbp, nCells);
dataSet.AddCellField("xLocation", xLocation, nCells);
dataSet.AddCellField("yLocation", yLocation, nCells);
dataSet.AddCellField("zLocation", zLocation, nCells);
dataSet.AddCellField("haloId", haloId, nCells);
dataSet.AddCellField("mbp", mbp, nCells);
return dataSet;
}

7
vtkm/worklet/testing/UnitTestProbe.cxx
View File

@ -12,7 +12,6 @@
#include <vtkm/cont/ArrayCopy.h>
#include <vtkm/cont/ArrayHandleCounting.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/worklet/CellDeepCopy.h>
@ -24,10 +23,8 @@ vtkm::cont::DataSet MakeInputDataSet()
{
auto input = vtkm::cont::DataSetBuilderUniform::Create(
vtkm::Id2(4, 4), vtkm::make_Vec(0.0f, 0.0f), vtkm::make_Vec(1.0f, 1.0f));
vtkm::cont::DataSetFieldAdd::AddPointField(
input, "pointdata", vtkm::cont::make_ArrayHandleCounting(0.0f, 0.3f, 16));
vtkm::cont::DataSetFieldAdd::AddCellField(
input, "celldata", vtkm::cont::make_ArrayHandleCounting(0.0f, 0.7f, 9));
input.AddPointField("pointdata", vtkm::cont::make_ArrayHandleCounting(0.0f, 0.3f, 16));
input.AddCellField("celldata", vtkm::cont::make_ArrayHandleCounting(0.0f, 0.7f, 9));
return input;
}

5
vtkm/worklet/testing/UnitTestSplitSharpEdges.cxx
View File

@ -102,9 +102,8 @@ vtkm::cont::DataSet Make3DExplicitSimpleCube()
vtkm::FloatDefault vars[nVerts] = { 10.1f, 20.1f, 30.2f, 40.2f, 50.3f, 60.3f, 70.3f, 80.3f };
vtkm::FloatDefault cellvar[nCells] = { 100.1f, 200.2f, 300.3f, 400.4f, 500.5f, 600.6f };
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddPointField(dataSet, "pointvar", vars, nVerts);
dsf.AddCellField(dataSet, "cellvar", cellvar, nCells);
dataSet.AddPointField("pointvar", vars, nVerts);
dataSet.AddCellField("cellvar", cellvar, nCells);
return dataSet;
}

3
vtkm/worklet/testing/UnitTestWarpScalar.cxx
View File

@ -13,7 +13,6 @@
#include <vtkm/cont/CellSetExplicit.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/testing/Testing.h>
@ -43,7 +42,7 @@ vtkm::cont::DataSet MakeWarpScalarTestDataSet()
dataSet.AddCoordinateSystem(
vtkm::cont::make_CoordinateSystem("coordinates", coordinates, vtkm::CopyFlag::On));
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "scalefactor", scaleFactor);
dataSet.AddPointField("scalefactor", scaleFactor);
return dataSet;
}
}