Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Use the strong typed enums for vtkm::cont::Field

Browse Source 
Since Field association is used either when creating or working
with 'vtkm::cont::Field', it's put in the class itself.
This commit is contained in:
Haocheng LIU 2018-05-18 16:10:15 -04:00
parent 87e25dc773
commit 5c797169ec
92 changed files with 561 additions and 436 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/changelog/Convert-enums-to-enum-structs.md Normal file
View File

@ -0,0 +1,4 @@
# Use the strong typed enums for vtkm::cont::Field
By doing so, the compiler would not convert these enums into `int`s
which can cause some unexpected behavior.

4
examples/clipping/Clipping.cxx
View File

@ -119,11 +119,11 @@ int main(int argc, char* argv[])
bool isCellField;
switch (inField.GetAssociation())
{
case vtkm::cont::Field::ASSOC_POINTS:
case vtkm::cont::Field::Association::POINTS:
isCellField = false;
break;
case vtkm::cont::Field::ASSOC_CELL_SET:
case vtkm::cont::Field::Association::CELL_SET:
isCellField = true;
break;

12
examples/game_of_life/GameOfLife.cxx
View File

@ -150,7 +150,7 @@ public:
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
//get the previous state of the game
input.GetField("state", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(prevstate);
input.GetField("state", vtkm::cont::Field::Association::POINTS).GetData().CopyTo(prevstate);
//Update the game state
DispatcherType().Invoke(vtkm::filter::ApplyPolicy(cells, policy), prevstate, state, colors);
@ -160,10 +160,10 @@ public:
output.AddCellSet(input.GetCellSet(this->GetActiveCellSetIndex()));
output.AddCoordinateSystem(input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex()));
vtkm::cont::Field colorField("colors", vtkm::cont::Field::ASSOC_POINTS, colors);
vtkm::cont::Field colorField("colors", vtkm::cont::Field::Association::POINTS, colors);
output.AddField(colorField);
vtkm::cont::Field stateField("state", vtkm::cont::Field::ASSOC_POINTS, state);
vtkm::cont::Field stateField("state", vtkm::cont::Field::Association::POINTS, state);
output.AddField(stateField);
return output;
@ -240,7 +240,8 @@ struct RenderGameOfLife
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
vtkm::Int32 arraySize = (vtkm::Int32)data.GetCoordinateSystem().GetData().GetNumberOfValues();
UploadData task(&this->ColorState, data.GetField("colors", vtkm::cont::Field::ASSOC_POINTS));
UploadData task(&this->ColorState,
data.GetField("colors", vtkm::cont::Field::Association::POINTS));
vtkm::cont::TryExecute(task, DevicesToTry());
vtkm::Float32 mvp[16] = { 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f,
@ -367,7 +368,8 @@ int main(int argc, char** argv)
vtkm::cont::DataSetBuilderUniform builder;
vtkm::cont::DataSet data = builder.Create(vtkm::Id2(x, y));
auto stateField = vtkm::cont::make_Field("state", vtkm::cont::Field::ASSOC_POINTS, input_state);
auto stateField =
vtkm::cont::make_Field("state", vtkm::cont::Field::Association::POINTS, input_state);
data.AddField(stateField);
GameOfLife filter;

4
examples/histogram/HistogramMPI.hxx
View File

@ -153,7 +153,7 @@ inline VTKM_CONT vtkm::cont::DataSet HistogramMPI::DoExecute(
this->BinDelta = static_cast<vtkm::Float64>(delta);
vtkm::cont::DataSet output;
vtkm::cont::Field rfield(
this->GetOutputFieldName(), vtkm::cont::Field::ASSOC_WHOLE_MESH, binArray);
this->GetOutputFieldName(), vtkm::cont::Field::Association::WHOLE_MESH, binArray);
output.AddField(rfield);
return output;
}
@ -195,7 +195,7 @@ inline VTKM_CONT void HistogramMPI::PostExecute(const vtkm::cont::MultiBlock&,
vtkm::cont::DataSet output;
vtkm::cont::Field rfield(this->GetOutputFieldName(),
vtkm::cont::Field::ASSOC_WHOLE_MESH,
vtkm::cont::Field::Association::WHOLE_MESH,
helper.ReduceAll(this->NumberOfBins));
output.AddField(rfield);

3
examples/isosurface/IsosurfaceUniformGrid.cxx
View File

@ -130,7 +130,8 @@ vtkm::cont::DataSet MakeIsosurfaceTestDataSet(vtkm::Id3 dims)
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vdims, origin, spacing);
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
dataSet.AddField(vtkm::cont::Field("nodevar", vtkm::cont::Field::ASSOC_POINTS, fieldArray));
dataSet.AddField(
vtkm::cont::Field("nodevar", vtkm::cont::Field::Association::POINTS, fieldArray));
static const vtkm::IdComponent ndim = 3;
vtkm::cont::CellSetStructured<ndim> cellSet("cells");

2
examples/multi_backend/MultiBackend.cxx
View File

@ -97,7 +97,7 @@ void multiblock_processing(TaskQueue<vtkm::cont::MultiBlock>& queue)
// block.PrintSummary(std::cout);
try
{
const auto& field = block.GetField("Gradients", vtkm::cont::Field::ASSOC_POINTS);
const auto& field = block.GetField("Gradients", vtkm::cont::Field::Association::POINTS);
(void)field;
}
catch (vtkm::cont::ErrorBadValue)

3
examples/streamline/StreamLineUniformGrid.cxx
View File

@ -254,7 +254,8 @@ int main(int argc, char* argv[])
vtkm::cont::DataSet inDataSet;
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vdims);
inDataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
inDataSet.AddField(vtkm::cont::Field("vecData", vtkm::cont::Field::ASSOC_POINTS, fieldArray));
inDataSet.AddField(
vtkm::cont::Field("vecData", vtkm::cont::Field::Association::POINTS, fieldArray));
vtkm::cont::CellSetStructured<3> inCellSet("cells");
inCellSet.SetPointDimensions(vtkm::make_Vec(vdims[0], vdims[1], vdims[2]));

4
examples/tau_timing/TauTiming.cxx
View File

@ -149,7 +149,7 @@ vtkm::cont::DataSet CreateTestDataSet(vtkm::Id3 dims)
tangleFieldDispatcher.Invoke(vertexCountImplicitArray, scalarVar);
dataSet.AddField(
vtkm::cont::Field(std::string("scalar"), vtkm::cont::Field::ASSOC_POINTS, scalarVar));
vtkm::cont::Field(std::string("scalar"), vtkm::cont::Field::Association::POINTS, scalarVar));
return dataSet;
}
@ -456,7 +456,7 @@ int main(int argc, char** argv)
vtkm::cont::DataSet ds;
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vdims);
ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
ds.AddField(vtkm::cont::Field("vec", vtkm::cont::Field::ASSOC_POINTS, fieldArray));
ds.AddField(vtkm::cont::Field("vec", vtkm::cont::Field::Association::POINTS, fieldArray));
vtkm::cont::CellSetStructured<3> inCellSet("cells");
inCellSet.SetPointDimensions(vtkm::make_Vec(vdims[0], vdims[1], vdims[2]));

3
examples/unified_memory/UnifiedMemory.cu
View File

@ -107,7 +107,8 @@ vtkm::cont::DataSet MakeIsosurfaceTestDataSet(vtkm::Id3 dims)
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vdims, origin, spacing);
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
dataSet.AddField(vtkm::cont::Field("nodevar", vtkm::cont::Field::ASSOC_POINTS, fieldArray));
dataSet.AddField(
vtkm::cont::Field("nodevar", vtkm::cont::Field::Association::POINTS, fieldArray));
static const vtkm::IdComponent ndim = 3;
vtkm::cont::CellSetStructured<ndim> cellSet("cells");

4
vtkm/cont/CoordinateSystem.cxx
View File

@ -39,7 +39,7 @@ VTKM_CONT CoordinateSystem::CoordinateSystem()
VTKM_CONT CoordinateSystem::CoordinateSystem(
std::string name,
const vtkm::cont::ArrayHandleVirtualCoordinates::Superclass& data)
: Superclass(name, ASSOC_POINTS, data)
: Superclass(name, Association::POINTS, data)
{
}
@ -51,7 +51,7 @@ CoordinateSystem::CoordinateSystem(std::string name,
vtkm::Vec<vtkm::FloatDefault, 3> origin,
vtkm::Vec<vtkm::FloatDefault, 3> spacing)
: Superclass(name,
ASSOC_POINTS,
Association::POINTS,
vtkm::cont::ArrayHandleVirtualCoordinates(
vtkm::cont::ArrayHandleUniformPointCoordinates(dimensions, origin, spacing)))
{

4
vtkm/cont/CoordinateSystem.hxx
View File

@ -64,14 +64,14 @@ template <typename TypeList, typename StorageList>
VTKM_CONT CoordinateSystem::CoordinateSystem(
std::string name,
const vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList>& data)
: Superclass(name, ASSOC_POINTS, detail::MakeArrayHandleVirtualCoordinates(data))
: Superclass(name, Association::POINTS, detail::MakeArrayHandleVirtualCoordinates(data))
{
}
template <typename T, typename Storage>
VTKM_CONT CoordinateSystem::CoordinateSystem(std::string name,
const vtkm::cont::ArrayHandle<T, Storage>& data)
: Superclass(name, ASSOC_POINTS, vtkm::cont::ArrayHandleVirtualCoordinates(data))
: Superclass(name, Association::POINTS, vtkm::cont::ArrayHandleVirtualCoordinates(data))
{
}

7
vtkm/cont/DataSet.cxx
View File

@ -48,8 +48,7 @@ const vtkm::cont::Field& DataSet::GetField(vtkm::Id index) const
return this->Fields[static_cast<std::size_t>(index)];
}
vtkm::Id DataSet::GetFieldIndex(const std::string& name,
vtkm::cont::Field::AssociationEnum assoc) const
vtkm::Id DataSet::GetFieldIndex(const std::string& name, vtkm::cont::Field::Association assoc) const
{
bool found;
vtkm::Id index = this->FindFieldIndex(name, assoc, found);
@ -120,12 +119,12 @@ void DataSet::PrintSummary(std::ostream& out) const
}
vtkm::Id DataSet::FindFieldIndex(const std::string& name,
vtkm::cont::Field::AssociationEnum association,
vtkm::cont::Field::Association association,
bool& found) const
{
for (std::size_t index = 0; index < this->Fields.size(); ++index)
{
if ((association == vtkm::cont::Field::ASSOC_ANY ||
if ((association == vtkm::cont::Field::Association::ANY ||
association == this->Fields[index].GetAssociation()) &&
this->Fields[index].GetName() == name)
{

12
vtkm/cont/DataSet.h
View File

@ -49,7 +49,7 @@ public:
VTKM_CONT
bool HasField(const std::string& name,
vtkm::cont::Field::AssociationEnum assoc = vtkm::cont::Field::ASSOC_ANY) const
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY) const
{
bool found;
this->FindFieldIndex(name, assoc, found);
@ -59,12 +59,12 @@ public:
VTKM_CONT
vtkm::Id GetFieldIndex(
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc = vtkm::cont::Field::ASSOC_ANY) const;
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY) const;
VTKM_CONT
const vtkm::cont::Field& GetField(
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc = vtkm::cont::Field::ASSOC_ANY) const
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY) const
{
return this->GetField(this->GetFieldIndex(name, assoc));
}
@ -72,13 +72,13 @@ public:
VTKM_CONT
const vtkm::cont::Field& GetCellField(const std::string& name) const
{
return this->GetField(name, vtkm::cont::Field::ASSOC_CELL_SET);
return this->GetField(name, vtkm::cont::Field::Association::CELL_SET);
}
VTKM_CONT
const vtkm::cont::Field& GetPointField(const std::string& name) const
{
return this->GetField(name, vtkm::cont::Field::ASSOC_POINTS);
return this->GetField(name, vtkm::cont::Field::Association::POINTS);
}
VTKM_CONT
@ -174,7 +174,7 @@ private:
VTKM_CONT
vtkm::Id FindFieldIndex(const std::string& name,
vtkm::cont::Field::AssociationEnum association,
vtkm::cont::Field::Association association,
bool& found) const;
VTKM_CONT

24
vtkm/cont/DataSetFieldAdd.h
View File

@ -40,7 +40,7 @@ public:
const std::string& fieldName,
const vtkm::cont::DynamicArrayHandle& field)
{
dataSet.AddField(Field(fieldName, vtkm::cont::Field::ASSOC_POINTS, field));
dataSet.AddField(Field(fieldName, vtkm::cont::Field::Association::POINTS, field));
}
template <typename T, typename Storage>
@ -48,7 +48,7 @@ public:
const std::string& fieldName,
const vtkm::cont::ArrayHandle<T, Storage>& field)
{
dataSet.AddField(Field(fieldName, vtkm::cont::Field::ASSOC_POINTS, field));
dataSet.AddField(Field(fieldName, vtkm::cont::Field::Association::POINTS, field));
}
template <typename T>
@ -57,7 +57,7 @@ public:
const std::vector<T>& field)
{
dataSet.AddField(
make_Field(fieldName, vtkm::cont::Field::ASSOC_POINTS, field, vtkm::CopyFlag::On));
make_Field(fieldName, vtkm::cont::Field::Association::POINTS, field, vtkm::CopyFlag::On));
}
template <typename T>
@ -67,7 +67,7 @@ public:
const vtkm::Id& n)
{
dataSet.AddField(
make_Field(fieldName, vtkm::cont::Field::ASSOC_POINTS, field, n, vtkm::CopyFlag::On));
make_Field(fieldName, vtkm::cont::Field::Association::POINTS, field, n, vtkm::CopyFlag::On));
}
//Cell centered field
@ -77,7 +77,8 @@ public:
const vtkm::cont::DynamicArrayHandle& field,
const std::string& cellSetName)
{
dataSet.AddField(Field(fieldName, vtkm::cont::Field::ASSOC_CELL_SET, cellSetName, field));
dataSet.AddField(
Field(fieldName, vtkm::cont::Field::Association::CELL_SET, cellSetName, field));
}
template <typename T, typename Storage>
@ -86,7 +87,8 @@ public:
const vtkm::cont::ArrayHandle<T, Storage>& field,
const std::string& cellSetName)
{
dataSet.AddField(Field(fieldName, vtkm::cont::Field::ASSOC_CELL_SET, cellSetName, field));
dataSet.AddField(
Field(fieldName, vtkm::cont::Field::Association::CELL_SET, cellSetName, field));
}
template <typename T>
@ -96,7 +98,7 @@ public:
const std::string& cellSetName)
{
dataSet.AddField(make_Field(
fieldName, vtkm::cont::Field::ASSOC_CELL_SET, cellSetName, field, vtkm::CopyFlag::On));
fieldName, vtkm::cont::Field::Association::CELL_SET, cellSetName, field, vtkm::CopyFlag::On));
}
template <typename T>
@ -106,8 +108,12 @@ public:
const vtkm::Id& n,
const std::string& cellSetName)
{
dataSet.AddField(make_Field(
fieldName, vtkm::cont::Field::ASSOC_CELL_SET, cellSetName, field, n, vtkm::CopyFlag::On));
dataSet.AddField(make_Field(fieldName,
vtkm::cont::Field::Association::CELL_SET,
cellSetName,
field,
n,
vtkm::CopyFlag::On));
}
VTKM_CONT

10
vtkm/cont/Field.cxx
View File

@ -32,19 +32,19 @@ void Field::PrintSummary(std::ostream& out) const
out << " assoc= ";
switch (this->GetAssociation())
{
case ASSOC_ANY:
case Association::ANY:
out << "Any ";
break;
case ASSOC_WHOLE_MESH:
case Association::WHOLE_MESH:
out << "Mesh ";
break;
case ASSOC_POINTS:
case Association::POINTS:
out << "Points ";
break;
case ASSOC_CELL_SET:
case Association::CELL_SET:
out << "Cells ";
break;
case ASSOC_LOGICAL_DIM:
case Association::LOGICAL_DIM:
out << "LogicalDim ";
break;
}

70
vtkm/cont/Field.h
View File

@ -64,113 +64,113 @@ private:
class VTKM_CONT_EXPORT Field
{
public:
enum AssociationEnum
enum struct Association
{
ASSOC_ANY,
ASSOC_WHOLE_MESH,
ASSOC_POINTS,
ASSOC_CELL_SET,
ASSOC_LOGICAL_DIM
ANY,
WHOLE_MESH,
POINTS,
CELL_SET,
LOGICAL_DIM
};
/// constructors for points / whole mesh
VTKM_CONT
Field(std::string name, AssociationEnum association, const vtkm::cont::DynamicArrayHandle& data)
Field(std::string name, Association association, const vtkm::cont::DynamicArrayHandle& data)
: Name(name)
, Association(association)
, FieldAssociation(association)
, AssocCellSetName()
, AssocLogicalDim(-1)
, Data(data)
, Range()
, ModifiedFlag(true)
{
VTKM_ASSERT(this->Association == ASSOC_WHOLE_MESH || this->Association == ASSOC_POINTS);
VTKM_ASSERT(this->FieldAssociation == Association::WHOLE_MESH ||
this->FieldAssociation == Association::POINTS);
}
template <typename T, typename Storage>
VTKM_CONT Field(std::string name,
AssociationEnum association,
const ArrayHandle<T, Storage>& data)
VTKM_CONT Field(std::string name, Association association, const ArrayHandle<T, Storage>& data)
: Name(name)
, Association(association)
, FieldAssociation(association)
, AssocCellSetName()
, AssocLogicalDim(-1)
, Data(data)
, Range()
, ModifiedFlag(true)
{
VTKM_ASSERT((this->Association == ASSOC_WHOLE_MESH) || (this->Association == ASSOC_POINTS));
VTKM_ASSERT((this->FieldAssociation == Association::WHOLE_MESH) ||
(this->FieldAssociation == Association::POINTS));
}
/// constructors for cell set associations
VTKM_CONT
Field(std::string name,
AssociationEnum association,
Association association,
const std::string& cellSetName,
const vtkm::cont::DynamicArrayHandle& data)
: Name(name)
, Association(association)
, FieldAssociation(association)
, AssocCellSetName(cellSetName)
, AssocLogicalDim(-1)
, Data(data)
, Range()
, ModifiedFlag(true)
{
VTKM_ASSERT(this->Association == ASSOC_CELL_SET);
VTKM_ASSERT(this->FieldAssociation == Association::CELL_SET);
}
template <typename T, typename Storage>
VTKM_CONT Field(std::string name,
AssociationEnum association,
Association association,
const std::string& cellSetName,
const vtkm::cont::ArrayHandle<T, Storage>& data)
: Name(name)
, Association(association)
, FieldAssociation(association)
, AssocCellSetName(cellSetName)
, AssocLogicalDim(-1)
, Data(data)
, Range()
, ModifiedFlag(true)
{
VTKM_ASSERT(this->Association == ASSOC_CELL_SET);
VTKM_ASSERT(this->FieldAssociation == Association::CELL_SET);
}
/// constructors for logical dimension associations
VTKM_CONT
Field(std::string name,
AssociationEnum association,
Association association,
vtkm::IdComponent logicalDim,
const vtkm::cont::DynamicArrayHandle& data)
: Name(name)
, Association(association)
, FieldAssociation(association)
, AssocCellSetName()
, AssocLogicalDim(logicalDim)
, Data(data)
, Range()
, ModifiedFlag(true)
{
VTKM_ASSERT(this->Association == ASSOC_LOGICAL_DIM);
VTKM_ASSERT(this->FieldAssociation == Association::LOGICAL_DIM);
}
template <typename T, typename Storage>
VTKM_CONT Field(std::string name,
AssociationEnum association,
Association association,
vtkm::IdComponent logicalDim,
const vtkm::cont::ArrayHandle<T, Storage>& data)
: Name(name)
, Association(association)
, FieldAssociation(association)
, AssocLogicalDim(logicalDim)
, Data(data)
, Range()
, ModifiedFlag(true)
{
VTKM_ASSERT(this->Association == ASSOC_LOGICAL_DIM);
VTKM_ASSERT(this->FieldAssociation == Association::LOGICAL_DIM);
}
VTKM_CONT
Field()
: Name()
, Association(ASSOC_ANY)
, FieldAssociation(Association::ANY)
, AssocCellSetName()
, AssocLogicalDim()
, Data()
@ -190,7 +190,7 @@ public:
const std::string& GetName() const { return this->Name; }
VTKM_CONT
AssociationEnum GetAssociation() const { return this->Association; }
Association GetAssociation() const { return this->FieldAssociation; }
VTKM_CONT
std::string GetAssocCellSet() const { return this->AssocCellSetName; }
@ -279,7 +279,7 @@ public:
private:
std::string Name; ///< name of field
AssociationEnum Association;
Association FieldAssociation;
std::string AssocCellSetName; ///< only populate if assoc is cells
vtkm::IdComponent AssocLogicalDim; ///< only populate if assoc is logical dim
@ -314,7 +314,7 @@ void CastAndCall(const vtkm::cont::Field& field, Functor&& f, Args&&... args)
/// Convenience functions to build fields from C style arrays and std::vector
template <typename T>
vtkm::cont::Field make_Field(std::string name,
Field::AssociationEnum association,
Field::Association association,
const T* data,
vtkm::Id size,
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
@ -324,7 +324,7 @@ vtkm::cont::Field make_Field(std::string name,
template <typename T>
vtkm::cont::Field make_Field(std::string name,
Field::AssociationEnum association,
Field::Association association,
const std::vector<T>& data,
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
{
@ -333,7 +333,7 @@ vtkm::cont::Field make_Field(std::string name,
template <typename T>
vtkm::cont::Field make_Field(std::string name,
Field::AssociationEnum association,
Field::Association association,
const std::string& cellSetName,
const T* data,
vtkm::Id size,
@ -345,7 +345,7 @@ vtkm::cont::Field make_Field(std::string name,
template <typename T>
vtkm::cont::Field make_Field(std::string name,
Field::AssociationEnum association,
Field::Association association,
const std::string& cellSetName,
const std::vector<T>& data,
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
@ -356,7 +356,7 @@ vtkm::cont::Field make_Field(std::string name,
template <typename T>
vtkm::cont::Field make_Field(std::string name,
Field::AssociationEnum association,
Field::Association association,
vtkm::IdComponent logicalDim,
const T* data,
vtkm::Id size,
@ -368,7 +368,7 @@ vtkm::cont::Field make_Field(std::string name,
template <typename T>
vtkm::cont::Field make_Field(std::string name,
Field::AssociationEnum association,
Field::Association association,
vtkm::IdComponent logicalDim,
const std::vector<T>& data,
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)

4
vtkm/cont/FieldRangeCompute.cxx
View File

@ -31,7 +31,7 @@ namespace cont
VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc)
vtkm::cont::Field::Association assoc)
{
return vtkm::cont::detail::FieldRangeComputeImpl(
dataset, name, assoc, VTKM_DEFAULT_TYPE_LIST_TAG(), VTKM_DEFAULT_STORAGE_LIST_TAG());
@ -41,7 +41,7 @@ vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(const vtkm::cont::DataSet
VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(const vtkm::cont::MultiBlock& multiblock,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc)
vtkm::cont::Field::Association assoc)
{
return vtkm::cont::detail::FieldRangeComputeImpl(
multiblock, name, assoc, VTKM_DEFAULT_TYPE_LIST_TAG(), VTKM_DEFAULT_STORAGE_LIST_TAG());

12
vtkm/cont/FieldRangeCompute.h
View File

@ -45,13 +45,13 @@ VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(
const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc = vtkm::cont::Field::ASSOC_ANY);
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY);
template <typename TypeList, typename StorageList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(
const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList,
StorageList)
{
@ -65,7 +65,7 @@ template <typename TypeList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(
const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList)
{
VTKM_IS_LIST_TAG(TypeList);
@ -86,13 +86,13 @@ VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(
const vtkm::cont::MultiBlock& multiblock,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc = vtkm::cont::Field::ASSOC_ANY);
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY);
template <typename TypeList, typename StorageList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(
const vtkm::cont::MultiBlock& multiblock,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList,
StorageList)
{
@ -107,7 +107,7 @@ template <typename TypeList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeCompute(
const vtkm::cont::MultiBlock& multiblock,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList)
{
VTKM_IS_LIST_TAG(TypeList);

4
vtkm/cont/FieldRangeCompute.hxx
View File

@ -33,7 +33,7 @@ template <typename TypeList, typename StorageList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeComputeImpl(
const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList,
StorageList)
{
@ -55,7 +55,7 @@ template <typename TypeList, typename StorageList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeComputeImpl(
const vtkm::cont::MultiBlock& multiblock,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList,
StorageList)
{

9
vtkm/cont/FieldRangeGlobalCompute.cxx
View File

@ -41,10 +41,9 @@ namespace cont
//-----------------------------------------------------------------------------
VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(
const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc)
vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::Association assoc)
{
return detail::FieldRangeGlobalComputeImpl(
dataset, name, assoc, VTKM_DEFAULT_TYPE_LIST_TAG(), VTKM_DEFAULT_STORAGE_LIST_TAG());
@ -55,7 +54,7 @@ VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(
const vtkm::cont::MultiBlock& multiblock,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc)
vtkm::cont::Field::Association assoc)
{
return detail::FieldRangeGlobalComputeImpl(
multiblock, name, assoc, VTKM_DEFAULT_TYPE_LIST_TAG(), VTKM_DEFAULT_STORAGE_LIST_TAG());

12
vtkm/cont/FieldRangeGlobalCompute.h
View File

@ -43,13 +43,13 @@ VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(
const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc = vtkm::cont::Field::ASSOC_ANY);
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY);
template <typename TypeList, typename StorageList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(
const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList,
StorageList)
{
@ -63,7 +63,7 @@ template <typename TypeList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(
const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList)
{
VTKM_IS_LIST_TAG(TypeList);
@ -84,13 +84,13 @@ VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(
const vtkm::cont::MultiBlock& multiblock,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc = vtkm::cont::Field::ASSOC_ANY);
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY);
template <typename TypeList, typename StorageList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(
const vtkm::cont::MultiBlock& multiblock,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList,
StorageList)
{
@ -104,7 +104,7 @@ template <typename TypeList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalCompute(
const vtkm::cont::MultiBlock& multiblock,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList)
{
VTKM_IS_LIST_TAG(TypeList);

4
vtkm/cont/FieldRangeGlobalCompute.hxx
View File

@ -36,7 +36,7 @@ template <typename TypeList, typename StorageList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalComputeImpl(
const vtkm::cont::DataSet& dataset,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList,
StorageList)
{
@ -48,7 +48,7 @@ template <typename TypeList, typename StorageList>
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeGlobalComputeImpl(
const vtkm::cont::MultiBlock& multiblock,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
TypeList,
StorageList)
{

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

@ -314,13 +314,13 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DRegularDataSet0()
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
//Set point scalar
dataSet.AddField(
make_Field("pointvar", vtkm::cont::Field::ASSOC_POINTS, vars, nVerts, vtkm::CopyFlag::On));
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::ASSOC_CELL_SET, "cells", cellvar, 4, vtkm::CopyFlag::On));
"cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 4, vtkm::CopyFlag::On));
static constexpr vtkm::IdComponent dim = 3;
vtkm::cont::CellSetStructured<dim> cellSet("cells");
@ -341,13 +341,13 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DRegularDataSet1()
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
//Set point scalar
dataSet.AddField(
make_Field("pointvar", vtkm::cont::Field::ASSOC_POINTS, vars, nVerts, vtkm::CopyFlag::On));
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::ASSOC_CELL_SET, "cells", cellvar, 1, vtkm::CopyFlag::On));
"cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 1, vtkm::CopyFlag::On));
static constexpr vtkm::IdComponent dim = 3;
vtkm::cont::CellSetStructured<dim> cellSet("cells");
@ -597,13 +597,13 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet1()
dataSet.AddCellSet(cellSet);
//Set point scalar
dataSet.AddField(
make_Field("pointvar", vtkm::cont::Field::ASSOC_POINTS, vars, nVerts, vtkm::CopyFlag::On));
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::ASSOC_CELL_SET, "cells", cellvar, 2, vtkm::CopyFlag::On));
"cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 2, vtkm::CopyFlag::On));
return dataSet;
}
@ -630,13 +630,13 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet2()
vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On));
//Set point scalar
dataSet.AddField(
make_Field("pointvar", vtkm::cont::Field::ASSOC_POINTS, vars, nVerts, vtkm::CopyFlag::On));
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::ASSOC_CELL_SET, "cells", cellvar, 1, vtkm::CopyFlag::On));
"cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 1, vtkm::CopyFlag::On));
vtkm::cont::CellSetExplicit<> cellSet("cells");
vtkm::Vec<vtkm::Id, 8> ids;
@ -686,13 +686,13 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet4()
vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On));
//Set point scalar
dataSet.AddField(
make_Field("pointvar", vtkm::cont::Field::ASSOC_POINTS, vars, nVerts, vtkm::CopyFlag::On));
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::ASSOC_CELL_SET, "cells", cellvar, 2, vtkm::CopyFlag::On));
"cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 2, vtkm::CopyFlag::On));
vtkm::cont::CellSetExplicit<> cellSet("cells");
vtkm::Vec<vtkm::Id, 8> ids;
@ -739,13 +739,13 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet3()
vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On));
//Set point scalar
dataSet.AddField(
make_Field("pointvar", vtkm::cont::Field::ASSOC_POINTS, vars, nVerts, vtkm::CopyFlag::On));
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::ASSOC_CELL_SET, "cells", cellvar, 1, vtkm::CopyFlag::On));
"cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellvar, 1, vtkm::CopyFlag::On));
vtkm::cont::CellSetExplicit<> cellSet("cells");
vtkm::Vec<vtkm::Id, 4> ids;
@ -790,14 +790,18 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSet5()
vtkm::cont::make_CoordinateSystem("coordinates", coordinates, nVerts, vtkm::CopyFlag::On));
//Set point scalar
dataSet.AddField(
make_Field("pointvar", vtkm::cont::Field::ASSOC_POINTS, vars, nVerts, vtkm::CopyFlag::On));
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::ASSOC_CELL_SET, "cells", cellvar, nCells, vtkm::CopyFlag::On));
dataSet.AddField(make_Field("cellvar",
vtkm::cont::Field::Association::CELL_SET,
"cells",
cellvar,
nCells,
vtkm::CopyFlag::On));
vtkm::cont::CellSetExplicit<> cellSet("cells");
vtkm::Vec<vtkm::Id, 8> ids;

5
vtkm/cont/testing/TestingComputeRange.h
View File

@ -60,7 +60,8 @@ private:
const vtkm::Id nvals = 11;
T data[nvals] = { 1, 2, 3, 4, 5, -5, -4, -3, -2, -1, 0 };
std::random_shuffle(data, data + nvals);
auto field = vtkm::cont::make_Field("TestField", vtkm::cont::Field::ASSOC_POINTS, data, nvals);
auto field =
vtkm::cont::make_Field("TestField", vtkm::cont::Field::Association::POINTS, data, nvals);
vtkm::Range result;
field.GetRange(&result);
@ -85,7 +86,7 @@ private:
}
}
auto field =
vtkm::cont::make_Field("TestField", vtkm::cont::Field::ASSOC_POINTS, fieldData, nvals);
vtkm::cont::make_Field("TestField", vtkm::cont::Field::Association::POINTS, fieldData, nvals);
vtkm::Range result[NumberOfComponents];
field.GetRange(result, CustomTypeList(), VTKM_DEFAULT_STORAGE_LIST_TAG());

10
vtkm/cont/testing/TestingDataSetExplicit.h
View File

@ -74,22 +74,22 @@ private:
// test various field-getting methods and associations
const vtkm::cont::Field& f1 = ds.GetField("pointvar");
VTKM_TEST_ASSERT(f1.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS,
"Association of 'pointvar' was not ASSOC_POINTS");
VTKM_TEST_ASSERT(f1.GetAssociation() == vtkm::cont::Field::Association::POINTS,
"Association of 'pointvar' was not Association::POINTS");
try
{
//const vtkm::cont::Field &f2 =
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
ds.GetField("cellvar", vtkm::cont::Field::Association::CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
VTKM_TEST_FAIL("Failed to get field 'cellvar' with Association::CELL_SET.");
}
try
{
//const vtkm::cont::Field &f3 =
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_POINTS);
ds.GetField("cellvar", vtkm::cont::Field::Association::POINTS);
VTKM_TEST_FAIL("Failed to get expected error for association mismatch.");
}
catch (vtkm::cont::ErrorBadValue& error)

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

@ -62,16 +62,16 @@ void ValidateDataSet(const vtkm::cont::DataSet& ds,
// test various field-getting methods and associations
try
{
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
ds.GetField("cellvar", vtkm::cont::Field::Association::CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
VTKM_TEST_FAIL("Failed to get field 'cellvar' with Association::CELL_SET.");
}
try
{
ds.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
ds.GetField("pointvar", vtkm::cont::Field::Association::POINTS);
}
catch (...)
{

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

@ -52,16 +52,16 @@ void ValidateDataSet(const vtkm::cont::DataSet& ds,
// test various field-getting methods and associations
try
{
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
ds.GetField("cellvar", vtkm::cont::Field::Association::CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
VTKM_TEST_FAIL("Failed to get field 'cellvar' with Association::CELL_SET.");
}
try
{
ds.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
ds.GetField("pointvar", vtkm::cont::Field::Association::POINTS);
}
catch (...)
{

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

@ -53,16 +53,16 @@ void ValidateDataSet(const vtkm::cont::DataSet& ds,
// test various field-getting methods and associations
try
{
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
ds.GetField("cellvar", vtkm::cont::Field::Association::CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
VTKM_TEST_FAIL("Failed to get field 'cellvar' with Association::CELL_SET.");
}
try
{
ds.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
ds.GetField("pointvar", vtkm::cont::Field::Association::POINTS);
}
catch (...)
{

12
vtkm/cont/testing/UnitTestDataSetRectilinear.cxx
View File

@ -62,16 +62,16 @@ static void TwoDimRectilinearTest()
// test various field-getting methods and associations
try
{
dataSet.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
dataSet.GetField("cellvar", vtkm::cont::Field::Association::CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
VTKM_TEST_FAIL("Failed to get field 'cellvar' with Association::CELL_SET.");
}
try
{
dataSet.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
dataSet.GetField("pointvar", vtkm::cont::Field::Association::POINTS);
}
catch (...)
{
@ -149,16 +149,16 @@ static void ThreeDimRectilinearTest()
try
{
dataSet.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
dataSet.GetField("cellvar", vtkm::cont::Field::Association::CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
VTKM_TEST_FAIL("Failed to get field 'cellvar' with Association::CELL_SET.");
}
try
{
dataSet.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
dataSet.GetField("pointvar", vtkm::cont::Field::Association::POINTS);
}
catch (...)
{

12
vtkm/cont/testing/UnitTestDataSetUniform.cxx
View File

@ -65,16 +65,16 @@ static void TwoDimUniformTest()
// test various field-getting methods and associations
try
{
dataSet.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
dataSet.GetField("cellvar", vtkm::cont::Field::Association::CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
VTKM_TEST_FAIL("Failed to get field 'cellvar' with Association::CELL_SET.");
}
try
{
dataSet.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
dataSet.GetField("pointvar", vtkm::cont::Field::Association::POINTS);
}
catch (...)
{
@ -159,16 +159,16 @@ static void ThreeDimUniformTest()
try
{
dataSet.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
dataSet.GetField("cellvar", vtkm::cont::Field::Association::CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
VTKM_TEST_FAIL("Failed to get field 'cellvar' with Association::CELL_SET.");
}
try
{
dataSet.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
dataSet.GetField("pointvar", vtkm::cont::Field::Association::POINTS);
}
catch (...)
{

2
vtkm/filter/CellAverage.hxx
View File

@ -68,7 +68,7 @@ inline VTKM_CONT vtkm::cont::DataSet CellAverage::DoExecute(
}
return internal::CreateResult(
input, outArray, outputName, vtkm::cont::Field::ASSOC_CELL_SET, cellSet.GetName());
input, outArray, outputName, vtkm::cont::Field::Association::CELL_SET, cellSet.GetName());
}
}
} // namespace vtkm::filter

3
vtkm/filter/CellMeasures.hxx
View File

@ -61,7 +61,8 @@ inline VTKM_CONT vtkm::cont::DataSet CellMeasures<IntegrationType>::DoExecute(
// Default name is name of input.
outputName = "measure";
}
result = internal::CreateResult(input, outArray, outputName, vtkm::cont::Field::ASSOC_CELL_SET);
result =
internal::CreateResult(input, outArray, outputName, vtkm::cont::Field::Association::CELL_SET);
return result;
}

10
vtkm/filter/CrossProduct.h
View File

@ -41,13 +41,13 @@ public:
VTKM_CONT
void SetPrimaryField(
const std::string& name,
vtkm::cont::Field::AssociationEnum association = vtkm::cont::Field::ASSOC_ANY)
vtkm::cont::Field::Association association = vtkm::cont::Field::Association::ANY)
{
this->SetActiveField(name, association);
}
VTKM_CONT const std::string& GetPrimaryFieldName() const { return this->SecondaryFieldName; }
VTKM_CONT vtkm::cont::Field::AssociationEnum GetPrimaryFieldAssociation() const
VTKM_CONT vtkm::cont::Field::Association GetPrimaryFieldAssociation() const
{
return this->SecondaryFieldAssociation;
}
@ -86,14 +86,14 @@ public:
VTKM_CONT
void SetSecondaryField(
const std::string& name,
vtkm::cont::Field::AssociationEnum association = vtkm::cont::Field::ASSOC_ANY)
vtkm::cont::Field::Association association = vtkm::cont::Field::Association::ANY)
{
this->SecondaryFieldName = name;
this->SecondaryFieldAssociation = association;
}
VTKM_CONT const std::string& GetSecondaryFieldName() const { return this->GetActiveFieldName(); }
VTKM_CONT vtkm::cont::Field::AssociationEnum GetSecondaryFieldAssociation() const
VTKM_CONT vtkm::cont::Field::Association GetSecondaryFieldAssociation() const
{
return this->GetActiveFieldAssociation();
}
@ -146,7 +146,7 @@ public:
private:
std::string SecondaryFieldName;
vtkm::cont::Field::AssociationEnum SecondaryFieldAssociation;
vtkm::cont::Field::Association SecondaryFieldAssociation;
bool UseCoordinateSystemAsSecondaryField;
vtkm::Id SecondaryCoordinateSystemIndex;
};

2
vtkm/filter/CrossProduct.hxx
View File

@ -51,7 +51,7 @@ struct CrossProductFunctor
inline VTKM_CONT CrossProduct::CrossProduct()
: vtkm::filter::FilterField<CrossProduct>()
, SecondaryFieldName()
, SecondaryFieldAssociation(vtkm::cont::Field::ASSOC_ANY)
, SecondaryFieldAssociation(vtkm::cont::Field::Association::ANY)
, UseCoordinateSystemAsSecondaryField(false)
, SecondaryCoordinateSystemIndex(0)
{

10
vtkm/filter/DotProduct.h
View File

@ -41,13 +41,13 @@ public:
VTKM_CONT
void SetPrimaryField(
const std::string& name,
vtkm::cont::Field::AssociationEnum association = vtkm::cont::Field::ASSOC_ANY)
vtkm::cont::Field::Association association = vtkm::cont::Field::Association::ANY)
{
this->SetActiveField(name, association);
}
VTKM_CONT const std::string& GetPrimaryFieldName() const { return this->SecondaryFieldName; }
VTKM_CONT vtkm::cont::Field::AssociationEnum GetPrimaryFieldAssociation() const
VTKM_CONT vtkm::cont::Field::Association GetPrimaryFieldAssociation() const
{
return this->SecondaryFieldAssociation;
}
@ -86,14 +86,14 @@ public:
VTKM_CONT
void SetSecondaryField(
const std::string& name,
vtkm::cont::Field::AssociationEnum association = vtkm::cont::Field::ASSOC_ANY)
vtkm::cont::Field::Association association = vtkm::cont::Field::Association::ANY)
{
this->SecondaryFieldName = name;
this->SecondaryFieldAssociation = association;
}
VTKM_CONT const std::string& GetSecondaryFieldName() const { return this->GetActiveFieldName(); }
VTKM_CONT vtkm::cont::Field::AssociationEnum GetSecondaryFieldAssociation() const
VTKM_CONT vtkm::cont::Field::Association GetSecondaryFieldAssociation() const
{
return this->GetActiveFieldAssociation();
}
@ -146,7 +146,7 @@ public:
private:
std::string SecondaryFieldName;
vtkm::cont::Field::AssociationEnum SecondaryFieldAssociation;
vtkm::cont::Field::Association SecondaryFieldAssociation;
bool UseCoordinateSystemAsSecondaryField;
vtkm::Id SecondaryCoordinateSystemIndex;
};

2
vtkm/filter/DotProduct.hxx
View File

@ -52,7 +52,7 @@ struct DotProductFunctor
inline VTKM_CONT DotProduct::DotProduct()
: vtkm::filter::FilterField<DotProduct>()
, SecondaryFieldName()
, SecondaryFieldAssociation(vtkm::cont::Field::ASSOC_ANY)
, SecondaryFieldAssociation(vtkm::cont::Field::Association::ANY)
, UseCoordinateSystemAsSecondaryField(false)
, SecondaryCoordinateSystemIndex(0)
{

2
vtkm/filter/ExternalFaces.hxx
View File

@ -84,7 +84,7 @@ inline VTKM_CONT vtkm::cont::DataSet ExternalFaces::DoExecute(
for (vtkm::Id fieldIdx = 0; fieldIdx < numFields && !hasCellFields; ++fieldIdx)
{
auto f = input.GetField(fieldIdx);
if (f.GetAssociation() == vtkm::cont::Field::ASSOC_CELL_SET)
if (f.GetAssociation() == vtkm::cont::Field::Association::CELL_SET)
{
hasCellFields = true;
}

10
vtkm/filter/FieldMetadata.h
View File

@ -35,7 +35,7 @@ public:
VTKM_CONT
FieldMetadata()
: Name()
, Association(vtkm::cont::Field::ASSOC_ANY)
, Association(vtkm::cont::Field::Association::ANY)
, CellSetName()
{
}
@ -57,16 +57,16 @@ public:
}
VTKM_CONT
bool IsPointField() const { return this->Association == vtkm::cont::Field::ASSOC_POINTS; }
bool IsPointField() const { return this->Association == vtkm::cont::Field::Association::POINTS; }
VTKM_CONT
bool IsCellField() const { return this->Association == vtkm::cont::Field::ASSOC_CELL_SET; }
bool IsCellField() const { return this->Association == vtkm::cont::Field::Association::CELL_SET; }
VTKM_CONT
const std::string& GetName() const { return this->Name; }
VTKM_CONT
vtkm::cont::Field::AssociationEnum GetAssociation() const { return this->Association; }
vtkm::cont::Field::Association GetAssociation() const { return this->Association; }
VTKM_CONT
const std::string& GetCellSetName() const { return this->CellSetName; }
@ -102,7 +102,7 @@ public:
private:
std::string Name; ///< name of field
vtkm::cont::Field::AssociationEnum Association;
vtkm::cont::Field::Association Association;
std::string CellSetName; ///< only populate if assoc is cells
};
}

45
vtkm/filter/FieldSelection.h
View File

@ -60,7 +60,7 @@ public:
FieldSelection(const std::string& field, ModeEnum mode = MODE_SELECT)
: Mode(mode)
{
this->AddField(field, vtkm::cont::Field::ASSOC_ANY);
this->AddField(field, vtkm::cont::Field::Association::ANY);
}
/// Use this constructor to create a field selection given a single field name
@ -71,16 +71,16 @@ public:
FieldSelection(const char* field, ModeEnum mode = MODE_SELECT)
: Mode(mode)
{
this->AddField(field, vtkm::cont::Field::ASSOC_ANY);
this->AddField(field, vtkm::cont::Field::Association::ANY);
}
/// Use this constructor to create a field selection given a single name and association.
/// \code{cpp}
/// FieldSelection("field_name", vtkm::cont::Field::ASSOC_POINTS)
/// FieldSelection("field_name", vtkm::cont::Field::Association::POINTS)
/// \endcode{cpp}
VTKM_CONT
FieldSelection(const std::string& field,
vtkm::cont::Field::AssociationEnum association,
vtkm::cont::Field::Association association,
ModeEnum mode = MODE_SELECT)
: Mode(mode)
{
@ -97,21 +97,21 @@ public:
{
for (const std::string& afield : fields)
{
this->AddField(afield, vtkm::cont::Field::ASSOC_ANY);
this->AddField(afield, vtkm::cont::Field::Association::ANY);
}
}
/// Use this constructor create a field selection given the field names and
/// associations e.g.
/// @code{cpp}
/// using pair_type = std::pair<std::string, vtkm::cont::Field::AssociationEnum>;
/// using pair_type = std::pair<std::string, vtkm::cont::Field::Association>;
/// FieldSelection({
/// pair_type{"field_one", vtkm::cont::Field::ASSOC_POINTS},
/// pair_type{"field_two", vtkm::cont::Field::ASSOC_CELL_SET} });
/// pair_type{"field_one", vtkm::cont::Field::Association::POINTS},
/// pair_type{"field_two", vtkm::cont::Field::Association::CELL_SET} });
/// @endcode
VTKM_CONT
FieldSelection(
std::initializer_list<std::pair<std::string, vtkm::cont::Field::AssociationEnum>> fields,
std::initializer_list<std::pair<std::string, vtkm::cont::Field::Association>> fields,
ModeEnum mode = MODE_SELECT)
: Mode(mode)
{
@ -124,14 +124,14 @@ public:
/// Use this constructor create a field selection given the field names and
/// associations e.g.
/// @code{cpp}
/// using pair_type = vtkm::Pair<std::string, vtkm::cont::Field::AssociationEnum>;
/// using pair_type = vtkm::Pair<std::string, vtkm::cont::Field::Association>;
/// FieldSelection({
/// pair_type{"field_one", vtkm::cont::Field::ASSOC_POINTS},
/// pair_type{"field_two", vtkm::cont::Field::ASSOC_CELL_SET} });
/// pair_type{"field_one", vtkm::cont::Field::Association::POINTS},
/// pair_type{"field_two", vtkm::cont::Field::Association::CELL_SET} });
/// @endcode
VTKM_CONT
FieldSelection(
std::initializer_list<vtkm::Pair<std::string, vtkm::cont::Field::AssociationEnum>> fields,
std::initializer_list<vtkm::Pair<std::string, vtkm::cont::Field::Association>> fields,
ModeEnum mode = MODE_SELECT)
: Mode(mode)
{
@ -154,7 +154,7 @@ public:
bool IsFieldSelected(
const std::string& name,
vtkm::cont::Field::AssociationEnum association = vtkm::cont::Field::ASSOC_ANY) const
vtkm::cont::Field::Association association = vtkm::cont::Field::Association::ANY) const
{
switch (this->Mode)
{
@ -184,7 +184,7 @@ public:
VTKM_CONT
void AddField(const std::string& fieldName,
vtkm::cont::Field::AssociationEnum association = vtkm::cont::Field::ASSOC_ANY)
vtkm::cont::Field::Association association = vtkm::cont::Field::Association::ANY)
{
this->Fields.insert(Field(fieldName, association));
}
@ -200,20 +200,21 @@ public:
return this->HasField(inputField.GetName(), inputField.GetAssociation());
}
bool HasField(const std::string& name,
vtkm::cont::Field::AssociationEnum association = vtkm::cont::Field::ASSOC_ANY) const
bool HasField(
const std::string& name,
vtkm::cont::Field::Association association = vtkm::cont::Field::Association::ANY) const
{
if (this->Fields.find(Field(name, association)) != this->Fields.end())
{
return true;
}
// if not exact match, let's lookup for ASSOC_ANY.
// if not exact match, let's lookup for Association::ANY.
for (const auto& aField : this->Fields)
{
if (aField.Name == name)
{
if (aField.Association == vtkm::cont::Field::ASSOC_ANY ||
association == vtkm::cont::Field::ASSOC_ANY)
if (aField.Association == vtkm::cont::Field::Association::ANY ||
association == vtkm::cont::Field::Association::ANY)
{
return true;
}
@ -236,9 +237,9 @@ private:
struct Field
{
std::string Name;
vtkm::cont::Field::AssociationEnum Association;
vtkm::cont::Field::Association Association;
Field() = default;
Field(const std::string& name, vtkm::cont::Field::AssociationEnum assoc)
Field(const std::string& name, vtkm::cont::Field::Association assoc)
: Name(name)
, Association(assoc)
{

4
vtkm/filter/FieldToColors.hxx
View File

@ -219,7 +219,7 @@ inline VTKM_CONT vtkm::cont::DataSet FieldToColors::DoExecute(
{
throw vtkm::cont::ErrorFilterExecution("Unsupported input mode.");
}
outField = vtkm::cont::Field(outputName, vtkm::cont::Field::ASSOC_POINTS, output);
outField = vtkm::cont::Field(outputName, vtkm::cont::Field::Association::POINTS, output);
}
else
{
@ -267,7 +267,7 @@ inline VTKM_CONT vtkm::cont::DataSet FieldToColors::DoExecute(
{
throw vtkm::cont::ErrorFilterExecution("Unsupported input mode.");
}
outField = vtkm::cont::Field(outputName, vtkm::cont::Field::ASSOC_POINTS, output);
outField = vtkm::cont::Field(outputName, vtkm::cont::Field::Association::POINTS, output);
}

2
vtkm/filter/Filter.h
View File

@ -226,7 +226,7 @@ public:
VTKM_CONT
void SetFieldsToPass(
const std::string& fieldname,
vtkm::cont::Field::AssociationEnum association,
vtkm::cont::Field::Association association,
vtkm::filter::FieldSelection::ModeEnum mode = vtkm::filter::FieldSelection::MODE_SELECT)
{
this->SetFieldsToPass({ fieldname, association }, mode);

10
vtkm/filter/FilterDataSet.h
View File

@ -61,11 +61,11 @@ public:
/// These are provided to satisfy the Filter API requirements.
//From the field we can extract the association component
// ASSOC_ANY -> unable to map
// ASSOC_WHOLE_MESH -> (I think this is points)
// ASSOC_POINTS -> map using point mapping
// ASSOC_CELL_SET -> how do we map this?
// ASSOC_LOGICAL_DIM -> unable to map?
// Association::ANY -> unable to map
// Association::WHOLE_MESH -> (I think this is points)
// Association::POINTS -> map using point mapping
// Association::CELL_SET -> how do we map this?
// Association::LOGICAL_DIM -> unable to map?
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,

19
vtkm/filter/FilterDataSetWithField.h
View File

@ -62,15 +62,16 @@ public:
/// Choose the field to operate on. Note, if
/// `this->UseCoordinateSystemAsField` is true, then the active field is not used.
VTKM_CONT
void SetActiveField(const std::string& name,
vtkm::cont::Field::AssociationEnum association = vtkm::cont::Field::ASSOC_ANY)
void SetActiveField(
const std::string& name,
vtkm::cont::Field::Association association = vtkm::cont::Field::Association::ANY)
{
this->ActiveFieldName = name;
this->ActiveFieldAssociation = association;
}
VTKM_CONT const std::string& GetActiveFieldName() const { return this->ActiveFieldName; }
VTKM_CONT vtkm::cont::Field::AssociationEnum GetActiveFieldAssociation() const
VTKM_CONT vtkm::cont::Field::Association GetActiveFieldAssociation() const
{
return this->ActiveFieldAssociation;
}
@ -86,11 +87,11 @@ public:
//@}
//From the field we can extract the association component
// ASSOC_ANY -> unable to map
// ASSOC_WHOLE_MESH -> (I think this is points)
// ASSOC_POINTS -> map using point mapping
// ASSOC_CELL_SET -> how do we map this?
// ASSOC_LOGICAL_DIM -> unable to map?
// Association::ANY -> unable to map
// Association::WHOLE_MESH -> (I think this is points)
// Association::POINTS -> map using point mapping
// Association::CELL_SET -> how do we map this?
// Association::LOGICAL_DIM -> unable to map?
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
@ -119,7 +120,7 @@ private:
vtkm::Id CellSetIndex;
vtkm::Id CoordinateSystemIndex;
std::string ActiveFieldName;
vtkm::cont::Field::AssociationEnum ActiveFieldAssociation;
vtkm::cont::Field::Association ActiveFieldAssociation;
bool UseCoordinateSystemAsField;
friend class vtkm::filter::Filter<Derived>;

2
vtkm/filter/FilterDataSetWithField.hxx
View File

@ -44,7 +44,7 @@ inline VTKM_CONT FilterDataSetWithField<Derived>::FilterDataSetWithField()
, CellSetIndex(0)
, CoordinateSystemIndex(0)
, ActiveFieldName()
, ActiveFieldAssociation(vtkm::cont::Field::ASSOC_ANY)
, ActiveFieldAssociation(vtkm::cont::Field::Association::ANY)
, UseCoordinateSystemAsField(false)
{
}

9
vtkm/filter/FilterField.h
View File

@ -55,15 +55,16 @@ public:
/// Choose the field to operate on. Note, if
/// `this->UseCoordinateSystemAsField` is true, then the active field is not used.
VTKM_CONT
void SetActiveField(const std::string& name,
vtkm::cont::Field::AssociationEnum association = vtkm::cont::Field::ASSOC_ANY)
void SetActiveField(
const std::string& name,
vtkm::cont::Field::Association association = vtkm::cont::Field::Association::ANY)
{
this->ActiveFieldName = name;
this->ActiveFieldAssociation = association;
}
VTKM_CONT const std::string& GetActiveFieldName() const { return this->ActiveFieldName; }
VTKM_CONT vtkm::cont::Field::AssociationEnum GetActiveFieldAssociation() const
VTKM_CONT vtkm::cont::Field::Association GetActiveFieldAssociation() const
{
return this->ActiveFieldAssociation;
}
@ -111,7 +112,7 @@ private:
std::string OutputFieldName;
vtkm::Id CoordinateSystemIndex;
std::string ActiveFieldName;
vtkm::cont::Field::AssociationEnum ActiveFieldAssociation;
vtkm::cont::Field::Association ActiveFieldAssociation;
bool UseCoordinateSystemAsField;
friend class vtkm::filter::Filter<Derived>;

2
vtkm/filter/FilterField.hxx
View File

@ -42,7 +42,7 @@ inline VTKM_CONT FilterField<Derived>::FilterField()
: OutputFieldName()
, CoordinateSystemIndex(0)
, ActiveFieldName()
, ActiveFieldAssociation(vtkm::cont::Field::ASSOC_ANY)
, ActiveFieldAssociation(vtkm::cont::Field::Association::ANY)
, UseCoordinateSystemAsField(false)
{
}

11
vtkm/filter/Gradient.hxx
View File

@ -30,10 +30,11 @@ template <typename HandleType>
inline void add_field(vtkm::cont::DataSet& result,
const HandleType& handle,
const std::string name,
vtkm::cont::Field::AssociationEnum assoc,
vtkm::cont::Field::Association assoc,
const std::string& cellsetname)
{
if ((assoc == vtkm::cont::Field::ASSOC_WHOLE_MESH) || (assoc == vtkm::cont::Field::ASSOC_POINTS))
if ((assoc == vtkm::cont::Field::Association::WHOLE_MESH) ||
(assoc == vtkm::cont::Field::Association::POINTS))
{
vtkm::cont::Field field(name, assoc, handle);
result.AddField(field);
@ -132,9 +133,9 @@ inline vtkm::cont::DataSet Gradient::DoExecute(
constexpr bool isVector = std::is_same<typename vtkm::VecTraits<T>::HasMultipleComponents,
vtkm::VecTraitsTagMultipleComponents>::value;
vtkm::cont::Field::AssociationEnum fieldAssociation(this->ComputePointGradient
? vtkm::cont::Field::ASSOC_POINTS
: vtkm::cont::Field::ASSOC_CELL_SET);
vtkm::cont::Field::Association fieldAssociation(this->ComputePointGradient
? vtkm::cont::Field::Association::POINTS
: vtkm::cont::Field::Association::CELL_SET);
vtkm::cont::DataSet result =
internal::CreateResult(input, outArray, outputName, fieldAssociation, cells.GetName());

4
vtkm/filter/Histogram.hxx
View File

@ -222,7 +222,7 @@ inline VTKM_CONT vtkm::cont::DataSet Histogram::DoExecute(
this->BinDelta = static_cast<vtkm::Float64>(delta);
vtkm::cont::DataSet output;
vtkm::cont::Field rfield(
this->GetOutputFieldName(), vtkm::cont::Field::ASSOC_WHOLE_MESH, binArray);
this->GetOutputFieldName(), vtkm::cont::Field::Association::WHOLE_MESH, binArray);
output.AddField(rfield);
return output;
}
@ -264,7 +264,7 @@ inline VTKM_CONT void Histogram::PostExecute(const vtkm::cont::MultiBlock&,
vtkm::cont::DataSet output;
vtkm::cont::Field rfield(
this->GetOutputFieldName(), vtkm::cont::Field::ASSOC_WHOLE_MESH, helper.ReduceAll());
this->GetOutputFieldName(), vtkm::cont::Field::Association::WHOLE_MESH, helper.ReduceAll());
output.AddField(rfield);
result = vtkm::cont::MultiBlock(output);

5
vtkm/filter/MarchingCubes.hxx
View File

@ -128,7 +128,7 @@ inline VTKM_CONT vtkm::cont::DataSet MarchingCubes::DoExecute(
for (vtkm::Id fieldIdx = 0; fieldIdx < numFields && !hasCellFields; ++fieldIdx)
{
auto f = input.GetField(fieldIdx);
if (f.GetAssociation() == vtkm::cont::Field::ASSOC_CELL_SET)
if (f.GetAssociation() == vtkm::cont::Field::Association::CELL_SET)
{
hasCellFields = true;
}
@ -195,7 +195,8 @@ inline VTKM_CONT vtkm::cont::DataSet MarchingCubes::DoExecute(
smooth.Run(outputCells, faceNormals, normals, device);
}
vtkm::cont::Field normalField(this->NormalArrayName, vtkm::cont::Field::ASSOC_POINTS, normals);
vtkm::cont::Field normalField(
this->NormalArrayName, vtkm::cont::Field::Association::POINTS, normals);
output.AddField(normalField);
}

2
vtkm/filter/NDEntropy.hxx
View File

@ -58,7 +58,7 @@ inline VTKM_CONT vtkm::cont::DataSet NDEntropy::DoExecute(
vtkm::Float64 entropy = ndEntropy.Run(device);
vtkm::cont::DataSet outputData;
outputData.AddField(vtkm::cont::make_Field(
"Entropy", vtkm::cont::Field::ASSOC_POINTS, &entropy, 1, vtkm::CopyFlag::On));
"Entropy", vtkm::cont::Field::Association::POINTS, &entropy, 1, vtkm::CopyFlag::On));
return outputData;
}

5
vtkm/filter/NDHistogram.hxx
View File

@ -80,9 +80,10 @@ inline VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(
for (size_t i = 0; i < binIds.size(); i++)
{
outputData.AddField(
vtkm::cont::Field(FieldNames[i], vtkm::cont::Field::ASSOC_POINTS, binIds[i]));
vtkm::cont::Field(FieldNames[i], vtkm::cont::Field::Association::POINTS, binIds[i]));
}
outputData.AddField(vtkm::cont::Field("Frequency", vtkm::cont::Field::ASSOC_POINTS, freqs));
outputData.AddField(
vtkm::cont::Field("Frequency", vtkm::cont::Field::Association::POINTS, freqs));
return outputData;
}

2
vtkm/filter/PointAverage.hxx
View File

@ -68,7 +68,7 @@ inline VTKM_CONT vtkm::cont::DataSet PointAverage::DoExecute(
}
return internal::CreateResult(
input, outArray, outputName, vtkm::cont::Field::ASSOC_POINTS, cellSet.GetName());
input, outArray, outputName, vtkm::cont::Field::Association::POINTS, cellSet.GetName());
}
}
} // namespace vtkm::filter

4
vtkm/filter/Probe.hxx
View File

@ -50,9 +50,9 @@ VTKM_CONT inline vtkm::cont::DataSet Probe::DoExecute(
auto hcf = this->Worklet.GetHiddenCellsField(
vtkm::filter::ApplyPolicy(output.GetCellSet(), policy), device);
output.AddField(vtkm::cont::Field("HIDDEN", vtkm::cont::Field::ASSOC_POINTS, hpf));
output.AddField(vtkm::cont::Field("HIDDEN", vtkm::cont::Field::Association::POINTS, hpf));
output.AddField(vtkm::cont::Field(
"HIDDEN", vtkm::cont::Field::ASSOC_CELL_SET, output.GetCellSet().GetName(), hcf));
"HIDDEN", vtkm::cont::Field::Association::CELL_SET, output.GetCellSet().GetName(), hcf));
return output;
}

6
vtkm/filter/SurfaceNormals.hxx
View File

@ -104,11 +104,11 @@ inline vtkm::cont::DataSet SurfaceNormals::DoExecute(
result = internal::CreateResult(input,
pointNormals,
internal::ComputePointNormalsName(this),
vtkm::cont::Field::ASSOC_POINTS);
vtkm::cont::Field::Association::POINTS);
if (this->GenerateCellNormals)
{
result.AddField(vtkm::cont::Field(internal::ComputeCellNormalsName(this),
vtkm::cont::Field::ASSOC_CELL_SET,
vtkm::cont::Field::Association::CELL_SET,
cellset.GetName(),
faceNormals));
}
@ -118,7 +118,7 @@ inline vtkm::cont::DataSet SurfaceNormals::DoExecute(
result = internal::CreateResult(input,
faceNormals,
internal::ComputeCellNormalsName(this),
vtkm::cont::Field::ASSOC_CELL_SET,
vtkm::cont::Field::Association::CELL_SET,
cellset.GetName());
}

35
vtkm/filter/internal/CreateResult.h
View File

@ -51,7 +51,7 @@ inline VTKM_CONT vtkm::cont::DataSet CreateResult(const vtkm::cont::DataSet& dat
inline VTKM_CONT vtkm::cont::DataSet CreateResult(
const vtkm::cont::DataSet& dataSet,
const std::string& fieldName,
vtkm::cont::Field::AssociationEnum fieldAssociation = vtkm::cont::Field::ASSOC_ANY)
vtkm::cont::Field::Association fieldAssociation = vtkm::cont::Field::Association::ANY)
{
VTKM_ASSERT(fieldName != "");
VTKM_ASSERT(dataSet.HasField(fieldName, fieldAssociation));
@ -76,23 +76,23 @@ inline VTKM_CONT vtkm::cont::DataSet CreateResult(const vtkm::cont::DataSet& inD
/// field. If the field is associated with a particular element set (for
/// example, a cell association is associated with a cell set), the name of
/// that associated set must also be given. The element set name is ignored
/// for \c ASSOC_WHOLE_MESH and \c ASSOC_POINTS associations.
/// for \c Association::WHOLE_MESH and \c Association::POINTS associations.
template <typename T, typename Storage>
inline VTKM_CONT vtkm::cont::DataSet CreateResult(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, Storage>& fieldArray,
const std::string& fieldName,
vtkm::cont::Field::AssociationEnum fieldAssociation,
vtkm::cont::Field::Association fieldAssociation,
const std::string& elementSetName = "")
{
VTKM_ASSERT(fieldName != "");
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::ASSOC_ANY);
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::ASSOC_LOGICAL_DIM);
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::Association::ANY);
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::Association::LOGICAL_DIM);
vtkm::cont::DataSet clone;
clone.CopyStructure(inDataSet);
if ((fieldAssociation == vtkm::cont::Field::ASSOC_WHOLE_MESH) ||
(fieldAssociation == vtkm::cont::Field::ASSOC_POINTS))
if ((fieldAssociation == vtkm::cont::Field::Association::WHOLE_MESH) ||
(fieldAssociation == vtkm::cont::Field::Association::POINTS))
{
vtkm::cont::Field field(fieldName, fieldAssociation, fieldArray);
clone.AddField(field);
@ -113,23 +113,22 @@ inline VTKM_CONT vtkm::cont::DataSet CreateResult(
/// field. If the field is associated with a particular element set (for
/// example, a cell association is associated with a cell set), the name of
/// that associated set must also be given. The element set name is ignored
/// for \c ASSOC_WHOLE_MESH and \c ASSOC_POINTS associations.
/// for \c Association::WHOLE_MESH and \c Association::POINTS associations.
///
inline VTKM_CONT vtkm::cont::DataSet CreateResult(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::DynamicArrayHandle& fieldArray,
const std::string& fieldName,
vtkm::cont::Field::AssociationEnum fieldAssociation,
const std::string& elementSetName = "")
inline VTKM_CONT vtkm::cont::DataSet CreateResult(const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::DynamicArrayHandle& fieldArray,
const std::string& fieldName,
vtkm::cont::Field::Association fieldAssociation,
const std::string& elementSetName = "")
{
VTKM_ASSERT(fieldName != "");
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::ASSOC_ANY);
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::ASSOC_LOGICAL_DIM);
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::Association::ANY);
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::Association::LOGICAL_DIM);
vtkm::cont::DataSet clone;
clone.CopyStructure(inDataSet);
if ((fieldAssociation == vtkm::cont::Field::ASSOC_WHOLE_MESH) ||
(fieldAssociation == vtkm::cont::Field::ASSOC_POINTS))
if ((fieldAssociation == vtkm::cont::Field::Association::WHOLE_MESH) ||
(fieldAssociation == vtkm::cont::Field::Association::POINTS))
{
vtkm::cont::Field field(fieldName, fieldAssociation, fieldArray);
clone.AddField(field);

21
vtkm/filter/testing/UnitTestCellAverageFilter.cxx
View File

@ -37,11 +37,13 @@ void TestCellAverageRegular3D()
cellAverage.SetActiveField("pointvar");
vtkm::cont::DataSet result = cellAverage.Execute(dataSet);
VTKM_TEST_ASSERT(result.HasField("avgvals", vtkm::cont::Field::ASSOC_CELL_SET) == true,
VTKM_TEST_ASSERT(result.HasField("avgvals", vtkm::cont::Field::Association::CELL_SET) == true,
"Result field not present.");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetField("avgvals", vtkm::cont::Field::ASSOC_CELL_SET).GetData().CopyTo(resultArrayHandle);
result.GetField("avgvals", vtkm::cont::Field::Association::CELL_SET)
.GetData()
.CopyTo(resultArrayHandle);
{
vtkm::Float32 expected[4] = { 60.1875f, 70.2125f, 120.3375f, 130.3625f };
for (vtkm::Id i = 0; i < 4; ++i)
@ -56,11 +58,12 @@ void TestCellAverageRegular3D()
cellAverage.SetUseCoordinateSystemAsField(true);
result = cellAverage.Execute(dataSet);
VTKM_TEST_ASSERT(result.HasField("avgpos", vtkm::cont::Field::ASSOC_CELL_SET),
VTKM_TEST_ASSERT(result.HasField("avgpos", vtkm::cont::Field::Association::CELL_SET),
"Result field not present.");
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>> resultPointArray;
vtkm::cont::Field resultPointField = result.GetField("avgpos", vtkm::cont::Field::ASSOC_CELL_SET);
vtkm::cont::Field resultPointField =
result.GetField("avgpos", vtkm::cont::Field::Association::CELL_SET);
resultPointField.GetData().CopyTo(resultPointArray);
{
vtkm::FloatDefault expected[4][3] = {
@ -89,10 +92,11 @@ void TestCellAverageRegular2D()
vtkm::cont::DataSet result = cellAverage.Execute(dataSet);
// If no name is given, should have the same name as the input.
VTKM_TEST_ASSERT(result.HasField("pointvar", vtkm::cont::Field::ASSOC_CELL_SET),
VTKM_TEST_ASSERT(result.HasField("pointvar", vtkm::cont::Field::Association::CELL_SET),
"Field missing.");
vtkm::cont::Field resultField = result.GetField("pointvar", vtkm::cont::Field::ASSOC_CELL_SET);
vtkm::cont::Field resultField =
result.GetField("pointvar", vtkm::cont::Field::Association::CELL_SET);
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
resultField.GetData().CopyTo(resultArrayHandle);
vtkm::Float32 expected[2] = { 30.1f, 40.1f };
@ -116,11 +120,12 @@ void TestCellAverageExplicit()
vtkm::cont::DataSet result = cellAverage.Execute(dataSet);
// If no name is given, should have the same name as the input.
VTKM_TEST_ASSERT(result.HasField("pointvar", vtkm::cont::Field::ASSOC_CELL_SET),
VTKM_TEST_ASSERT(result.HasField("pointvar", vtkm::cont::Field::Association::CELL_SET),
"Field missing.");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
vtkm::cont::Field resultField = result.GetField("pointvar", vtkm::cont::Field::ASSOC_CELL_SET);
vtkm::cont::Field resultField =
result.GetField("pointvar", vtkm::cont::Field::Association::CELL_SET);
resultField.GetData().CopyTo(resultArrayHandle);
vtkm::Float32 expected[2] = { 20.1333f, 35.2f };
for (int i = 0; i < 2; ++i)

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

@ -69,7 +69,7 @@ void TestClipExplicit()
vtkm::filter::ClipWithField clip;
clip.SetClipValue(0.5);
clip.SetActiveField("scalars");
clip.SetFieldsToPass("scalars", vtkm::cont::Field::ASSOC_POINTS);
clip.SetFieldsToPass("scalars", vtkm::cont::Field::Association::POINTS);
const vtkm::cont::DataSet outputData = clip.Execute(ds);

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

@ -87,11 +87,13 @@ void CheckResult(const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>>
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>>& field2,
const vtkm::cont::DataSet& result)
{
VTKM_TEST_ASSERT(result.HasField("crossproduct", vtkm::cont::Field::ASSOC_POINTS),
VTKM_TEST_ASSERT(result.HasField("crossproduct", vtkm::cont::Field::Association::POINTS),
"Output field is missing.");
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>> outputArray;
result.GetField("crossproduct", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(outputArray);
result.GetField("crossproduct", vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(outputArray);
auto v1Portal = field1.GetPortalConstControl();
auto v2Portal = field2.GetPortalConstControl();

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

@ -87,11 +87,13 @@ void CheckResult(const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>>
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>>& field2,
const vtkm::cont::DataSet& result)
{
VTKM_TEST_ASSERT(result.HasField("dotproduct", vtkm::cont::Field::ASSOC_POINTS),
VTKM_TEST_ASSERT(result.HasField("dotproduct", vtkm::cont::Field::Association::POINTS),
"Output field is missing.");
vtkm::cont::ArrayHandle<vtkm::FloatDefault> outputArray;
result.GetField("dotproduct", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(outputArray);
result.GetField("dotproduct", vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(outputArray);
auto v1Portal = field1.GetPortalConstControl();
auto v2Portal = field2.GetPortalConstControl();

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

@ -100,7 +100,8 @@ vtkm::cont::DataSet MakeIsosurfaceTestDataSet(vtkm::Id3 dims)
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vdims, origin, spacing);
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
dataSet.AddField(vtkm::cont::Field("nodevar", vtkm::cont::Field::ASSOC_POINTS, fieldArray));
dataSet.AddField(
vtkm::cont::Field("nodevar", vtkm::cont::Field::Association::POINTS, fieldArray));
static constexpr vtkm::IdComponent ndim = 3;
vtkm::cont::CellSetStructured<ndim> cellSet("cells");

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

@ -28,14 +28,14 @@ namespace
vtkm::cont::Field makeCellField()
{
return vtkm::cont::Field("foo",
vtkm::cont::Field::ASSOC_CELL_SET,
vtkm::cont::Field::Association::CELL_SET,
std::string(),
vtkm::cont::ArrayHandle<vtkm::Float32>());
}
vtkm::cont::Field makePointField()
{
return vtkm::cont::Field(
"foo", vtkm::cont::Field::ASSOC_POINTS, vtkm::cont::ArrayHandle<vtkm::Float32>());
"foo", vtkm::cont::Field::Association::POINTS, vtkm::cont::ArrayHandle<vtkm::Float32>());
}
void TestFieldTypesUnknown()
@ -59,7 +59,7 @@ void TestFieldTypesPoint()
//verify the field helper works properly
vtkm::Float32 vars[6] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f };
auto field = vtkm::cont::make_Field("pointvar", vtkm::cont::Field::ASSOC_POINTS, vars, 6);
auto field = vtkm::cont::make_Field("pointvar", vtkm::cont::Field::Association::POINTS, vars, 6);
vtkm::filter::FieldMetadata makeMDFromField(field);
VTKM_TEST_ASSERT(makeMDFromField.IsPointField() == true, "point should be a point field");
VTKM_TEST_ASSERT(makeMDFromField.IsCellField() == false, "point can't be a cell field");
@ -74,8 +74,8 @@ void TestFieldTypesCell()
//verify the field helper works properly
vtkm::Float32 vars[6] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f };
auto field =
vtkm::cont::make_Field("pointvar", vtkm::cont::Field::ASSOC_CELL_SET, std::string(), vars, 6);
auto field = vtkm::cont::make_Field(
"pointvar", vtkm::cont::Field::Association::CELL_SET, std::string(), vars, 6);
vtkm::filter::FieldMetadata makeMDFromField(field);
VTKM_TEST_ASSERT(makeMDFromField.IsPointField() == false, "cell can't be a point field");
VTKM_TEST_ASSERT(makeMDFromField.IsCellField() == true, "cell should be a cell field");

90
vtkm/filter/testing/UnitTestFieldSelection.cxx
View File

@ -29,7 +29,8 @@ void TestFieldSelection()
std::cout << "empty field selection, everything should be false." << std::endl;
vtkm::filter::FieldSelection selection;
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo") == false, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_POINTS) == false,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::POINTS) ==
false,
"field selection failed.");
}
@ -37,7 +38,8 @@ void TestFieldSelection()
std::cout << "field selection with select all, everything should be true." << std::endl;
vtkm::filter::FieldSelection selection(vtkm::filter::FieldSelection::MODE_ALL);
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo") == true, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_POINTS) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::POINTS) ==
true,
"field selection failed.");
}
@ -45,7 +47,8 @@ void TestFieldSelection()
std::cout << "field selection with select none, everything should be false." << std::endl;
vtkm::filter::FieldSelection selection(vtkm::filter::FieldSelection::MODE_NONE);
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo") == false, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_POINTS) == false,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::POINTS) ==
false,
"field selection failed.");
}
@ -53,20 +56,24 @@ void TestFieldSelection()
std::cout << "field selection of one field" << std::endl;
vtkm::filter::FieldSelection selection("foo");
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo") == true, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::ASSOC_POINTS) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::Association::POINTS) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::ASSOC_CELL_SET) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::Association::CELL_SET) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar") == false, "field selection failed.");
}
{
std::cout << "field selection of one field/association" << std::endl;
vtkm::filter::FieldSelection selection("foo", vtkm::cont::Field::ASSOC_POINTS);
vtkm::filter::FieldSelection selection("foo", vtkm::cont::Field::Association::POINTS);
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo") == true, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::ASSOC_POINTS) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::Association::POINTS) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::ASSOC_CELL_SET) == false,
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::Association::CELL_SET) ==
false,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar") == false, "field selection failed.");
}
@ -75,13 +82,16 @@ void TestFieldSelection()
std::cout << "field selection with specific fields selected (AddField)." << std::endl;
vtkm::filter::FieldSelection selection;
selection.AddField("foo");
selection.AddField("bar", vtkm::cont::Field::ASSOC_CELL_SET);
selection.AddField("bar", vtkm::cont::Field::Association::CELL_SET);
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo") == true, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::ASSOC_POINTS) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::Association::POINTS) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_POINTS) == false,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::POINTS) ==
false,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_CELL_SET) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::CELL_SET) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar") == true, "field selection failed.");
}
@ -90,11 +100,14 @@ void TestFieldSelection()
std::cout << "field selection with specific fields selected (initializer list)." << std::endl;
vtkm::filter::FieldSelection selection{ "foo", "bar" };
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo") == true, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::ASSOC_POINTS) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::Association::POINTS) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_POINTS) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::POINTS) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_CELL_SET) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::CELL_SET) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar") == true, "field selection failed.");
}
@ -102,15 +115,19 @@ void TestFieldSelection()
{
std::cout << "field selection with specific fields selected (std::pair initializer list)."
<< std::endl;
using pair_type = std::pair<std::string, vtkm::cont::Field::AssociationEnum>;
vtkm::filter::FieldSelection selection{ pair_type{ "foo", vtkm::cont::Field::ASSOC_ANY },
pair_type{ "bar", vtkm::cont::Field::ASSOC_CELL_SET } };
using pair_type = std::pair<std::string, vtkm::cont::Field::Association>;
vtkm::filter::FieldSelection selection{ pair_type{ "foo", vtkm::cont::Field::Association::ANY },
pair_type{ "bar",
vtkm::cont::Field::Association::CELL_SET } };
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo") == true, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::ASSOC_POINTS) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::Association::POINTS) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_POINTS) == false,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::POINTS) ==
false,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_CELL_SET) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::CELL_SET) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar") == true, "field selection failed.");
}
@ -118,32 +135,39 @@ void TestFieldSelection()
{
std::cout << "field selection with specific fields selected (vtkm::Pair initializer list)."
<< std::endl;
using pair_type = vtkm::Pair<std::string, vtkm::cont::Field::AssociationEnum>;
vtkm::filter::FieldSelection selection{ pair_type{ "foo", vtkm::cont::Field::ASSOC_ANY },
pair_type{ "bar", vtkm::cont::Field::ASSOC_CELL_SET } };
using pair_type = vtkm::Pair<std::string, vtkm::cont::Field::Association>;
vtkm::filter::FieldSelection selection{ pair_type{ "foo", vtkm::cont::Field::Association::ANY },
pair_type{ "bar",
vtkm::cont::Field::Association::CELL_SET } };
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo") == true, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::ASSOC_POINTS) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::Association::POINTS) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_POINTS) == false,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::POINTS) ==
false,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_CELL_SET) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::CELL_SET) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar") == true, "field selection failed.");
}
{
std::cout << "field selection with specific fields excluded." << std::endl;
using pair_type = std::pair<std::string, vtkm::cont::Field::AssociationEnum>;
using pair_type = std::pair<std::string, vtkm::cont::Field::Association>;
vtkm::filter::FieldSelection selection(
{ pair_type{ "foo", vtkm::cont::Field::ASSOC_ANY },
pair_type{ "bar", vtkm::cont::Field::ASSOC_CELL_SET } },
{ pair_type{ "foo", vtkm::cont::Field::Association::ANY },
pair_type{ "bar", vtkm::cont::Field::Association::CELL_SET } },
vtkm::filter::FieldSelection::MODE_EXCLUDE);
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo") == false, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::ASSOC_POINTS) == false,
VTKM_TEST_ASSERT(selection.IsFieldSelected("foo", vtkm::cont::Field::Association::POINTS) ==
false,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_POINTS) == true,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::POINTS) ==
true,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::ASSOC_CELL_SET) == false,
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar", vtkm::cont::Field::Association::CELL_SET) ==
false,
"field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("bar") == false, "field selection failed.");
VTKM_TEST_ASSERT(selection.IsFieldSelected("baz") == true, "field selection failed.");

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

@ -48,9 +48,9 @@ void TestFieldToColors()
ftc.SetOutputFieldName("colors");
auto rgbaResult = ftc.Execute(ds);
VTKM_TEST_ASSERT(rgbaResult.HasField("colors", vtkm::cont::Field::ASSOC_POINTS),
VTKM_TEST_ASSERT(rgbaResult.HasField("colors", vtkm::cont::Field::Association::POINTS),
"Field missing.");
vtkm::cont::Field Result = rgbaResult.GetField("colors", vtkm::cont::Field::ASSOC_POINTS);
vtkm::cont::Field Result = rgbaResult.GetField("colors", vtkm::cont::Field::Association::POINTS);
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::UInt8, 4>> resultRGBAHandle;
Result.GetData().CopyTo(resultRGBAHandle);
@ -70,8 +70,9 @@ void TestFieldToColors()
//Now verify that we can switching our output mode
ftc.SetOutputToRGB();
auto rgbResult = ftc.Execute(ds);
VTKM_TEST_ASSERT(rgbResult.HasField("colors", vtkm::cont::Field::ASSOC_POINTS), "Field missing.");
Result = rgbResult.GetField("colors", vtkm::cont::Field::ASSOC_POINTS);
VTKM_TEST_ASSERT(rgbResult.HasField("colors", vtkm::cont::Field::Association::POINTS),
"Field missing.");
Result = rgbResult.GetField("colors", vtkm::cont::Field::Association::POINTS);
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::UInt8, 3>> resultRGBHandle;
Result.GetData().CopyTo(resultRGBHandle);

20
vtkm/filter/testing/UnitTestGradient.cxx
View File

@ -43,7 +43,7 @@ void TestCellGradientUniform3D()
vtkm::cont::DataSet result = gradient.Execute(dataSet);
VTKM_TEST_ASSERT(result.HasField("Gradient", vtkm::cont::Field::ASSOC_CELL_SET),
VTKM_TEST_ASSERT(result.HasField("Gradient", vtkm::cont::Field::Association::CELL_SET),
"Field missing.");
//verify that the vorticity and qcriterion fields don't exist
@ -94,7 +94,7 @@ void TestCellGradientUniform3DWithVectorField()
vtkm::cont::DataSet result = gradient.Execute(dataSet);
VTKM_TEST_ASSERT(result.HasField("vec_gradient", vtkm::cont::Field::ASSOC_CELL_SET),
VTKM_TEST_ASSERT(result.HasField("vec_gradient", vtkm::cont::Field::Association::CELL_SET),
"Result field missing.");
//verify that the vorticity and qcriterion fields DO exist
@ -103,7 +103,7 @@ void TestCellGradientUniform3DWithVectorField()
"vec gradients should generate qcriterion");
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec<vtkm::Float64, 3>, 3>> resultArrayHandle;
result.GetField("vec_gradient", vtkm::cont::Field::ASSOC_CELL_SET)
result.GetField("vec_gradient", vtkm::cont::Field::Association::CELL_SET)
.GetData()
.CopyTo(resultArrayHandle);
vtkm::Vec<vtkm::Vec<vtkm::Float64, 3>, 3> expected[4] = {
@ -139,11 +139,11 @@ void TestCellGradientExplicit()
vtkm::cont::DataSet result = gradient.Execute(dataSet);
VTKM_TEST_ASSERT(result.HasField("gradient", vtkm::cont::Field::ASSOC_CELL_SET),
VTKM_TEST_ASSERT(result.HasField("gradient", vtkm::cont::Field::Association::CELL_SET),
"Result field missing.");
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 3>> resultArrayHandle;
result.GetField("gradient", vtkm::cont::Field::ASSOC_CELL_SET)
result.GetField("gradient", vtkm::cont::Field::Association::CELL_SET)
.GetData()
.CopyTo(resultArrayHandle);
vtkm::Vec<vtkm::Float32, 3> expected[2] = { { 10.f, 10.1f, 0.0f }, { 10.f, 10.1f, -0.0f } };
@ -180,11 +180,11 @@ void TestPointGradientUniform3DWithVectorField()
gradient.SetActiveField("vec_pointvar");
vtkm::cont::DataSet result = gradient.Execute(dataSet);
VTKM_TEST_ASSERT(result.HasField("vec_gradient", vtkm::cont::Field::ASSOC_POINTS),
VTKM_TEST_ASSERT(result.HasField("vec_gradient", vtkm::cont::Field::Association::POINTS),
"Result field missing.");
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec<vtkm::Float64, 3>, 3>> resultArrayHandle;
result.GetField("vec_gradient", vtkm::cont::Field::ASSOC_POINTS)
result.GetField("vec_gradient", vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(resultArrayHandle);
vtkm::Vec<vtkm::Vec<vtkm::Float64, 3>, 3> expected[4] = {
@ -221,11 +221,13 @@ void TestPointGradientExplicit()
vtkm::cont::DataSet result = gradient.Execute(dataSet);
VTKM_TEST_ASSERT(result.HasField("gradient", vtkm::cont::Field::ASSOC_POINTS),
VTKM_TEST_ASSERT(result.HasField("gradient", vtkm::cont::Field::Association::POINTS),
"Result field missing.");
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 3>> resultArrayHandle;
result.GetField("gradient", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(resultArrayHandle);
result.GetField("gradient", vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(resultArrayHandle);
vtkm::Vec<vtkm::Float32, 3> expected[2] = { { 10.f, 10.1f, 0.0f }, { 10.f, 10.1f, 0.0f } };
for (int i = 0; i < 2; ++i)

34
vtkm/filter/testing/UnitTestHistogramFilter.cxx
View File

@ -228,27 +228,39 @@ vtkm::cont::DataSet MakeTestDataSet()
// Set point scalars
dataSet.AddField(vtkm::cont::make_Field(
"p_poisson", vtkm::cont::Field::ASSOC_POINTS, poisson, nVerts, vtkm::CopyFlag::On));
"p_poisson", vtkm::cont::Field::Association::POINTS, poisson, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"p_normal", vtkm::cont::Field::ASSOC_POINTS, normal, nVerts, vtkm::CopyFlag::On));
"p_normal", vtkm::cont::Field::Association::POINTS, normal, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"p_chiSquare", vtkm::cont::Field::ASSOC_POINTS, chiSquare, nVerts, vtkm::CopyFlag::On));
"p_chiSquare", vtkm::cont::Field::Association::POINTS, chiSquare, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"p_uniform", vtkm::cont::Field::ASSOC_POINTS, uniform, nVerts, vtkm::CopyFlag::On));
"p_uniform", vtkm::cont::Field::Association::POINTS, uniform, nVerts, vtkm::CopyFlag::On));
// Set cell scalars
dataSet.AddField(vtkm::cont::make_Field(
"c_poisson", vtkm::cont::Field::ASSOC_CELL_SET, "cells", poisson, nCells, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"c_normal", vtkm::cont::Field::ASSOC_CELL_SET, "cells", normal, nCells, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_poisson",
vtkm::cont::Field::Association::CELL_SET,
"cells",
poisson,
nCells,
vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_normal",
vtkm::cont::Field::Association::CELL_SET,
"cells",
normal,
nCells,
vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_chiSquare",
vtkm::cont::Field::ASSOC_CELL_SET,
vtkm::cont::Field::Association::CELL_SET,
"cells",
chiSquare,
nCells,
vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"c_uniform", vtkm::cont::Field::ASSOC_CELL_SET, "cells", poisson, nCells, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_uniform",
vtkm::cont::Field::Association::CELL_SET,
"cells",
poisson,
nCells,
vtkm::CopyFlag::On));
vtkm::cont::CellSetStructured<dimension> cellSet("cells");

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

@ -109,7 +109,7 @@ vtkm::cont::DataSet MakeIsosurfaceTestDataSet(vtkm::Id3 dims)
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
dataSet.AddField(
vtkm::cont::Field(std::string("nodevar"), vtkm::cont::Field::ASSOC_POINTS, fieldArray));
vtkm::cont::Field(std::string("nodevar"), vtkm::cont::Field::Association::POINTS, fieldArray));
static constexpr vtkm::IdComponent ndim = 3;
vtkm::cont::CellSetStructured<ndim> cellSet("cells");
@ -282,10 +282,10 @@ inline vtkm::cont::DataSet MakeRadiantDataSet::Make3DRadiantDataSet(vtkm::IdComp
//Set point scalar
dataSet.AddField(vtkm::cont::Field("distanceToOrigin",
vtkm::cont::Field::ASSOC_POINTS,
vtkm::cont::Field::Association::POINTS,
vtkm::cont::DynamicArrayHandle(distanceToOrigin)));
dataSet.AddField(vtkm::cont::Field("distanceToOther",
vtkm::cont::Field::ASSOC_POINTS,
vtkm::cont::Field::Association::POINTS,
vtkm::cont::DynamicArrayHandle(distanceToOther)));
CellSet cellSet("cells");

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

@ -82,7 +82,7 @@ void AddField(vtkm::cont::DataSet& dataset,
const T& max,
vtkm::Id numVals,
const std::string& name,
vtkm::cont::Field::AssociationEnum assoc = vtkm::cont::Field::ASSOC_POINTS)
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::POINTS)
{
auto ah = CreateArrayHandle(min, max, numVals);
dataset.AddField(vtkm::cont::Field(name, assoc, ah));

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

@ -174,11 +174,11 @@ vtkm::cont::DataSet MakeTestDataSet()
// Set point scalars
dataSet.AddField(vtkm::cont::make_Field(
"fieldA", vtkm::cont::Field::ASSOC_POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
"fieldA", vtkm::cont::Field::Association::POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldB", vtkm::cont::Field::ASSOC_POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
"fieldB", vtkm::cont::Field::Association::POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldC", vtkm::cont::Field::ASSOC_POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
"fieldC", vtkm::cont::Field::Association::POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
return dataSet;
}

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

@ -57,11 +57,11 @@ vtkm::cont::DataSet MakeTestDataSet()
// Set point scalars
dataSet.AddField(vtkm::cont::make_Field(
"fieldA", vtkm::cont::Field::ASSOC_POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
"fieldA", vtkm::cont::Field::Association::POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldB", vtkm::cont::Field::ASSOC_POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
"fieldB", vtkm::cont::Field::Association::POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldC", vtkm::cont::Field::ASSOC_POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
"fieldC", vtkm::cont::Field::Association::POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
return dataSet;
}

26
vtkm/filter/testing/UnitTestPointAverageFilter.cxx
View File

@ -37,9 +37,12 @@ void TestPointAverageUniform3D()
pointAverage.SetActiveField("cellvar");
auto result = pointAverage.Execute(dataSet);
VTKM_TEST_ASSERT(result.HasField("avgvals", vtkm::cont::Field::ASSOC_POINTS), "Field missing.");
VTKM_TEST_ASSERT(result.HasField("avgvals", vtkm::cont::Field::Association::POINTS),
"Field missing.");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetField("avgvals", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(resultArrayHandle);
result.GetField("avgvals", vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(resultArrayHandle);
vtkm::Float32 expected[18] = { 100.1f, 100.15f, 100.2f, 100.1f, 100.15f, 100.2f,
100.2f, 100.25f, 100.3f, 100.2f, 100.25f, 100.3f,
100.3f, 100.35f, 100.4f, 100.3f, 100.35f, 100.4f };
@ -62,8 +65,9 @@ void TestPointAverageRegular3D()
auto result = pointAverage.Execute(dataSet);
// If no name is given, should have the same name as the input.
VTKM_TEST_ASSERT(result.HasField("cellvar", vtkm::cont::Field::ASSOC_POINTS), "Field missing.");
vtkm::cont::Field Result = result.GetField("cellvar", vtkm::cont::Field::ASSOC_POINTS);
VTKM_TEST_ASSERT(result.HasField("cellvar", vtkm::cont::Field::Association::POINTS),
"Field missing.");
vtkm::cont::Field Result = result.GetField("cellvar", vtkm::cont::Field::Association::POINTS);
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
Result.GetData().CopyTo(resultArrayHandle);
@ -88,9 +92,12 @@ void TestPointAverageExplicit1()
auto result = pointAverage.Execute(dataSet);
// If no name is given, should have the same name as the input.
VTKM_TEST_ASSERT(result.HasField("cellvar", vtkm::cont::Field::ASSOC_POINTS), "Field missing.");
VTKM_TEST_ASSERT(result.HasField("cellvar", vtkm::cont::Field::Association::POINTS),
"Field missing.");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetField("cellvar", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(resultArrayHandle);
result.GetField("cellvar", vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(resultArrayHandle);
vtkm::Float32 expected[5] = { 100.1f, 100.15f, 100.15f, 100.2f, 100.2f };
for (int i = 0; i < 5; ++i)
{
@ -111,9 +118,12 @@ void TestPointAverageExplicit2()
auto result = pointAverage.Execute(dataSet);
// If no name is given, should have the same name as the input.
VTKM_TEST_ASSERT(result.HasField("cellvar", vtkm::cont::Field::ASSOC_POINTS), "Field missing.");
VTKM_TEST_ASSERT(result.HasField("cellvar", vtkm::cont::Field::Association::POINTS),
"Field missing.");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetField("cellvar", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(resultArrayHandle);
result.GetField("cellvar", vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(resultArrayHandle);
vtkm::Float32 expected[11] = { 100.1f, 105.05f, 105.05f, 100.1f, 115.3f, 115.2f,
115.2f, 115.3f, 115.1f, 130.5f, 125.35f };
for (int i = 0; i < 11; ++i)

12
vtkm/filter/testing/UnitTestPointElevationFilter.cxx
View File

@ -82,11 +82,13 @@ void TestPointElevationNoPolicy()
auto result = filter.Execute(inputData);
//verify the result
VTKM_TEST_ASSERT(result.HasField("height", vtkm::cont::Field::ASSOC_POINTS),
VTKM_TEST_ASSERT(result.HasField("height", vtkm::cont::Field::Association::POINTS),
"Output field missing.");
vtkm::cont::ArrayHandle<vtkm::Float64> resultArrayHandle;
result.GetField("height", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(resultArrayHandle);
result.GetField("height", vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(resultArrayHandle);
auto coordinates = inputData.GetCoordinateSystem().GetData();
for (vtkm::Id i = 0; i < resultArrayHandle.GetNumberOfValues(); ++i)
{
@ -114,11 +116,13 @@ void TestPointElevationWithPolicy()
auto result = filter.Execute(inputData, p);
//verify the result
VTKM_TEST_ASSERT(result.HasField("elevation", vtkm::cont::Field::ASSOC_POINTS),
VTKM_TEST_ASSERT(result.HasField("elevation", vtkm::cont::Field::Association::POINTS),
"Output field has wrong association");
vtkm::cont::ArrayHandle<vtkm::Float64> resultArrayHandle;
result.GetField("elevation", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(resultArrayHandle);
result.GetField("elevation", vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(resultArrayHandle);
auto coordinates = inputData.GetCoordinateSystem().GetData();
for (vtkm::Id i = 0; i < resultArrayHandle.GetNumberOfValues(); ++i)
{

12
vtkm/filter/testing/UnitTestSurfaceNormalsFilter.cxx
View File

@ -28,7 +28,7 @@ namespace
void VerifyCellNormalValues(const vtkm::cont::DataSet& ds)
{
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>> normals;
ds.GetField("Normals", vtkm::cont::Field::ASSOC_CELL_SET).GetData().CopyTo(normals);
ds.GetField("Normals", vtkm::cont::Field::Association::CELL_SET).GetData().CopyTo(normals);
vtkm::Vec<vtkm::FloatDefault, 3> expected[8] = {
{ -0.707f, -0.500f, 0.500f }, { -0.707f, -0.500f, 0.500f }, { 0.707f, 0.500f, -0.500f },
@ -48,7 +48,7 @@ void VerifyCellNormalValues(const vtkm::cont::DataSet& ds)
void VerifyPointNormalValues(const vtkm::cont::DataSet& ds)
{
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>> normals;
ds.GetField("Normals", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(normals);
ds.GetField("Normals", vtkm::cont::Field::Association::POINTS).GetData().CopyTo(normals);
vtkm::Vec<vtkm::FloatDefault, 3> expected[8] = {
{ -0.8165f, -0.4082f, -0.4082f }, { -0.2357f, -0.9714f, 0.0286f },
@ -75,22 +75,22 @@ void TestSurfaceNormals()
std::cout << "testing default output (generate only point normals):\n";
result = filter.Execute(ds);
VTKM_TEST_ASSERT(result.HasField("Normals", vtkm::cont::Field::ASSOC_POINTS),
VTKM_TEST_ASSERT(result.HasField("Normals", vtkm::cont::Field::Association::POINTS),
"Point normals missing.");
std::cout << "generate only cell normals:\n";
filter.SetGenerateCellNormals(true);
filter.SetGeneratePointNormals(false);
result = filter.Execute(ds);
VTKM_TEST_ASSERT(result.HasField("Normals", vtkm::cont::Field::ASSOC_CELL_SET),
VTKM_TEST_ASSERT(result.HasField("Normals", vtkm::cont::Field::Association::CELL_SET),
"Cell normals missing.");
std::cout << "generate both cell and point normals:\n";
filter.SetGeneratePointNormals(true);
result = filter.Execute(ds);
VTKM_TEST_ASSERT(result.HasField("Normals", vtkm::cont::Field::ASSOC_POINTS),
VTKM_TEST_ASSERT(result.HasField("Normals", vtkm::cont::Field::Association::POINTS),
"Point normals missing.");
VTKM_TEST_ASSERT(result.HasField("Normals", vtkm::cont::Field::ASSOC_CELL_SET),
VTKM_TEST_ASSERT(result.HasField("Normals", vtkm::cont::Field::Association::CELL_SET),
"Cell normals missing.");
std::cout << "test result values:\n";

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

@ -51,11 +51,13 @@ void TestVectorMagnitude()
vm.SetActiveField("double_vec_pointvar");
auto result = vm.Execute(dataSet);
VTKM_TEST_ASSERT(result.HasField("magnitude", vtkm::cont::Field::ASSOC_POINTS),
VTKM_TEST_ASSERT(result.HasField("magnitude", vtkm::cont::Field::Association::POINTS),
"Output field missing.");
vtkm::cont::ArrayHandle<vtkm::Float64> resultArrayHandle;
result.GetField("magnitude", vtkm::cont::Field::ASSOC_POINTS).GetData().CopyTo(resultArrayHandle);
result.GetField("magnitude", vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(resultArrayHandle);
for (vtkm::Id i = 0; i < resultArrayHandle.GetNumberOfValues(); ++i)
{
VTKM_TEST_ASSERT(test_equal(std::sqrt(3 * fvars[i] * fvars[i]),

10
vtkm/io/reader/VTKDataSetReaderBase.h
View File

@ -385,7 +385,7 @@ protected:
return;
}
vtkm::cont::Field::AssociationEnum association = vtkm::cont::Field::ASSOC_ANY;
vtkm::cont::Field::Association association = vtkm::cont::Field::Association::ANY;
std::size_t size;
std::string tag;
@ -394,11 +394,11 @@ protected:
{
if (tag == "POINT_DATA")
{
association = vtkm::cont::Field::ASSOC_POINTS;
association = vtkm::cont::Field::Association::POINTS;
}
else if (tag == "CELL_DATA")
{
association = vtkm::cont::Field::ASSOC_CELL_SET;
association = vtkm::cont::Field::Association::CELL_SET;
}
else
{
@ -450,10 +450,10 @@ protected:
{
switch (association)
{
case vtkm::cont::Field::ASSOC_POINTS:
case vtkm::cont::Field::Association::POINTS:
this->DataSet.AddField(vtkm::cont::Field(name, association, data));
break;
case vtkm::cont::Field::ASSOC_CELL_SET:
case vtkm::cont::Field::Association::CELL_SET:
vtkm::cont::CastAndCall(data, PermuteCellData(this->CellsPermutation, data));
this->DataSet.AddField(vtkm::cont::Field(name, association, "cells", data));
break;

4
vtkm/io/writer/VTKDataSetWriter.h
View File

@ -226,7 +226,7 @@ private:
{
const vtkm::cont::Field field = dataSet.GetField(f);
if (field.GetAssociation() != vtkm::cont::Field::ASSOC_POINTS)
if (field.GetAssociation() != vtkm::cont::Field::Association::POINTS)
{
continue;
}
@ -263,7 +263,7 @@ private:
{
const vtkm::cont::Field field = dataSet.GetField(f);
if (field.GetAssociation() != vtkm::cont::Field::ASSOC_CELL_SET)
if (field.GetAssociation() != vtkm::cont::Field::Association::CELL_SET)
{
continue;
}

7
vtkm/rendering/MapperWireframer.cxx
View File

@ -328,7 +328,8 @@ void MapperWireframer::RenderCells(const vtkm::cont::DynamicCellSet& inCellSet,
if (is1D)
{
bool isSupportedField = inScalarField.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS;
bool isSupportedField =
inScalarField.GetAssociation() == vtkm::cont::Field::Association::POINTS;
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue(
@ -348,8 +349,8 @@ void MapperWireframer::RenderCells(const vtkm::cont::DynamicCellSet& inCellSet,
this->LogarithmX);
actualCoords = vtkm::cont::CoordinateSystem("coords", newCoords);
actualField =
vtkm::cont::Field(inScalarField.GetName(), vtkm::cont::Field::ASSOC_POINTS, newScalars);
actualField = vtkm::cont::Field(
inScalarField.GetName(), vtkm::cont::Field::Association::POINTS, newScalars);
vtkm::Id numCells = cellSet.GetNumberOfCells();
vtkm::cont::ArrayHandle<vtkm::Id> conn;

7
vtkm/rendering/Wireframer.h
View File

@ -532,11 +532,12 @@ private:
xOffset = static_cast<vtkm::Id>(_x);
}
bool isSupportedField = (ScalarField.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS ||
ScalarField.GetAssociation() == vtkm::cont::Field::ASSOC_CELL_SET);
bool isSupportedField =
(ScalarField.GetAssociation() == vtkm::cont::Field::Association::POINTS ||
ScalarField.GetAssociation() == vtkm::cont::Field::Association::CELL_SET);
if (!isSupportedField)
throw vtkm::cont::ErrorBadValue("Field not associated with cell set or points");
bool isAssocPoints = ScalarField.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS;
bool isAssocPoints = ScalarField.GetAssociation() == vtkm::cont::Field::Association::POINTS;
EdgePlotter<DeviceTag> plotter(WorldToProjection,
width,

2
vtkm/rendering/raytracing/ChannelBuffer.cxx
View File

@ -405,7 +405,7 @@ struct NormalizeFunctor
template <typename Device>
bool operator()(Device vtkmNotUsed(device))
{
vtkm::cont::Field asField("name meaningless", vtkm::cont::Field::ASSOC_POINTS, Input);
vtkm::cont::Field asField("name meaningless", vtkm::cont::Field::Association::POINTS, Input);
vtkm::Range range;
asField.GetRange(&range);
Precision minScalar = static_cast<Precision>(range.Min);

13
vtkm/rendering/raytracing/ConnectivityTracerBase.cxx
View File

@ -68,11 +68,12 @@ void ConnectivityTracerBase::SetVolumeData(const vtkm::cont::Field& scalarField,
ScalarField = scalarField;
ScalarBounds = scalarBounds;
bool isSupportedField = (ScalarField.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS ||
ScalarField.GetAssociation() == vtkm::cont::Field::ASSOC_CELL_SET);
bool isSupportedField =
(ScalarField.GetAssociation() == vtkm::cont::Field::Association::POINTS ||
ScalarField.GetAssociation() == vtkm::cont::Field::Association::CELL_SET);
if (!isSupportedField)
throw vtkm::cont::ErrorBadValue("Field not accociated with cell set or points");
FieldAssocPoints = ScalarField.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS;
FieldAssocPoints = ScalarField.GetAssociation() == vtkm::cont::Field::Association::POINTS;
this->Integrator = Volume;
}
@ -81,7 +82,7 @@ void ConnectivityTracerBase::SetEnergyData(const vtkm::cont::Field& absorption,
const vtkm::Int32 numBins,
const vtkm::cont::Field& emission)
{
bool isSupportedField = absorption.GetAssociation() == vtkm::cont::Field::ASSOC_CELL_SET;
bool isSupportedField = absorption.GetAssociation() == vtkm::cont::Field::Association::CELL_SET;
if (!isSupportedField)
throw vtkm::cont::ErrorBadValue("Absorption Field '" + absorption.GetName() +
"' not accociated with cells");
@ -89,9 +90,9 @@ void ConnectivityTracerBase::SetEnergyData(const vtkm::cont::Field& absorption,
// Check for emission
HasEmission = false;
if (emission.GetAssociation() != vtkm::cont::Field::ASSOC_ANY)
if (emission.GetAssociation() != vtkm::cont::Field::Association::ANY)
{
if (emission.GetAssociation() != vtkm::cont::Field::ASSOC_CELL_SET)
if (emission.GetAssociation() != vtkm::cont::Field::Association::CELL_SET)
throw vtkm::cont::ErrorBadValue("Emission Field '" + emission.GetName() +
"' not accociated with cells");
HasEmission = true;

7
vtkm/rendering/raytracing/RayTracer.cxx
View File

@ -238,11 +238,12 @@ public:
const vtkm::cont::Field& scalarField,
const vtkm::Range& scalarRange)
{
bool isSupportedField = (scalarField.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS ||
scalarField.GetAssociation() == vtkm::cont::Field::ASSOC_CELL_SET);
bool isSupportedField =
(scalarField.GetAssociation() == vtkm::cont::Field::Association::POINTS ||
scalarField.GetAssociation() == vtkm::cont::Field::Association::CELL_SET);
if (!isSupportedField)
throw vtkm::cont::ErrorBadValue("Field not accociated with cell set or points");
bool isAssocPoints = scalarField.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS;
bool isAssocPoints = scalarField.GetAssociation() == vtkm::cont::Field::Association::POINTS;
vtkm::worklet::DispatcherMapField<CalculateNormals, Device>(CalculateNormals(bvh.LeafNodes))
.Invoke(rays.HitIdx, rays.Dir, rays.NormalX, rays.NormalY, rays.NormalZ, coordsHandle);

7
vtkm/rendering/raytracing/VolumeRendererStructured.cxx
View File

@ -825,11 +825,12 @@ void VolumeRendererStructured::RenderOnDevice(vtkm::rendering::raytracing::Ray<P
logger->AddLogData("calc_ray_start", time);
timer.Reset();
bool isSupportedField = (ScalarField->GetAssociation() == vtkm::cont::Field::ASSOC_POINTS ||
ScalarField->GetAssociation() == vtkm::cont::Field::ASSOC_CELL_SET);
bool isSupportedField =
(ScalarField->GetAssociation() == vtkm::cont::Field::Association::POINTS ||
ScalarField->GetAssociation() == vtkm::cont::Field::Association::CELL_SET);
if (!isSupportedField)
throw vtkm::cont::ErrorBadValue("Field not accociated with cell set or points");
bool isAssocPoints = ScalarField->GetAssociation() == vtkm::cont::Field::ASSOC_POINTS;
bool isAssocPoints = ScalarField->GetAssociation() == vtkm::cont::Field::Association::POINTS;
if (IsUniformDataSet)
{

12
vtkm/worklet/Threshold.h
View File

@ -127,7 +127,7 @@ public:
vtkm::cont::CellSetPermutation<CellSetType> Run(
const CellSetType& cellSet,
const vtkm::cont::ArrayHandle<ValueType, StorageType>& field,
const vtkm::cont::Field::AssociationEnum fieldType,
const vtkm::cont::Field::Association fieldType,
const UnaryPredicate& predicate,
DeviceAdapter)
{
@ -136,7 +136,7 @@ public:
vtkm::cont::ArrayHandle<bool> passFlags;
switch (fieldType)
{
case vtkm::cont::Field::ASSOC_POINTS:
case vtkm::cont::Field::Association::POINTS:
{
using ThresholdWorklet = ThresholdByPointField<UnaryPredicate>;
@ -145,7 +145,7 @@ public:
dispatcher.Invoke(cellSet, field, passFlags);
break;
}
case vtkm::cont::Field::ASSOC_CELL_SET:
case vtkm::cont::Field::Association::CELL_SET:
{
using ThresholdWorklet = ThresholdByCellField<UnaryPredicate>;
@ -173,13 +173,13 @@ public:
vtkm::cont::DynamicCellSet& Output;
vtkm::worklet::Threshold& Worklet;
const FieldArrayType& Field;
const vtkm::cont::Field::AssociationEnum FieldType;
const vtkm::cont::Field::Association FieldType;
const UnaryPredicate& Predicate;
CallWorklet(vtkm::cont::DynamicCellSet& output,
vtkm::worklet::Threshold& worklet,
const FieldArrayType& field,
const vtkm::cont::Field::AssociationEnum fieldType,
const vtkm::cont::Field::Association fieldType,
const UnaryPredicate& predicate)
: Output(output)
, Worklet(worklet)
@ -204,7 +204,7 @@ public:
typename Device>
vtkm::cont::DynamicCellSet Run(const vtkm::cont::DynamicCellSetBase<CellSetList>& cellSet,
const vtkm::cont::ArrayHandle<ValueType, StorageType>& field,
const vtkm::cont::Field::AssociationEnum fieldType,
const vtkm::cont::Field::Association fieldType,
const UnaryPredicate& predicate,
Device)
{

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

@ -114,9 +114,10 @@ static vtkm::cont::DataSet MakeIsosurfaceTestDataSet(vtkm::Id3 dims)
cellSet.SetPointDimensions(vdims);
dataSet.AddCellSet(cellSet);
dataSet.AddField(vtkm::cont::Field("nodevar", vtkm::cont::Field::ASSOC_POINTS, pointFieldArray));
dataSet.AddField(
vtkm::cont::Field("cellvar", vtkm::cont::Field::ASSOC_CELL_SET, "cells", cellFieldArray));
vtkm::cont::Field("nodevar", vtkm::cont::Field::Association::POINTS, pointFieldArray));
dataSet.AddField(vtkm::cont::Field(
"cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellFieldArray));
return dataSet;
}

34
vtkm/worklet/testing/UnitTestFieldHistogram.cxx
View File

@ -228,27 +228,39 @@ vtkm::cont::DataSet MakeTestDataSet()
// Set point scalars
dataSet.AddField(vtkm::cont::make_Field(
"p_poisson", vtkm::cont::Field::ASSOC_POINTS, poisson, nVerts, vtkm::CopyFlag::On));
"p_poisson", vtkm::cont::Field::Association::POINTS, poisson, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"p_normal", vtkm::cont::Field::ASSOC_POINTS, normal, nVerts, vtkm::CopyFlag::On));
"p_normal", vtkm::cont::Field::Association::POINTS, normal, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"p_chiSquare", vtkm::cont::Field::ASSOC_POINTS, chiSquare, nVerts, vtkm::CopyFlag::On));
"p_chiSquare", vtkm::cont::Field::Association::POINTS, chiSquare, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"p_uniform", vtkm::cont::Field::ASSOC_POINTS, uniform, nVerts, vtkm::CopyFlag::On));
"p_uniform", vtkm::cont::Field::Association::POINTS, uniform, nVerts, vtkm::CopyFlag::On));
// Set cell scalars
dataSet.AddField(vtkm::cont::make_Field(
"c_poisson", vtkm::cont::Field::ASSOC_CELL_SET, "cells", poisson, nCells, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"c_normal", vtkm::cont::Field::ASSOC_CELL_SET, "cells", normal, nCells, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_poisson",
vtkm::cont::Field::Association::CELL_SET,
"cells",
poisson,
nCells,
vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_normal",
vtkm::cont::Field::Association::CELL_SET,
"cells",
normal,
nCells,
vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_chiSquare",
vtkm::cont::Field::ASSOC_CELL_SET,
vtkm::cont::Field::Association::CELL_SET,
"cells",
chiSquare,
nCells,
vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"c_uniform", vtkm::cont::Field::ASSOC_CELL_SET, "cells", poisson, nCells, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_uniform",
vtkm::cont::Field::Association::CELL_SET,
"cells",
poisson,
nCells,
vtkm::CopyFlag::On));
vtkm::cont::CellSetStructured<dimension> cellSet("cells");

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

@ -47,7 +47,7 @@ vtkm::cont::DataSet Make2DUniformStatDataSet0()
// Create cell scalar
vtkm::Float32 data[nVerts] = { 4, 1, 10, 6, 8, 2, 9, 3, 5, 7 };
dataSet.AddField(vtkm::cont::make_Field(
"data", vtkm::cont::Field::ASSOC_CELL_SET, "cells", data, nCells, vtkm::CopyFlag::On));
"data", vtkm::cont::Field::Association::CELL_SET, "cells", data, nCells, vtkm::CopyFlag::On));
vtkm::cont::CellSetStructured<dimension> cellSet("cells");
@ -263,27 +263,39 @@ vtkm::cont::DataSet Make2DUniformStatDataSet1()
// Set point scalars
dataSet.AddField(vtkm::cont::make_Field(
"p_poisson", vtkm::cont::Field::ASSOC_POINTS, poisson, nVerts, vtkm::CopyFlag::On));
"p_poisson", vtkm::cont::Field::Association::POINTS, poisson, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"p_normal", vtkm::cont::Field::ASSOC_POINTS, normal, nVerts, vtkm::CopyFlag::On));
"p_normal", vtkm::cont::Field::Association::POINTS, normal, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"p_chiSquare", vtkm::cont::Field::ASSOC_POINTS, chiSquare, nVerts, vtkm::CopyFlag::On));
"p_chiSquare", vtkm::cont::Field::Association::POINTS, chiSquare, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"p_uniform", vtkm::cont::Field::ASSOC_POINTS, uniform, nVerts, vtkm::CopyFlag::On));
"p_uniform", vtkm::cont::Field::Association::POINTS, uniform, nVerts, vtkm::CopyFlag::On));
// Set cell scalars
dataSet.AddField(vtkm::cont::make_Field(
"c_poisson", vtkm::cont::Field::ASSOC_CELL_SET, "cells", poisson, nCells, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"c_normal", vtkm::cont::Field::ASSOC_CELL_SET, "cells", normal, nCells, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_poisson",
vtkm::cont::Field::Association::CELL_SET,
"cells",
poisson,
nCells,
vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_normal",
vtkm::cont::Field::Association::CELL_SET,
"cells",
normal,
nCells,
vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_chiSquare",
vtkm::cont::Field::ASSOC_CELL_SET,
vtkm::cont::Field::Association::CELL_SET,
"cells",
chiSquare,
nCells,
vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"c_uniform", vtkm::cont::Field::ASSOC_CELL_SET, "cells", poisson, nCells, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field("c_uniform",
vtkm::cont::Field::Association::CELL_SET,
"cells",
poisson,
nCells,
vtkm::CopyFlag::On));
vtkm::cont::CellSetStructured<dimension> cellSet("cells");

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

@ -45,7 +45,8 @@ public:
vtkm::cont::DataSetBuilderUniform builder;
vtkm::cont::DataSet data = builder.Create(vtkm::Id3(8, 4, 1));
auto colorField = vtkm::cont::make_Field("color", vtkm::cont::Field::ASSOC_POINTS, pixels);
auto colorField =
vtkm::cont::make_Field("color", vtkm::cont::Field::Association::POINTS, pixels);
data.AddField(colorField);
vtkm::cont::ArrayHandle<vtkm::Id> component;

13
vtkm/worklet/testing/UnitTestMarchingCubes.cxx
View File

@ -118,9 +118,10 @@ vtkm::cont::DataSet MakeIsosurfaceTestDataSet(vtkm::Id3 dims)
cellSet.SetPointDimensions(vdims);
dataSet.AddCellSet(cellSet);
dataSet.AddField(vtkm::cont::Field("nodevar", vtkm::cont::Field::ASSOC_POINTS, pointFieldArray));
dataSet.AddField(
vtkm::cont::Field("cellvar", vtkm::cont::Field::ASSOC_CELL_SET, "cells", cellFieldArray));
vtkm::cont::Field("nodevar", vtkm::cont::Field::Association::POINTS, pointFieldArray));
dataSet.AddField(vtkm::cont::Field(
"cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellFieldArray));
return dataSet;
}
@ -266,10 +267,10 @@ inline vtkm::cont::DataSet MakeRadiantDataSet::Make3DRadiantDataSet(vtkm::IdComp
//Set point scalar
dataSet.AddField(vtkm::cont::Field("distanceToOrigin",
vtkm::cont::Field::ASSOC_POINTS,
vtkm::cont::Field::Association::POINTS,
vtkm::cont::DynamicArrayHandle(distanceToOrigin)));
dataSet.AddField(vtkm::cont::Field("distanceToOther",
vtkm::cont::Field::ASSOC_POINTS,
vtkm::cont::Field::Association::POINTS,
vtkm::cont::DynamicArrayHandle(distanceToOther)));
CellSet cellSet("cells");
@ -277,8 +278,8 @@ inline vtkm::cont::DataSet MakeRadiantDataSet::Make3DRadiantDataSet(vtkm::IdComp
dataSet.AddCellSet(cellSet);
dataSet.AddField(
vtkm::cont::Field("cellvar", vtkm::cont::Field::ASSOC_CELL_SET, "cells", cellFieldArray));
dataSet.AddField(vtkm::cont::Field(
"cellvar", vtkm::cont::Field::Association::CELL_SET, "cells", cellFieldArray));
return dataSet;
}

6
vtkm/worklet/testing/UnitTestNDimsEntropy.cxx
View File

@ -174,11 +174,11 @@ vtkm::cont::DataSet MakeTestDataSet()
// Set point scalars
dataSet.AddField(vtkm::cont::make_Field(
"fieldA", vtkm::cont::Field::ASSOC_POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
"fieldA", vtkm::cont::Field::Association::POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldB", vtkm::cont::Field::ASSOC_POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
"fieldB", vtkm::cont::Field::Association::POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldC", vtkm::cont::Field::ASSOC_POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
"fieldC", vtkm::cont::Field::Association::POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
return dataSet;
}

6
vtkm/worklet/testing/UnitTestNDimsHistMarginalization.cxx
View File

@ -176,11 +176,11 @@ vtkm::cont::DataSet MakeTestDataSet()
// Set point scalars
dataSet.AddField(vtkm::cont::make_Field(
"fieldA", vtkm::cont::Field::ASSOC_POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
"fieldA", vtkm::cont::Field::Association::POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldB", vtkm::cont::Field::ASSOC_POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
"fieldB", vtkm::cont::Field::Association::POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldC", vtkm::cont::Field::ASSOC_POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
"fieldC", vtkm::cont::Field::Association::POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
return dataSet;
}

6
vtkm/worklet/testing/UnitTestNDimsHistogram.cxx
View File

@ -57,11 +57,11 @@ vtkm::cont::DataSet MakeTestDataSet()
// Set point scalars
dataSet.AddField(vtkm::cont::make_Field(
"fieldA", vtkm::cont::Field::ASSOC_POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
"fieldA", vtkm::cont::Field::Association::POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldB", vtkm::cont::Field::ASSOC_POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
"fieldB", vtkm::cont::Field::Association::POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldC", vtkm::cont::Field::ASSOC_POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
"fieldC", vtkm::cont::Field::Association::POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
return dataSet;
}

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

@ -142,7 +142,8 @@ void TestStreamLineUniformGrid()
vtkm::cont::DataSet inDataSet;
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vdims);
inDataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
inDataSet.AddField(vtkm::cont::Field("vecData", vtkm::cont::Field::ASSOC_POINTS, fieldArray));
inDataSet.AddField(
vtkm::cont::Field("vecData", vtkm::cont::Field::Association::POINTS, fieldArray));
vtkm::cont::CellSetStructured<3> inCellSet("cells");
inCellSet.SetPointDimensions(vtkm::make_Vec(vdims[0], vdims[1], vdims[2]));

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

@ -74,7 +74,7 @@ public:
vtkm::worklet::Threshold threshold;
OutCellSetType outCellSet = threshold.Run(
cellset, pointvar, vtkm::cont::Field::ASSOC_POINTS, HasValue(60.1f), DeviceAdapter());
cellset, pointvar, vtkm::cont::Field::Association::POINTS, HasValue(60.1f), DeviceAdapter());
VTKM_TEST_ASSERT(outCellSet.GetNumberOfCells() == 1, "Wrong number of cells");
@ -105,7 +105,7 @@ public:
vtkm::worklet::Threshold threshold;
OutCellSetType outCellSet = threshold.Run(
cellset, pointvar, vtkm::cont::Field::ASSOC_POINTS, HasValue(20.1f), DeviceAdapter());
cellset, pointvar, vtkm::cont::Field::Association::POINTS, HasValue(20.1f), DeviceAdapter());
VTKM_TEST_ASSERT(outCellSet.GetNumberOfCells() == 2, "Wrong number of cells");
@ -136,8 +136,11 @@ public:
dataset.GetField("cellvar").GetData().CopyTo(cellvar);
vtkm::worklet::Threshold threshold;
OutCellSetType outCellSet = threshold.Run(
cellset, cellvar, vtkm::cont::Field::ASSOC_CELL_SET, HasValue(100.1f), DeviceAdapter());
OutCellSetType outCellSet = threshold.Run(cellset,
cellvar,
vtkm::cont::Field::Association::CELL_SET,
HasValue(100.1f),
DeviceAdapter());
VTKM_TEST_ASSERT(outCellSet.GetNumberOfCells() == 1, "Wrong number of cells");