diff --git a/vtkm/cont/DataSet.h b/vtkm/cont/DataSet.h
index 3e1b07ada..cfbe1974b 100644
--- a/vtkm/cont/DataSet.h
+++ b/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 });
 
diff --git a/vtkm/cont/Field.cxx b/vtkm/cont/Field.cxx
index 20b633d8e..c54258d62 100644
--- a/vtkm/cont/Field.cxx
+++ b/vtkm/cont/Field.cxx
@@ -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);
diff --git a/vtkm/cont/Field.h b/vtkm/cont/Field.h
index bbd3713fc..9ad266ecd 100644
--- a/vtkm/cont/Field.h
+++ b/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`.
diff --git a/vtkm/cont/PartitionedDataSet.h b/vtkm/cont/PartitionedDataSet.h
index f1f94bfd7..e26cb9523 100644
--- a/vtkm/cont/PartitionedDataSet.h
+++ b/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,
-                                       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
diff --git a/vtkm/cont/testing/UnitTestPartitionedDataSet.cxx b/vtkm/cont/testing/UnitTestPartitionedDataSet.cxx
index 56d9f3408..2f4e412b5 100644
--- a/vtkm/cont/testing/UnitTestPartitionedDataSet.cxx
+++ b/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.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.
diff --git a/vtkm/filter/FilterDataSet.h b/vtkm/filter/FilterDataSet.h
index 972cd83cc..eaabada97 100644
--- a/vtkm/filter/FilterDataSet.h
+++ b/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>
diff --git a/vtkm/filter/FilterDataSetWithField.h b/vtkm/filter/FilterDataSetWithField.h
index 5ae817e35..0fae8fead 100644
--- a/vtkm/filter/FilterDataSetWithField.h
+++ b/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>
diff --git a/vtkm/filter/contour/testing/UnitTestMIRFilter.cxx b/vtkm/filter/contour/testing/UnitTestMIRFilter.cxx
index 810fa2b6c..49dcc1a7f 100644
--- a/vtkm/filter/contour/testing/UnitTestMIRFilter.cxx
+++ b/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_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");
diff --git a/vtkm/filter/density_estimate/Entropy.cxx b/vtkm/filter/density_estimate/Entropy.cxx
index 46b1cfc3c..c80f710f3 100644
--- a/vtkm/filter/density_estimate/Entropy.cxx
+++ b/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;
diff --git a/vtkm/filter/density_estimate/Histogram.cxx b/vtkm/filter/density_estimate/Histogram.cxx
index 66831c520..050a8bf1e 100644
--- a/vtkm/filter/density_estimate/Histogram.cxx
+++ b/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);
diff --git a/vtkm/filter/density_estimate/NDEntropy.cxx b/vtkm/filter/density_estimate/NDEntropy.cxx
index 036f83ba0..9dafad7a7 100644
--- a/vtkm/filter/density_estimate/NDEntropy.cxx
+++ b/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;
 }
diff --git a/vtkm/filter/density_estimate/NDHistogram.cxx b/vtkm/filter/density_estimate/NDHistogram.cxx
index 4f7b40cc3..3c95fa05f 100644
--- a/vtkm/filter/density_estimate/NDHistogram.cxx
+++ b/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;
 }
diff --git a/vtkm/filter/flow/worklet/Field.h b/vtkm/filter/flow/worklet/Field.h
index 3d3124800..3fa246f68 100644
--- a/vtkm/filter/flow/worklet/Field.h
+++ b/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");
   }
 
diff --git a/vtkm/filter/scalar_topology/ContourTreeUniform.cxx b/vtkm/filter/scalar_topology/ContourTreeUniform.cxx
index 69dd6d9c1..e24bb8630 100644
--- a/vtkm/filter/scalar_topology/ContourTreeUniform.cxx
+++ b/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
diff --git a/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx b/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx
index 6bf2b7268..cea1477a4 100644
--- a/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx
+++ b/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);
diff --git a/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.cxx b/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.cxx
index d237dd8b0..5c58a6cc8 100644
--- a/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.cxx
+++ b/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);
 
diff --git a/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx b/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx
index f2adc22cc..391cf4a9c 100644
--- a/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx
+++ b/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);
     });
 
diff --git a/vtkm/filter/scalar_topology/worklet/contourtree_distributed/HierarchicalContourTree.h b/vtkm/filter/scalar_topology/worklet/contourtree_distributed/HierarchicalContourTree.h
index 73040be21..acd5eca2b 100644
--- a/vtkm/filter/scalar_topology/worklet/contourtree_distributed/HierarchicalContourTree.h
+++ b/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(
-    "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
diff --git a/vtkm/filter/testing/UnitTestPartitionedDataSetFilters.cxx b/vtkm/filter/testing/UnitTestPartitionedDataSetFilters.cxx
index b2ab3010d..78c8e4808 100644
--- a/vtkm/filter/testing/UnitTestPartitionedDataSetFilters.cxx
+++ b/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");
     }
   }
 }
diff --git a/vtkm/io/VTKDataSetReaderBase.cxx b/vtkm/io/VTKDataSetReaderBase.cxx
index 3b662714c..ef613a208 100644
--- a/vtkm/io/VTKDataSetReaderBase.cxx
+++ b/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: