Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-07-11 09:33:37 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Change of Field::Association names.

Browse Source
This commit is contained in:
Dave Pugmire 2022-08-29 06:40:42 -04:00
parent 00b6657689
commit f69e598225
20 changed files with 91 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vtkm/cont/DataSet.h
View File

@ -354,7 +354,7 @@ public:
private:
std::vector<vtkm::cont::CoordinateSystem> CoordSystems;
vtkm::cont::internal::FieldCollection Fields =
vtkm::cont::internal::FieldCollection({ vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::internal::FieldCollection({ vtkm::cont::Field::Association::WholeDataSet,
vtkm::cont::Field::Association::Points,
vtkm::cont::Field::Association::Cells });

11
vtkm/cont/Field.cxx
View File

@ -88,8 +88,8 @@ void Field::PrintSummary(std::ostream& out) const
case Association::Any:
out << "Any ";
break;
case Association::WholeMesh:
out << "Mesh ";
case Association::WholeDataSet:
out << "WholeDataSet ";
break;
case Association::Points:
out << "Points ";
@ -97,8 +97,11 @@ void Field::PrintSummary(std::ostream& out) const
case Association::Cells:
out << "Cells ";
break;
case Association::AllPartitions:
out << "AllPartitions ";
case Association::Partitions:
out << "Partitions ";
break;
case Association::Global:
out << "Global ";
break;
}
this->Data.PrintSummary(out);

16
vtkm/cont/Field.h
View File

@ -34,15 +34,18 @@ public:
enum struct Association
{
Any,
WholeMesh,
WholeDataSet,
Points,
Cells,
Partitions,
AllPartitions,
Global,
ANY VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::Any.") = Any,
WHOLE_MESH VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::WholeMesh.") = WholeMesh,
WHOLE_MESH VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::WholeMesh.") =
WholeDataSet,
POINTS VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::Points.") = Points,
CELL_SET VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::Cells.") = Cells
CELL_SET VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::Cells.") = Cells,
WholeMesh VTKM_DEPRECATED(1.9, "Use vtkm::cont::Field::Association::WholeDataSet.") =
WholeDataSet
};
VTKM_CONT
@ -69,7 +72,10 @@ public:
VTKM_CONT bool IsFieldCell() const { return this->FieldAssociation == Association::Cells; }
VTKM_CONT bool IsFieldPoint() const { return this->FieldAssociation == Association::Points; }
VTKM_CONT bool IsFieldGlobal() const { return this->FieldAssociation == Association::WholeMesh; }
VTKM_CONT bool IsFieldGlobal() const
{
return this->FieldAssociation == Association::WholeDataSet;
}
/// Returns true if the array of the field has a value type that matches something in
/// `VTKM_FIELD_TYPE_LIST` and a storage that matches something in `VTKM_FIELD_STORAGE_LIST`.

41
vtkm/cont/PartitionedDataSet.h
View File

@ -108,27 +108,24 @@ public:
VTKM_CONT void AddField(const Field& field) { this->Fields.AddField(field); }
template <typename T, typename Storage>
VTKM_CONT void AddAllPartitionsField(const std::string& fieldName,
const vtkm::cont::ArrayHandle<T, Storage>& field)
VTKM_CONT void AddGlobalField(const std::string& fieldName,
const vtkm::cont::ArrayHandle<T, Storage>& field)
{
this->AddField(vtkm::cont::Field(fieldName, vtkm::cont::Field::Association::Global, field));
}
template <typename T>
VTKM_CONT void AddGlobalField(const std::string& fieldName, const std::vector<T>& field)
{
this->AddField(
vtkm::cont::Field(fieldName, vtkm::cont::Field::Association::AllPartitions, field));
make_Field(fieldName, vtkm::cont::Field::Association::Global, field, vtkm::CopyFlag::On));
}
template <typename T>
VTKM_CONT void AddAllPartitionsField(const std::string& fieldName, const std::vector<T>& field)
VTKM_CONT void AddGlobalField(const std::string& fieldName, const T* field, const vtkm::Id& n)
{
this->AddField(make_Field(
fieldName, vtkm::cont::Field::Association::AllPartitions, field, vtkm::CopyFlag::On));
}
template <typename T>
VTKM_CONT void AddAllPartitionsField(const std::string& fieldName,
const T* field,
const vtkm::Id& n)
{
this->AddField(make_Field(
fieldName, vtkm::cont::Field::Association::AllPartitions, field, n, vtkm::CopyFlag::On));
this->AddField(
make_Field(fieldName, vtkm::cont::Field::Association::Global, field, n, vtkm::CopyFlag::On));
}
template <typename T, typename Storage>
@ -175,9 +172,9 @@ public:
}
VTKM_CONT
const vtkm::cont::Field& GetAllPartitionsField(const std::string& name) const
const vtkm::cont::Field& GetGlobalField(const std::string& name) const
{
return this->GetField(name, vtkm::cont::Field::Association::AllPartitions);
return this->GetField(name, vtkm::cont::Field::Association::Global);
}
VTKM_CONT
@ -187,9 +184,9 @@ public:
}
VTKM_CONT
vtkm::cont::Field& GetAllPartitionsField(const std::string& name)
vtkm::cont::Field& GetGlobalField(const std::string& name)
{
return this->GetField(name, vtkm::cont::Field::Association::AllPartitions);
return this->GetField(name, vtkm::cont::Field::Association::Global);
}
VTKM_CONT
@ -206,9 +203,9 @@ public:
}
VTKM_CONT
bool HasAllPartitionsField(const std::string& name) const
bool HasGlobalField(const std::string& name) const
{
return (this->Fields.GetFieldIndex(name, vtkm::cont::Field::Association::AllPartitions) != -1);
return (this->Fields.GetFieldIndex(name, vtkm::cont::Field::Association::Global) != -1);
}
VTKM_CONT
@ -245,7 +242,7 @@ private:
std::vector<vtkm::cont::DataSet> Partitions;
vtkm::cont::internal::FieldCollection Fields = vtkm::cont::internal::FieldCollection(
{ vtkm::cont::Field::Association::Partitions, vtkm::cont::Field::Association::AllPartitions });
{ vtkm::cont::Field::Association::Partitions, vtkm::cont::Field::Association::Global });
};
}
} // namespace vtkm::cont

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

@ -43,7 +43,7 @@ static void PartitionedDataSetTest()
auto idsField = vtkm::cont::make_Field(
"ids", vtkm::cont::Field::Association::Partitions, ids, vtkm::CopyFlag::On);
auto pdsVar = vtkm::cont::make_Field(
"pds_var", vtkm::cont::Field::Association::AllPartitions, ids, vtkm::CopyFlag::On);
"pds_var", vtkm::cont::Field::Association::Partitions, ids, vtkm::CopyFlag::On);
pds.AddField(idsField);
pds.AddField(pdsVar);
@ -110,7 +110,7 @@ static void PartitionedDataSetTest()
pdsVar.GetRange(&SourceRange);
pds.GetField("pds_var").GetRange(&TestRange);
VTKM_TEST_ASSERT(TestRange == SourceRange, "AllPartitions field values incorrect");
VTKM_TEST_ASSERT(TestRange == SourceRange, "Global field values incorrect");
vtkm::cont::PartitionedDataSet testblocks1;
std::vector<vtkm::cont::DataSet> partitions = pds.GetPartitions();
@ -162,7 +162,7 @@ static void PartitionedDataSetFieldTest()
auto idField = vtkm::cont::make_Field(
"id", vtkm::cont::Field::Association::Partitions, ids, vtkm::CopyFlag::Off);
auto gScalar = vtkm::cont::make_Field(
"global_scalar", vtkm::cont::Field::Association::AllPartitions, gs, vtkm::CopyFlag::Off);
"global_scalar", vtkm::cont::Field::Association::Global, gs, vtkm::CopyFlag::Off);
pds.AddField(idField);
pds.AddField(gScalar);
@ -170,26 +170,25 @@ static void PartitionedDataSetFieldTest()
else if (i == 1) //array handle
{
pds.AddPartitionsField("id", idsArr);
pds.AddAllPartitionsField("global_scalar", gsArr);
pds.AddGlobalField("global_scalar", gsArr);
}
else if (i == 2) //std::vector
{
pds.AddPartitionsField("id", ids);
pds.AddAllPartitionsField("global_scalar", gs);
pds.AddGlobalField("global_scalar", gs);
}
else if (i == 3) //pointer
{
pds.AddPartitionsField("id", ids.data(), 2);
pds.AddAllPartitionsField("global_scalar", gs.data(), 1);
pds.AddGlobalField("global_scalar", gs.data(), 1);
}
//Validate each method.
VTKM_TEST_ASSERT(pds.GetNumberOfFields() == 2, "Wrong number of fields");
//Make sure fields are there and of the right type.
VTKM_TEST_ASSERT(pds.HasField("id") && pds.HasPartitionsField("id"), "id field misssing.");
VTKM_TEST_ASSERT(pds.HasField("global_scalar") && pds.HasAllPartitionsField("global_scalar"),
"global_scalar field misssing.");
VTKM_TEST_ASSERT(pds.HasPartitionsField("id"), "id field misssing.");
VTKM_TEST_ASSERT(pds.HasGlobalField("global_scalar"), "global_scalar field misssing.");
for (int j = 0; j < 2; j++)
{
@ -203,7 +202,7 @@ static void PartitionedDataSetFieldTest()
else
{
f0 = pds.GetPartitionsField("id");
f1 = pds.GetAllPartitionsField("global_scalar");
f1 = pds.GetGlobalField("global_scalar");
}
//Check the values.

2
vtkm/filter/FilterDataSet.h
View File

@ -44,7 +44,7 @@ public:
//From the field we can extract the association component
// Association::Any -> unable to map
// Association::WholeMesh -> (I think this is points)
// Association::WholeDataSet -> (I think this is points)
// Association::Points -> map using point mapping
// Association::Cells -> how do we map this?
template <typename DerivedPolicy>

2
vtkm/filter/FilterDataSetWithField.h
View File

@ -70,7 +70,7 @@ public:
//From the field we can extract the association component
// Association::Any -> unable to map
// Association::WholeMesh -> (I think this is points)
// Association::WholeDataSet -> (I think this is points)
// Association::Points -> map using point mapping
// Association::Cells -> how do we map this?
template <typename DerivedPolicy>

8
vtkm/filter/contour/testing/UnitTestMIRFilter.cxx
View File

@ -93,8 +93,8 @@ vtkm::cont::DataSet GetTestDataSet()
vtkm::cont::DataSet ds = dsb.Create(points, shapes, numberofInd, connections);
ds.AddField(vtkm::cont::Field("scatter_pos", vtkm::cont::Field::Association::Cells, offsets));
ds.AddField(vtkm::cont::Field("scatter_len", vtkm::cont::Field::Association::Cells, lengths));
ds.AddField(vtkm::cont::Field("scatter_ids", vtkm::cont::Field::Association::WholeMesh, ids));
ds.AddField(vtkm::cont::Field("scatter_vfs", vtkm::cont::Field::Association::WholeMesh, vfs));
ds.AddField(vtkm::cont::Field("scatter_ids", vtkm::cont::Field::Association::WholeDataSet, ids));
ds.AddField(vtkm::cont::Field("scatter_vfs", vtkm::cont::Field::Association::WholeDataSet, vfs));
return ds;
}
@ -201,9 +201,9 @@ void TestMIRVenn250()
data.AddField(vtkm::cont::Field("scatter_pos", vtkm::cont::Field::Association::Cells, offset));
data.AddField(vtkm::cont::Field("scatter_len", vtkm::cont::Field::Association::Cells, length));
data.AddField(
vtkm::cont::Field("scatter_ids", vtkm::cont::Field::Association::WholeMesh, matIds));
vtkm::cont::Field("scatter_ids", vtkm::cont::Field::Association::WholeDataSet, matIds));
data.AddField(
vtkm::cont::Field("scatter_vfs", vtkm::cont::Field::Association::WholeMesh, matVFs));
vtkm::cont::Field("scatter_vfs", vtkm::cont::Field::Association::WholeDataSet, matVFs));
vtkm::filter::contour::MIRFilter mir;
mir.SetIDWholeSetName("scatter_ids");

2
vtkm/filter/density_estimate/Entropy.cxx
View File

@ -42,7 +42,7 @@ VTKM_CONT vtkm::cont::DataSet Entropy::DoExecute(const vtkm::cont::DataSet& inDa
vtkm::cont::DataSet output;
output.AddField(
{ this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, entropy });
{ this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, entropy });
// The output is a "summary" of the input, no need to map fields
return output;

4
vtkm/filter/density_estimate/Histogram.cxx
View File

@ -215,7 +215,7 @@ VTKM_CONT vtkm::cont::DataSet Histogram::DoExecute(const vtkm::cont::DataSet& in
vtkm::cont::DataSet output;
output.AddField(
{ this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, binArray });
{ this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, binArray });
// The output is a "summary" of the input, no need to map fields
return output;
@ -265,7 +265,7 @@ VTKM_CONT void Histogram::PostExecute(const vtkm::cont::PartitionedDataSet&,
vtkm::cont::DataSet output;
vtkm::cont::Field rfield(
this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, helper.ReduceAll());
this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, helper.ReduceAll());
output.AddField(rfield);
result = vtkm::cont::PartitionedDataSet(output);

2
vtkm/filter/density_estimate/NDEntropy.cxx
View File

@ -42,7 +42,7 @@ VTKM_CONT vtkm::cont::DataSet NDEntropy::DoExecute(const vtkm::cont::DataSet& in
entropyHandle.WritePortal().Set(0, entropy);
vtkm::cont::DataSet outputData;
outputData.AddField({ "Entropy", vtkm::cont::Field::Association::WholeMesh, entropyHandle });
outputData.AddField({ "Entropy", vtkm::cont::Field::Association::WholeDataSet, entropyHandle });
// The output is a "summary" of the input, no need to map fields
return outputData;
}

4
vtkm/filter/density_estimate/NDHistogram.cxx
View File

@ -61,9 +61,9 @@ VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(const vtkm::cont::DataSet&
for (size_t i = 0; i < binIds.size(); i++)
{
outputData.AddField(
{ this->FieldNames[i], vtkm::cont::Field::Association::WholeMesh, binIds[i] });
{ this->FieldNames[i], vtkm::cont::Field::Association::WholeDataSet, binIds[i] });
}
outputData.AddField({ "Frequency", vtkm::cont::Field::Association::WholeMesh, freqs });
outputData.AddField({ "Frequency", vtkm::cont::Field::Association::WholeDataSet, freqs });
// The output is a "summary" of the input, no need to map fields
return outputData;
}

2
vtkm/filter/flow/worklet/Field.h
View File

@ -152,7 +152,7 @@ public:
: FieldValues(fieldValues)
, Assoc(assoc)
{
if (assoc == Association::Any || assoc == Association::WholeMesh)
if (assoc != Association::Points && assoc != Association::Cells)
throw("Unsupported field association");
}

4
vtkm/filter/scalar_topology/ContourTreeUniform.cxx
View File

@ -96,7 +96,7 @@ vtkm::cont::DataSet ContourTreeMesh2D::DoExecute(const vtkm::cont::DataSet& inpu
this->CastAndCallScalarField(field, resolveType);
return this->CreateResultField(
input, this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, saddlePeak);
input, this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, saddlePeak);
}
//-----------------------------------------------------------------------------
@ -132,7 +132,7 @@ vtkm::cont::DataSet ContourTreeMesh3D::DoExecute(const vtkm::cont::DataSet& inpu
this->CastAndCallScalarField(field, resolveType);
return this->CreateResultField(
input, this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, saddlePeak);
input, this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, saddlePeak);
}
} // namespace scalar_topology
} // namespace filter

6
vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx
View File

@ -189,10 +189,10 @@ vtkm::cont::DataSet ContourTreeAugmented::DoExecute(const vtkm::cont::DataSet& i
// DataSet without any coordinate system etc.
result = this->CreateResultField(input,
this->GetOutputFieldName(),
vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::Field::Association::WholeDataSet,
sortedValues);
// vtkm::cont::Field rfield(
// this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, sortedValues);
// this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, sortedValues);
// result.AddField(rfield);
// return result;
}
@ -446,7 +446,7 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(const vtkm::cont::Partitioned
// TODO the result we return for the parallel and serial case are different right now. This should be made consistent. However, only in the parallel case are we useing the result output
vtkm::cont::DataSet temp;
vtkm::cont::Field rfield(this->GetOutputFieldName(),
vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::Field::Association::WholeDataSet,
contourTreeMeshOut.SortedValues);
temp.AddField(rfield);
output = vtkm::cont::PartitionedDataSet(temp);

8
vtkm/filter/scalar_topology/ContourTreeUniformDistributed.cxx
View File

@ -784,10 +784,10 @@ inline VTKM_CONT void ContourTreeUniformDistributed::ComputeVolumeMetric(
hierarchical_hyper_sweep_master.foreach (
[&](HyperSweepBlock* b, const vtkmdiy::Master::ProxyWithLink&) {
vtkm::cont::Field intrinsicVolumeField(
"IntrinsicVolume", vtkm::cont::Field::Association::WholeMesh, b->IntrinsicVolume);
"IntrinsicVolume", vtkm::cont::Field::Association::WholeDataSet, b->IntrinsicVolume);
hierarchicalTreeOutputDataSet[b->LocalBlockNo].AddField(intrinsicVolumeField);
vtkm::cont::Field dependentVolumeField(
"DependentVolume", vtkm::cont::Field::Association::WholeMesh, b->DependentVolume);
"DependentVolume", vtkm::cont::Field::Association::WholeDataSet, b->DependentVolume);
hierarchicalTreeOutputDataSet[b->LocalBlockNo].AddField(dependentVolumeField);
#ifdef DEBUG_PRINT
VTKM_LOG_S(this->TreeLogLevel, "Block " << b->GlobalBlockId);
@ -1210,7 +1210,7 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
auto vtkmGlobalBlockIdWP = vtkmGlobalBlockIdAH.WritePortal();
vtkmGlobalBlockIdWP.Set(0, blockData->GlobalBlockId);
vtkm::cont::Field vtkmGlobalBlockIdField(
"vtkmGlobalBlockId", vtkm::cont::Field::Association::WholeMesh, vtkmGlobalBlockIdAH);
"vtkmGlobalBlockId", vtkm::cont::Field::Association::WholeDataSet, vtkmGlobalBlockIdAH);
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(vtkmGlobalBlockIdField);
vtkm::cont::ArrayHandle<vtkm::Id> vtkmBlocksPerDimensionAH;
vtkmBlocksPerDimensionAH.Allocate(3);
@ -1219,7 +1219,7 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
vtkmBlocksPerDimensionWP.Set(1, this->BlocksPerDimension[1]);
vtkmBlocksPerDimensionWP.Set(2, this->BlocksPerDimension[2]);
vtkm::cont::Field vtkmBlocksPerDimensionField("vtkmBlocksPerDimension",
vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::Field::Association::WholeDataSet,
vtkmBlocksPerDimensionAH);
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(vtkmBlocksPerDimensionField);

2
vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx
View File

@ -263,7 +263,7 @@ VTKM_CONT vtkm::cont::PartitionedDataSet DistributedBranchDecompositionFilter::D
branch_decomposition_master.foreach (
[&](BranchDecompositionBlock* b, const vtkmdiy::Master::ProxyWithLink&) {
vtkm::cont::Field branchRootField(
"BranchRoots", vtkm::cont::Field::Association::WholeMesh, b->BranchRoots);
"BranchRoots", vtkm::cont::Field::Association::WholeDataSet, b->BranchRoots);
outputDataSets[b->LocalBlockNo].AddField(branchRootField);
});

32
vtkm/filter/scalar_topology/worklet/contourtree_distributed/HierarchicalContourTree.h
View File

@ -1001,38 +1001,40 @@ template <typename FieldType>
void HierarchicalContourTree<FieldType>::AddToVTKMDataSet(vtkm::cont::DataSet& ds) const
{
// Create data set from output
vtkm::cont::Field regularNodeGlobalIdsField(
"RegularNodeGlobalIds", vtkm::cont::Field::Association::WholeMesh, this->RegularNodeGlobalIds);
vtkm::cont::Field regularNodeGlobalIdsField("RegularNodeGlobalIds",
vtkm::cont::Field::Association::WholeDataSet,
this->RegularNodeGlobalIds);
ds.AddField(regularNodeGlobalIdsField);
vtkm::cont::Field dataValuesField(
"DataValues", vtkm::cont::Field::Association::WholeMesh, this->DataValues);
"DataValues", vtkm::cont::Field::Association::WholeDataSet, this->DataValues);
ds.AddField(dataValuesField);
vtkm::cont::Field regularNodeSortOrderField(
"RegularNodeSortOrder", vtkm::cont::Field::Association::WholeMesh, this->RegularNodeSortOrder);
vtkm::cont::Field regularNodeSortOrderField("RegularNodeSortOrder",
vtkm::cont::Field::Association::WholeDataSet,
this->RegularNodeSortOrder);
ds.AddField(regularNodeSortOrderField);
vtkm::cont::Field regular2SupernodeField(
"Regular2Supernode", vtkm::cont::Field::Association::WholeMesh, this->Regular2Supernode);
"Regular2Supernode", vtkm::cont::Field::Association::WholeDataSet, this->Regular2Supernode);
ds.AddField(regular2SupernodeField);
vtkm::cont::Field superparentsField(
"Superparents", vtkm::cont::Field::Association::WholeMesh, this->Superparents);
"Superparents", vtkm::cont::Field::Association::WholeDataSet, this->Superparents);
ds.AddField(superparentsField);
vtkm::cont::Field supernodesField(
"Supernodes", vtkm::cont::Field::Association::WholeMesh, this->Supernodes);
"Supernodes", vtkm::cont::Field::Association::WholeDataSet, this->Supernodes);
ds.AddField(supernodesField);
vtkm::cont::Field superarcsField(
"Superarcs", vtkm::cont::Field::Association::WholeMesh, this->Superarcs);
"Superarcs", vtkm::cont::Field::Association::WholeDataSet, this->Superarcs);
ds.AddField(superarcsField);
vtkm::cont::Field hyperparentsField(
"Hyperparents", vtkm::cont::Field::Association::WholeMesh, this->Hyperparents);
"Hyperparents", vtkm::cont::Field::Association::WholeDataSet, this->Hyperparents);
ds.AddField(hyperparentsField);
vtkm::cont::Field super2HypernodeField(
"Super2Hypernode", vtkm::cont::Field::Association::WholeMesh, this->Super2Hypernode);
"Super2Hypernode", vtkm::cont::Field::Association::WholeDataSet, this->Super2Hypernode);
ds.AddField(super2HypernodeField);
vtkm::cont::Field whichRoundField(
"WhichRound", vtkm::cont::Field::Association::WholeMesh, this->WhichRound);
"WhichRound", vtkm::cont::Field::Association::WholeDataSet, this->WhichRound);
ds.AddField(whichRoundField);
vtkm::cont::Field whichIterationField(
"WhichIteration", vtkm::cont::Field::Association::WholeMesh, this->WhichIteration);
"WhichIteration", vtkm::cont::Field::Association::WholeDataSet, this->WhichIteration);
ds.AddField(whichIterationField);
// TODO/FIXME: See what other fields we need to add
vtkm::worklet::contourtree_augmented::IdArrayType firstSupernodePerIterationComponents;
@ -1042,12 +1044,12 @@ void HierarchicalContourTree<FieldType>::AddToVTKMDataSet(vtkm::cont::DataSet& d
firstSupernodePerIterationOffsets);
vtkm::cont::Field firstSupernodePerIterationComponentsField(
"FirstSupernodePerIterationComponents",
vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::Field::Association::WholeDataSet,
firstSupernodePerIterationComponents);
ds.AddField(firstSupernodePerIterationComponentsField);
vtkm::cont::Field firstSupernodePerIterationOffsetsField(
"FirstSupernodePerIterationOffsets",
vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::Field::Association::WholeDataSet,
firstSupernodePerIterationOffsets);
ds.AddField(firstSupernodePerIterationOffsetsField);
// TODO/FIXME: It seems we may only need the counts for the first iteration, so check, which

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

@ -130,7 +130,7 @@ void TestPartitionedDataSetFilters()
std::vector<vtkm::Id> ids = { 0, 1, 2 };
std::vector<vtkm::FloatDefault> scalar = { 10.0f };
partitions.AddPartitionsField("ids", ids);
partitions.AddAllPartitionsField("scalar", scalar);
partitions.AddGlobalField("scalar", scalar);
//On second iteration, only allow "ids" to pass through.
cellAverage.GetFieldsToPass().ClearFields();
@ -161,7 +161,7 @@ void TestPartitionedDataSetFilters()
if (fields.empty() || std::find(fields.begin(), fields.end(), "scalar") != fields.end())
{
VTKM_TEST_ASSERT(result.HasAllPartitionsField("scalar"), "Missing field on result");
VTKM_TEST_ASSERT(result.HasGlobalField("scalar"), "Missing field on result");
auto field1 = result.GetField("scalar");
auto portal1 =
field1.GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::FloatDefault>>().ReadPortal();
@ -171,7 +171,7 @@ void TestPartitionedDataSetFilters()
}
else
{
VTKM_TEST_ASSERT(!result.HasAllPartitionsField("scalar"), "Field should not be on result");
VTKM_TEST_ASSERT(!result.HasGlobalField("scalar"), "Field should not be on result");
}
}
}

2
vtkm/io/VTKDataSetReaderBase.cxx
View File

@ -499,7 +499,7 @@ void VTKDataSetReaderBase::AddField(const std::string& name,
switch (association)
{
case vtkm::cont::Field::Association::Points:
case vtkm::cont::Field::Association::WholeMesh:
case vtkm::cont::Field::Association::WholeDataSet:
this->DataSet.AddField(vtkm::cont::Field(name, association, data));
break;
case vtkm::cont::Field::Association::Cells: