Change of Field::Association names.

vtkm/cont/DataSet.h

@@ -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 });
 

vtkm/cont/Field.cxx

@@ -88,8 +88,8 @@ void Field::PrintSummary(std::ostream& out) const
     case Association::Any:
       out << "Any ";
       break;
-    case Association::WholeMesh:
+    case Association::WholeDataSet:
-      out << "Mesh ";
+      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:
+    case Association::Partitions:
-      out << "AllPartitions ";
+      out << "Partitions ";
+      break;
+    case Association::Global:
+      out << "Global ";
       break;
   }
   this->Data.PrintSummary(out);

vtkm/cont/Field.h

@@ -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`.

vtkm/cont/PartitionedDataSet.h

@@ -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,
+  VTKM_CONT void AddGlobalField(const std::string& fieldName,
-                                       const vtkm::cont::ArrayHandle<T, Storage>& field)
+                                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(
+    this->AddField(
-      fieldName, vtkm::cont::Field::Association::AllPartitions, field, vtkm::CopyFlag::On));
+      make_Field(fieldName, vtkm::cont::Field::Association::Global, field, n, 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));
   }
 
   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

vtkm/cont/testing/UnitTestPartitionedDataSet.cxx

@@ -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.HasPartitionsField("id"), "id field misssing.");
-    VTKM_TEST_ASSERT(pds.HasField("global_scalar") && pds.HasAllPartitionsField("global_scalar"),
+    VTKM_TEST_ASSERT(pds.HasGlobalField("global_scalar"), "global_scalar field misssing.");
-                     "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.

vtkm/filter/FilterDataSet.h

@@ -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>

vtkm/filter/FilterDataSetWithField.h

@@ -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>

vtkm/filter/contour/testing/UnitTestMIRFilter.cxx

@@ -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_ids", vtkm::cont::Field::Association::WholeDataSet, ids));
-  ds.AddField(vtkm::cont::Field("scatter_vfs", vtkm::cont::Field::Association::WholeMesh, vfs));
+  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");

vtkm/filter/density_estimate/Entropy.cxx

@@ -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;

vtkm/filter/density_estimate/Histogram.cxx

@@ -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);

vtkm/filter/density_estimate/NDEntropy.cxx

@@ -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;
 }

vtkm/filter/density_estimate/NDHistogram.cxx

@@ -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;
 }

vtkm/filter/flow/worklet/Field.h

@@ -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");
   }
 

vtkm/filter/scalar_topology/ContourTreeUniform.cxx

@@ -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

vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx

@@ -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);

vtkm/filter/scalar_topology/ContourTreeUniformDistributed.cxx

@@ -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);
 

vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx

@@ -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);
     });
 

vtkm/filter/scalar_topology/worklet/contourtree_distributed/HierarchicalContourTree.h

@@ -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(
+  vtkm::cont::Field regularNodeGlobalIdsField("RegularNodeGlobalIds",
-    "RegularNodeGlobalIds", vtkm::cont::Field::Association::WholeMesh, this->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(
+  vtkm::cont::Field regularNodeSortOrderField("RegularNodeSortOrder",
-    "RegularNodeSortOrder", vtkm::cont::Field::Association::WholeMesh, this->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

vtkm/filter/testing/UnitTestPartitionedDataSetFilters.cxx

@@ -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");
     }
   }
 }

vtkm/io/VTKDataSetReaderBase.cxx

@@ -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: