From 13c264b99c94dbfd465db296680c756739882cf1 Mon Sep 17 00:00:00 2001
From: Nicole Marsaglia <marsagli@uoreogn.edu>
Date: Wed, 27 Apr 2022 12:46:34 -0700
Subject: [PATCH 1/9] update deprecations

---
 src/vtkh/utils/vtkm_dataset_info.cpp | 40 ++++++++++++++--------------
 src/vtkh/utils/vtkm_dataset_info.hpp |  8 +++---
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/vtkh/utils/vtkm_dataset_info.cpp b/src/vtkh/utils/vtkm_dataset_info.cpp
index 9cdf2f47..b0dd20eb 100644
--- a/src/vtkh/utils/vtkm_dataset_info.cpp
+++ b/src/vtkh/utils/vtkm_dataset_info.cpp
@@ -15,7 +15,7 @@ namespace vtkh
 bool VTKMDataSetInfo::IsStructured(const vtkm::cont::DataSet &data_set,
                                    int &topo_dims)
 {
-  const vtkm::cont::DynamicCellSet cell_set = data_set.GetCellSet();
+  const vtkm::cont::UnknownCellSet cell_set = data_set.GetCellSet();
   return IsStructured(cell_set, topo_dims);
 }
 
@@ -26,22 +26,22 @@ VTKMDataSetInfo::IsStructured(const vtkm::rendering::Actor &actor, int &topo_dim
 }
 
 bool
-VTKMDataSetInfo::IsStructured(const vtkm::cont::DynamicCellSet &cell_set, int &topo_dims)
+VTKMDataSetInfo::IsStructured(const vtkm::cont::UnknownCellSet &cell_set, int &topo_dims)
 {
   bool is_structured = false;
   topo_dims = -1;
 
-  if(cell_set.IsSameType(vtkm::cont::CellSetStructured<1>()))
+  if(cell_set.IsType<vtkm::cont::CellSetStructured<1>>())
   {
     is_structured = true;
     topo_dims = 1;
   }
-  else if(cell_set.IsSameType(vtkm::cont::CellSetStructured<2>()))
+  else if(cell_set.IsType<vtkm::cont::CellSetStructured<2>>())
   {
     is_structured = true;
     topo_dims = 2;
   }
-  else if(cell_set.IsSameType(vtkm::cont::CellSetStructured<3>()))
+  else if(cell_set.IsType<vtkm::cont::CellSetStructured<3>>())
   {
     is_structured = true;
     topo_dims = 3;
@@ -103,7 +103,7 @@ VTKMDataSetInfo::IsUniform(const vtkm::cont::CoordinateSystem &coords)
 bool
 VTKMDataSetInfo::GetPointDims(const vtkm::cont::DataSet &data_set, int *dims)
 {
-  const vtkm::cont::DynamicCellSet cell_set = data_set.GetCellSet();
+  const vtkm::cont::UnknownCellSet cell_set = data_set.GetCellSet();
   return GetPointDims(cell_set, dims);
 }
 
@@ -114,7 +114,7 @@ VTKMDataSetInfo::GetPointDims(const vtkm::rendering::Actor &actor, int *dims)
 }
 
 bool
-VTKMDataSetInfo::GetPointDims(const vtkm::cont::DynamicCellSet &cell_set, int *dims)
+VTKMDataSetInfo::GetPointDims(const vtkm::cont::UnknownCellSet &cell_set, int *dims)
 {
   int topo_dims;
   bool is_structured = IsStructured(cell_set, topo_dims);
@@ -131,14 +131,14 @@ VTKMDataSetInfo::GetPointDims(const vtkm::cont::DynamicCellSet &cell_set, int *d
   if(topo_dims == 1)
   {
     vtkm::cont::CellSetStructured<1> cell_set1 =
-        cell_set.Cast<vtkm::cont::CellSetStructured<1>>();
+        cell_set.AsCellSet<vtkm::cont::CellSetStructured<1>>();
     vtkm::Id dims1 = cell_set1.GetPointDimensions();
     dims[0] = dims1;
   }
   else if(topo_dims == 2)
   {
     vtkm::cont::CellSetStructured<2> cell_set2 =
-        cell_set.Cast<vtkm::cont::CellSetStructured<2>>();
+        cell_set.AsCellSet<vtkm::cont::CellSetStructured<2>>();
     vtkm::Id2 dims2 = cell_set2.GetPointDimensions();
     dims[0] = dims2[0];
     dims[1] = dims2[1];
@@ -146,7 +146,7 @@ VTKMDataSetInfo::GetPointDims(const vtkm::cont::DynamicCellSet &cell_set, int *d
   else if(topo_dims == 3)
   {
     vtkm::cont::CellSetStructured<3> cell_set3 =
-        cell_set.Cast<vtkm::cont::CellSetStructured<3>>();
+        cell_set.AsCellSet<vtkm::cont::CellSetStructured<3>>();
     vtkm::Id3 dims3 = cell_set3.GetPointDimensions();
     dims[0] = dims3[0];
     dims[1] = dims3[1];
@@ -160,7 +160,7 @@ VTKMDataSetInfo::GetPointDims(const vtkm::cont::DynamicCellSet &cell_set, int *d
 bool
 VTKMDataSetInfo::GetCellDims(const vtkm::cont::DataSet &data_set, int *dims)
 {
-  const vtkm::cont::DynamicCellSet cell_set = data_set.GetCellSet();
+  const vtkm::cont::UnknownCellSet cell_set = data_set.GetCellSet();
   return GetCellDims(cell_set, dims);
 }
 
@@ -171,7 +171,7 @@ VTKMDataSetInfo::GetCellDims(const vtkm::rendering::Actor &actor, int *dims)
 }
 
 bool
-VTKMDataSetInfo::GetCellDims(const vtkm::cont::DynamicCellSet &cell_set, int *dims)
+VTKMDataSetInfo::GetCellDims(const vtkm::cont::UnknownCellSet &cell_set, int *dims)
 {
   int topo_dims;
   bool is_structured = IsStructured(cell_set, topo_dims);
@@ -188,14 +188,14 @@ VTKMDataSetInfo::GetCellDims(const vtkm::cont::DynamicCellSet &cell_set, int *di
   if(topo_dims == 1)
   {
     vtkm::cont::CellSetStructured<1> cell_set1 =
-        cell_set.Cast<vtkm::cont::CellSetStructured<1>>();
+        cell_set.AsCellSet<vtkm::cont::CellSetStructured<1>>();
     vtkm::Id dims1 = cell_set1.GetCellDimensions();
     dims[0] = dims1;
   }
   else if(topo_dims == 2)
   {
     vtkm::cont::CellSetStructured<2> cell_set2 =
-        cell_set.Cast<vtkm::cont::CellSetStructured<2>>();
+        cell_set.AsCellSet<vtkm::cont::CellSetStructured<2>>();
     vtkm::Id2 dims2 = cell_set2.GetCellDimensions();
     dims[0] = dims2[0];
     dims[1] = dims2[1];
@@ -203,7 +203,7 @@ VTKMDataSetInfo::GetCellDims(const vtkm::cont::DynamicCellSet &cell_set, int *di
   else if(topo_dims == 3)
   {
     vtkm::cont::CellSetStructured<3> cell_set3 =
-        cell_set.Cast<vtkm::cont::CellSetStructured<3>>();
+        cell_set.AsCellSet<vtkm::cont::CellSetStructured<3>>();
     vtkm::Id3 dims3 = cell_set3.GetCellDimensions();
     dims[0] = dims3[0];
     dims[1] = dims3[1];
@@ -215,7 +215,7 @@ VTKMDataSetInfo::GetCellDims(const vtkm::cont::DynamicCellSet &cell_set, int *di
 }
 
 bool
-VTKMDataSetInfo::IsSingleCellShape(const vtkm::cont::DynamicCellSet &cell_set, vtkm::UInt8 &shape_id)
+VTKMDataSetInfo::IsSingleCellShape(const vtkm::cont::UnknownCellSet &cell_set, vtkm::UInt8 &shape_id)
 {
   int dims;
   shape_id = 0;
@@ -228,15 +228,15 @@ VTKMDataSetInfo::IsSingleCellShape(const vtkm::cont::DynamicCellSet &cell_set, v
   else
   {
     // we have an explicit cell set so we have to look deeper
-    if(cell_set.IsSameType(vtkm::cont::CellSetSingleType<>()))
+    if(cell_set.IsType<vtkm::cont::CellSetSingleType<>>())
     {
-      vtkm::cont::CellSetSingleType<> single = cell_set.Cast<vtkm::cont::CellSetSingleType<>>();
+      vtkm::cont::CellSetSingleType<> single = cell_set.AsCellSet<vtkm::cont::CellSetSingleType<>>();
       is_single_shape = true;
       shape_id = single.GetCellShape(0);
     }
-    else if(cell_set.IsSameType(vtkm::cont::CellSetExplicit<>()))
+    else if(cell_set.IsType<vtkm::cont::CellSetExplicit<>>())
     {
-      vtkm::cont::CellSetExplicit<> exp = cell_set.Cast<vtkm::cont::CellSetExplicit<>>();
+      vtkm::cont::CellSetExplicit<> exp = cell_set.AsCellSet<vtkm::cont::CellSetExplicit<>>();
       const vtkm::cont::ArrayHandle<vtkm::UInt8> shapes = exp.GetShapesArray(
         vtkm::TopologyElementTagCell(),
         vtkm::TopologyElementTagPoint());
diff --git a/src/vtkh/utils/vtkm_dataset_info.hpp b/src/vtkh/utils/vtkm_dataset_info.hpp
index 9df25a68..5d878351 100644
--- a/src/vtkh/utils/vtkm_dataset_info.hpp
+++ b/src/vtkh/utils/vtkm_dataset_info.hpp
@@ -27,7 +27,7 @@ class VTKH_API VTKMDataSetInfo
 
   static bool IsStructured(const vtkm::rendering::Actor &actor, int &topo_dims);
 
-  static bool IsStructured(const vtkm::cont::DynamicCellSet &cell_set, int &topo_dims);
+  static bool IsStructured(const vtkm::cont::UnknownCellSet &cell_set, int &topo_dims);
 
   static bool IsRectilinear(const vtkm::cont::DataSet &data_set);
 
@@ -45,15 +45,15 @@ class VTKH_API VTKMDataSetInfo
 
   static bool GetPointDims(const vtkm::rendering::Actor &actor, int *dims);
 
-  static bool GetPointDims(const vtkm::cont::DynamicCellSet &cell_set, int *dims);
+  static bool GetPointDims(const vtkm::cont::UnknownCellSet &cell_set, int *dims);
 
   static bool GetCellDims(const vtkm::cont::DataSet &data_set, int *dims);
 
   static bool GetCellDims(const vtkm::rendering::Actor &actor, int *dims);
 
-  static bool GetCellDims(const vtkm::cont::DynamicCellSet &cell_set, int *dims);
+  static bool GetCellDims(const vtkm::cont::UnknownCellSet &cell_set, int *dims);
 
-  static bool IsSingleCellShape(const vtkm::cont::DynamicCellSet &cell_set, vtkm::UInt8 &shape_id);
+  static bool IsSingleCellShape(const vtkm::cont::UnknownCellSet &cell_set, vtkm::UInt8 &shape_id);
 
 };
 

From 11772d7ad64535e6a0473f602eaf23648e9427c0 Mon Sep 17 00:00:00 2001
From: Nicole Marsaglia <marsagli@uoreogn.edu>
Date: Wed, 27 Apr 2022 13:34:52 -0700
Subject: [PATCH 2/9] needs new header, revisit deprecations

---
 src/vtkh/vtkm_filters/vtkmThreshold.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/vtkh/vtkm_filters/vtkmThreshold.cpp b/src/vtkh/vtkm_filters/vtkmThreshold.cpp
index 19b8df5e..cf2b17a6 100644
--- a/src/vtkh/vtkm_filters/vtkmThreshold.cpp
+++ b/src/vtkh/vtkm_filters/vtkmThreshold.cpp
@@ -1,6 +1,7 @@
 #include "vtkmThreshold.hpp"
 
-#include <vtkm/filter/Threshold.h>
+#include <vtkm/filter/entity_extraction/Threshold.h>
+#include <vtkm/cont/CellSetPermutation.h>
 #include <vtkm/worklet/CellDeepCopy.h>
 
 
@@ -26,22 +27,22 @@ void StripPermutation(vtkm::cont::DataSet &data_set)
 
   if(cell_set.IsSameType(PermStructured2d()))
   {
-    PermStructured2d perm = cell_set.Cast<PermStructured2d>();
+    PermStructured2d perm = cell_set.AsCellSet<PermStructured2d>();
     explicit_cells = vtkm::worklet::CellDeepCopy::Run(perm);
   }
   else if(cell_set.IsSameType(PermStructured3d()))
   {
-    PermStructured3d perm = cell_set.Cast<PermStructured3d>();
+    PermStructured3d perm = cell_set.AsCellSet<PermStructured3d>();
     explicit_cells = vtkm::worklet::CellDeepCopy::Run(perm);
   }
   else if(cell_set.IsSameType(PermExplicit()))
   {
-    PermExplicit perm = cell_set.Cast<PermExplicit>();
+    PermExplicit perm = cell_set.AsCellSet<PermExplicit>();
     explicit_cells = vtkm::worklet::CellDeepCopy::Run(perm);
   }
   else if(cell_set.IsSameType(PermExplicitSingle()))
   {
-    PermExplicitSingle perm = cell_set.Cast<PermExplicitSingle>();
+    PermExplicitSingle perm = cell_set.AsCellSet<PermExplicitSingle>();
     explicit_cells = vtkm::worklet::CellDeepCopy::Run(perm);
   }
 
@@ -70,7 +71,7 @@ vtkmThreshold::Run(vtkm::cont::DataSet &input,
                    vtkm::filter::FieldSelection map_fields,
                    bool return_all_in_range)
 {
-  vtkm::filter::Threshold thresholder;
+  vtkm::filter::entity_extraction::Threshold thresholder;
   thresholder.SetAllInRange(return_all_in_range);
   thresholder.SetUpperThreshold(max_value);
   thresholder.SetLowerThreshold(min_value);

From b18a4d2f004938513773fcb2f1d9a1c970b650f2 Mon Sep 17 00:00:00 2001
From: Nicole Marsaglia <marsagli@uoreogn.edu>
Date: Thu, 28 Apr 2022 08:56:35 -0700
Subject: [PATCH 3/9] update deprecations: pass a type, not a function

---
 src/vtkh/vtkm_filters/vtkmThreshold.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/vtkh/vtkm_filters/vtkmThreshold.cpp b/src/vtkh/vtkm_filters/vtkmThreshold.cpp
index cf2b17a6..a8af7e81 100644
--- a/src/vtkh/vtkm_filters/vtkmThreshold.cpp
+++ b/src/vtkh/vtkm_filters/vtkmThreshold.cpp
@@ -21,26 +21,26 @@ typedef  vtkm::cont::CellSetPermutation<vtkm::cont::CellSetSingleType<>>
 
 void StripPermutation(vtkm::cont::DataSet &data_set)
 {
-  vtkm::cont::DynamicCellSet cell_set = data_set.GetCellSet();
+  vtkm::cont::UnknownCellSet cell_set = data_set.GetCellSet();
   vtkm::cont::DataSet result;
   vtkm::cont::CellSetExplicit<> explicit_cells;
 
-  if(cell_set.IsSameType(PermStructured2d()))
+  if(cell_set.CanConvert<PermStructured2d>())
   {
     PermStructured2d perm = cell_set.AsCellSet<PermStructured2d>();
     explicit_cells = vtkm::worklet::CellDeepCopy::Run(perm);
   }
-  else if(cell_set.IsSameType(PermStructured3d()))
+  else if(cell_set.CanConvert<PermStructured3d>())
   {
     PermStructured3d perm = cell_set.AsCellSet<PermStructured3d>();
     explicit_cells = vtkm::worklet::CellDeepCopy::Run(perm);
   }
-  else if(cell_set.IsSameType(PermExplicit()))
+  else if(cell_set.CanConvert<PermExplicit>())
   {
     PermExplicit perm = cell_set.AsCellSet<PermExplicit>();
     explicit_cells = vtkm::worklet::CellDeepCopy::Run(perm);
   }
-  else if(cell_set.IsSameType(PermExplicitSingle()))
+  else if(cell_set.CanConvert<PermExplicitSingle>())
   {
     PermExplicitSingle perm = cell_set.AsCellSet<PermExplicitSingle>();
     explicit_cells = vtkm::worklet::CellDeepCopy::Run(perm);

From b0e64e80d5466bb0ac71857c2cd8d68bbaee2ccd Mon Sep 17 00:00:00 2001
From: Nicole Marsaglia <marsagli@uoreogn.edu>
Date: Thu, 28 Apr 2022 11:22:55 -0700
Subject: [PATCH 4/9] point to moved worklet headers

---
 src/vtkh/filters/Histogram.cpp       | 5 ++++-
 src/vtkh/filters/ParticleMerging.cpp | 5 ++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/vtkh/filters/Histogram.cpp b/src/vtkh/filters/Histogram.cpp
index 4b29d9a2..f62a2fd3 100644
--- a/src/vtkh/filters/Histogram.cpp
+++ b/src/vtkh/filters/Histogram.cpp
@@ -3,7 +3,9 @@
 #include <vtkh/Logger.hpp>
 #include <vtkh/utils/vtkm_array_utils.hpp>
 
-#include <vtkm/worklet/FieldHistogram.h>
+//TODO: Header for new Histogram filter
+//#include <vtkm/filter/density_estimate/Histogram.h>
+#include <vtkm/filter/density_estimate/worklet/FieldHistogram.h>
 
 #ifdef VTKH_PARALLEL
 #include <mpi.h>
@@ -31,6 +33,7 @@ struct HistoFunctor
     T min_range = static_cast<T>(m_range.Min);
     T max_range = static_cast<T>(m_range.Max);
 
+    //TODO:Rewrite using vtkm::filter::density_estimate::Histogram
     vtkm::worklet::FieldHistogram worklet;
     worklet.Run(array,m_num_bins,min_range,max_range,bin_delta,m_bins);
     m_bin_delta = static_cast<vtkm::Float64>(bin_delta);
diff --git a/src/vtkh/filters/ParticleMerging.cpp b/src/vtkh/filters/ParticleMerging.cpp
index e9b30089..b0d26ed3 100644
--- a/src/vtkh/filters/ParticleMerging.cpp
+++ b/src/vtkh/filters/ParticleMerging.cpp
@@ -1,4 +1,6 @@
-#include <vtkm/worklet/PointMerge.h>
+#include <vtkm/filter/clean_grid/worklet/PointMerge.h>
+//TODO: Header for wrapped filter
+//#include <vtkm/filter/clean_grid/CleanGrid.h>
 #include <vtkh/Error.hpp>
 #include <vtkh/filters/ParticleMerging.hpp>
 
@@ -68,6 +70,7 @@ void ParticleMerging::DoExecute()
     vtkm::Bounds bounds = dom.GetCoordinateSystem().GetBounds();
 
     bool fast_merge = true;
+    //TODO:Rewrite using vtkm::filter::clean_grid::CleanGrid
     vtkm::worklet::PointMerge merger;
     merger.Run(m_radius * 2. , fast_merge, bounds, coords);
     vtkm::cont::CoordinateSystem mcoords = vtkm::cont::CoordinateSystem(coords_name, coords);

From d87d489065a2cbbfa1af2f74a2f3c2684c9e63cd Mon Sep 17 00:00:00 2001
From: Nicole Marsaglia <marsagli@uoreogn.edu>
Date: Thu, 28 Apr 2022 11:28:52 -0700
Subject: [PATCH 5/9] include moved worklet header

---
 src/vtkh/filters/VectorMagnitude.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/vtkh/filters/VectorMagnitude.cpp b/src/vtkh/filters/VectorMagnitude.cpp
index 35f368e3..51fd9f36 100644
--- a/src/vtkh/filters/VectorMagnitude.cpp
+++ b/src/vtkh/filters/VectorMagnitude.cpp
@@ -1,5 +1,7 @@
 #include <vtkh/Error.hpp>
-#include <vtkh/filters/VectorMagnitude.hpp>
+//TODO: new wrapped vtkm filter header
+//#include <vtkm/filter/vector_analysis/VectorMagnitude.h>
+#include <vtkm/filter/vector_analysis/worklet/Magnitude.h>
 
 #include <vtkh/vtkm_filters/vtkmVectorMagnitude.hpp>
 #include <vtkm/worklet/Magnitude.h>
@@ -10,7 +12,7 @@ namespace vtkh
 
 namespace detail
 {
-
+//TODO: Rewrite using vtkm::filter::vector_analysis::VectorMagnitude
 struct VectorMagFunctor
 {
   vtkm::cont::Field result;

From 8ee85a6bafab41ed945928221af08cf6247aeda2 Mon Sep 17 00:00:00 2001
From: Nicole Marsaglia <marsagli@uoreogn.edu>
Date: Thu, 28 Apr 2022 11:35:38 -0700
Subject: [PATCH 6/9] oops; still need vtkh vecmag header

---
 src/vtkh/filters/VectorMagnitude.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/vtkh/filters/VectorMagnitude.cpp b/src/vtkh/filters/VectorMagnitude.cpp
index 51fd9f36..3b355e55 100644
--- a/src/vtkh/filters/VectorMagnitude.cpp
+++ b/src/vtkh/filters/VectorMagnitude.cpp
@@ -1,10 +1,10 @@
 #include <vtkh/Error.hpp>
+#include <vtkh/filters/VectorMagnitude.hpp>
+
+#include <vtkh/vtkm_filters/vtkmVectorMagnitude.hpp>
 //TODO: new wrapped vtkm filter header
 //#include <vtkm/filter/vector_analysis/VectorMagnitude.h>
 #include <vtkm/filter/vector_analysis/worklet/Magnitude.h>
-
-#include <vtkh/vtkm_filters/vtkmVectorMagnitude.hpp>
-#include <vtkm/worklet/Magnitude.h>
 #include <vtkm/TypeList.h>
 
 namespace vtkh

From 000eb0900e3dc82f6169bf82dc23113661797de0 Mon Sep 17 00:00:00 2001
From: Nicole Marsaglia <marsagli@uoreogn.edu>
Date: Thu, 28 Apr 2022 11:55:21 -0700
Subject: [PATCH 7/9] deprecations

---
 src/vtkh/filters/Clip.cpp            | 2 +-
 src/vtkh/filters/ClipField.cpp       | 4 ++--
 src/vtkh/filters/CompositeVector.cpp | 8 ++++----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/vtkh/filters/Clip.cpp b/src/vtkh/filters/Clip.cpp
index c31a388f..d531aa45 100644
--- a/src/vtkh/filters/Clip.cpp
+++ b/src/vtkh/filters/Clip.cpp
@@ -335,7 +335,7 @@ void Clip::DoExecute()
         .Invoke(dom.GetCoordinateSystem().GetData(), clip_field);
 
       dom.AddField(vtkm::cont::Field(fname,
-                                     vtkm::cont::Field::Association::POINTS,
+                                     vtkm::cont::Field::Association::Points,
                                      clip_field));
     } // each domain
 
diff --git a/src/vtkh/filters/ClipField.cpp b/src/vtkh/filters/ClipField.cpp
index 1818e146..e2d32b1f 100644
--- a/src/vtkh/filters/ClipField.cpp
+++ b/src/vtkh/filters/ClipField.cpp
@@ -60,14 +60,14 @@ void ClipField::DoExecute()
 
   bool valid_field = false;
   bool is_cell_assoc = m_input->GetFieldAssociation(m_field_name, valid_field) ==
-                       vtkm::cont::Field::Association::CELL_SET;
+                       vtkm::cont::Field::Association::Cells;
   bool delete_input = false;
   if(valid_field && is_cell_assoc)
   {
     Recenter recenter;
     recenter.SetInput(m_input);
     recenter.SetField(m_field_name);
-    recenter.SetResultAssoc(vtkm::cont::Field::Association::POINTS);
+    recenter.SetResultAssoc(vtkm::cont::Field::Association::Points);
     recenter.Update();
     this->m_input = recenter.GetOutput();
     delete_input = true;
diff --git a/src/vtkh/filters/CompositeVector.cpp b/src/vtkh/filters/CompositeVector.cpp
index b6ae49a6..6a313d03 100644
--- a/src/vtkh/filters/CompositeVector.cpp
+++ b/src/vtkh/filters/CompositeVector.cpp
@@ -12,19 +12,19 @@ namespace detail
 std::string to_string(vtkm::cont::Field::Association assoc)
 {
   std::string res = "unknown";
-  if(assoc == vtkm::cont::Field::Association::WHOLE_MESH)
+  if(assoc == vtkm::cont::Field::Association::WholeMesh)
   {
     res = "whole mesh";
   }
-  else if(assoc == vtkm::cont::Field::Association::ANY)
+  else if(assoc == vtkm::cont::Field::Association::Any)
   {
     res = "any";
   }
-  else if(assoc == vtkm::cont::Field::Association::POINTS)
+  else if(assoc == vtkm::cont::Field::Association::Points)
   {
     res = "points";
   }
-  else if(assoc == vtkm::cont::Field::Association::CELL_SET)
+  else if(assoc == vtkm::cont::Field::Association::Cells)
   {
     res = "cell set";
   }

From 18cc7fcc39fc57eecc05d66a01edfdb47d78ee34 Mon Sep 17 00:00:00 2001
From: Nicole Marsaglia <marsagli@uoreogn.edu>
Date: Thu, 28 Apr 2022 12:25:10 -0700
Subject: [PATCH 8/9] vtkm deprecations

---
 src/vtkh/filters/GhostStripper.cpp        |  8 ++++----
 src/vtkh/filters/Gradient.cpp             |  4 ++--
 src/vtkh/filters/HistSampling.cpp         |  2 +-
 src/vtkh/filters/Log.cpp                  |  4 ++--
 src/vtkh/filters/MarchingCubes.cpp        |  4 ++--
 src/vtkh/filters/MeshQuality.cpp          |  4 ++--
 src/vtkh/filters/MeshQuality.hpp          |  6 +++---
 src/vtkh/filters/PointAverage.cpp         |  2 +-
 src/vtkh/filters/Recenter.cpp             | 14 +++++++-------
 src/vtkh/filters/Slice.cpp                | 18 +++++++++---------
 src/vtkh/rendering/Annotator.cpp          |  2 +-
 src/vtkh/rendering/Renderer.cpp           |  2 +-
 src/vtkh/rendering/VolumeRenderer.cpp     |  8 ++++----
 src/vtkh/vtkm_filters/vtkmMeshQuality.cpp |  4 ++--
 src/vtkh/vtkm_filters/vtkmMeshQuality.hpp |  2 +-
 15 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/src/vtkh/filters/GhostStripper.cpp b/src/vtkh/filters/GhostStripper.cpp
index 296f5fa7..7de90f00 100644
--- a/src/vtkh/filters/GhostStripper.cpp
+++ b/src/vtkh/filters/GhostStripper.cpp
@@ -284,7 +284,7 @@ bool StructuredStrip(vtkm::cont::DataSet &dataset,
                      bool &should_strip)
 {
   VTKH_DATA_OPEN("structured_strip");
-  vtkm::cont::DynamicCellSet cell_set = dataset.GetCellSet();
+  vtkm::cont::UnknownCellSet cell_set = dataset.GetCellSet();
   int dims[3];
   VTKMDataSetInfo::GetPointDims(cell_set, dims);
   vtkm::Vec<vtkm::Id,3> cell_dims(0,0,0);
@@ -293,7 +293,7 @@ bool StructuredStrip(vtkm::cont::DataSet &dataset,
   bool can_strip = false;
   vtkm::Id size = 0;
   should_strip = false;
-  if(cell_set.IsSameType(vtkm::cont::CellSetStructured<1>()))
+  if(cell_set.CanConvert<vtkm::cont::CellSetStructured<1>>())
   {
     cell_dims[0] = dims[0] - 1;
     size = cell_dims[0];
@@ -307,7 +307,7 @@ bool StructuredStrip(vtkm::cont::DataSet &dataset,
                             size,
                             should_strip);
   }
-  else if(cell_set.IsSameType(vtkm::cont::CellSetStructured<2>()))
+  else if(cell_set.CanConvert<vtkm::cont::CellSetStructured<2>>())
   {
     cell_dims[0] = dims[0] - 1;
     cell_dims[1] = dims[1] - 1;
@@ -322,7 +322,7 @@ bool StructuredStrip(vtkm::cont::DataSet &dataset,
                             size,
                             should_strip);
   }
-  else if(cell_set.IsSameType(vtkm::cont::CellSetStructured<3>()))
+  else if(cell_set.CanConvert<vtkm::cont::CellSetStructured<3>>())
   {
     cell_dims[0] = dims[0] - 1;
     cell_dims[1] = dims[1] - 1;
diff --git a/src/vtkh/filters/Gradient.cpp b/src/vtkh/filters/Gradient.cpp
index bde6148f..e0966c28 100644
--- a/src/vtkh/filters/Gradient.cpp
+++ b/src/vtkh/filters/Gradient.cpp
@@ -46,7 +46,7 @@ void Gradient::DoExecute()
   // make sure we have a node-centered field
   bool valid_field = false;
   bool is_cell_assoc = m_input->GetFieldAssociation(m_field_name, valid_field) ==
-                       vtkm::cont::Field::Association::CELL_SET;
+                       vtkm::cont::Field::Association::Cells;
   bool delete_input = false;
 
   if(valid_field && is_cell_assoc)
@@ -54,7 +54,7 @@ void Gradient::DoExecute()
     Recenter recenter;
     recenter.SetInput(m_input);
     recenter.SetField(m_field_name);
-    recenter.SetResultAssoc(vtkm::cont::Field::Association::POINTS);
+    recenter.SetResultAssoc(vtkm::cont::Field::Association::Points);
     recenter.Update();
     m_input = recenter.GetOutput();
     delete_input = true;
diff --git a/src/vtkh/filters/HistSampling.cpp b/src/vtkh/filters/HistSampling.cpp
index 8891ef2e..e62cf754 100644
--- a/src/vtkh/filters/HistSampling.cpp
+++ b/src/vtkh/filters/HistSampling.cpp
@@ -340,7 +340,7 @@ void HistSampling::DoExecute()
     vtkm::cont::ArrayHandle <vtkm::Float32> output;
     vtkm::cont::Algorithm ::Copy(stencilBool , output );
 
-    if(assoc == vtkm::cont::Field::Association::POINTS)
+    if(assoc == vtkm::cont::Field::Association::Points)
     {
       dom.AddPointField("valSampled", output);
     }
diff --git a/src/vtkh/filters/Log.cpp b/src/vtkh/filters/Log.cpp
index f666c0d9..88968a50 100644
--- a/src/vtkh/filters/Log.cpp
+++ b/src/vtkh/filters/Log.cpp
@@ -141,8 +141,8 @@ void Log::DoExecute()
     }
 
     vtkm::cont::Field::Association in_assoc = dom.GetField(m_field_name).GetAssociation();
-    bool is_cell_assoc = in_assoc == vtkm::cont::Field::Association::CELL_SET;
-    bool is_point_assoc = in_assoc == vtkm::cont::Field::Association::POINTS;
+    bool is_cell_assoc = in_assoc == vtkm::cont::Field::Association::Cells;
+    bool is_point_assoc = in_assoc == vtkm::cont::Field::Association::Points;
 
     if(!is_cell_assoc && !is_point_assoc)
     {
diff --git a/src/vtkh/filters/MarchingCubes.cpp b/src/vtkh/filters/MarchingCubes.cpp
index 2ae3e128..fd6589f6 100644
--- a/src/vtkh/filters/MarchingCubes.cpp
+++ b/src/vtkh/filters/MarchingCubes.cpp
@@ -131,14 +131,14 @@ void MarchingCubes::DoExecute()
   // make sure we have a node-centered field
   bool valid_field = false;
   bool is_cell_assoc = m_input->GetFieldAssociation(m_field_name, valid_field) ==
-                       vtkm::cont::Field::Association::CELL_SET;
+                       vtkm::cont::Field::Association::Cells;
   bool delete_input = false;
   if(valid_field && is_cell_assoc)
   {
     Recenter recenter;
     recenter.SetInput(m_input);
     recenter.SetField(m_field_name);
-    recenter.SetResultAssoc(vtkm::cont::Field::Association::POINTS);
+    recenter.SetResultAssoc(vtkm::cont::Field::Association::Points);
     recenter.Update();
     m_input = recenter.GetOutput();
     delete_input = true;
diff --git a/src/vtkh/filters/MeshQuality.cpp b/src/vtkh/filters/MeshQuality.cpp
index d8b3cd28..b43fa96a 100644
--- a/src/vtkh/filters/MeshQuality.cpp
+++ b/src/vtkh/filters/MeshQuality.cpp
@@ -7,7 +7,7 @@ namespace vtkh
 {
 
 MeshQuality::MeshQuality()
-  : m_metric(vtkm::filter::CellMetric::VOLUME)
+  : m_metric(vtkm::filter::mesh_info::CellMetric::Volume)
 {
 
 }
@@ -17,7 +17,7 @@ MeshQuality::~MeshQuality()
 
 }
 
-void MeshQuality::cell_metric(vtkm::filter::CellMetric metric)
+void MeshQuality::cell_metric(vtkm::filter::mesh_info::CellMetric metric)
 {
   m_metric = metric;
 }
diff --git a/src/vtkh/filters/MeshQuality.hpp b/src/vtkh/filters/MeshQuality.hpp
index 5b3248a8..84cb2714 100644
--- a/src/vtkh/filters/MeshQuality.hpp
+++ b/src/vtkh/filters/MeshQuality.hpp
@@ -5,7 +5,7 @@
 #include <vtkh/vtkh.hpp>
 #include <vtkh/filters/Filter.hpp>
 #include <vtkh/DataSet.hpp>
-#include <vtkm/filter/MeshQuality.h>
+#include <vtkm/filter/mesh_info/MeshQuality.h>
 
 namespace vtkh
 {
@@ -17,13 +17,13 @@ class VTKH_API MeshQuality: public Filter
   virtual ~MeshQuality();
   std::string GetName() const override;
 
-  void cell_metric(vtkm::filter::CellMetric metric);
+  void cell_metric(vtkm::filter::mesh_info::CellMetric metric);
 
 protected:
   void PreExecute() override;
   void PostExecute() override;
   void DoExecute() override;
-  vtkm::filter::CellMetric m_metric;
+  vtkm::filter::mesh_info::CellMetric m_metric;
 };
 
 } //namespace vtkh
diff --git a/src/vtkh/filters/PointAverage.cpp b/src/vtkh/filters/PointAverage.cpp
index f2c680aa..6b7956f6 100644
--- a/src/vtkh/filters/PointAverage.cpp
+++ b/src/vtkh/filters/PointAverage.cpp
@@ -58,7 +58,7 @@ void PointAverage::DoExecute()
       continue;
     }
 
-    vtkm::filter::PointAverage avg;
+    vtkm::filter::field_conversion::PointAverage avg;
     avg.SetOutputFieldName(m_output_field_name);
     avg.SetActiveField(m_field_name);
     avg.SetFieldsToPass(this->GetFieldSelection());
diff --git a/src/vtkh/filters/Recenter.cpp b/src/vtkh/filters/Recenter.cpp
index 4a70b9dc..5e065ddf 100644
--- a/src/vtkh/filters/Recenter.cpp
+++ b/src/vtkh/filters/Recenter.cpp
@@ -8,7 +8,7 @@ namespace vtkh
 {
 
 Recenter::Recenter()
- : m_assoc(vtkm::cont::Field::Association::POINTS)
+ : m_assoc(vtkm::cont::Field::Association::Points)
 {
 
 }
@@ -38,8 +38,8 @@ void Recenter::PostExecute()
 void Recenter::SetResultAssoc(vtkm::cont::Field::Association assoc)
 {
 
-  if(assoc != vtkm::cont::Field::Association::CELL_SET &&
-     assoc != vtkm::cont::Field::Association::POINTS)
+  if(assoc != vtkm::cont::Field::Association::Cells &&
+     assoc != vtkm::cont::Field::Association::Points)
   {
     throw Error("Recenter can only recenter zonal and nodal fields");
   }
@@ -86,15 +86,15 @@ void Recenter::DoExecute()
       temp.AddCoordinateSystem(coords);
     }
 
-    vtkm::cont::DynamicCellSet cellset = dom.GetCellSet();
+    vtkm::cont::UnknownCellSet cellset = dom.GetCellSet();
     out_data.SetCellSet(cellset);
     temp.SetCellSet(cellset);
 
     if(temp.HasField(m_field_name))
     {
       vtkm::cont::Field::Association in_assoc = temp.GetField(m_field_name).GetAssociation();
-      bool is_cell_assoc = in_assoc == vtkm::cont::Field::Association::CELL_SET;
-      bool is_point_assoc = in_assoc == vtkm::cont::Field::Association::POINTS;
+      bool is_cell_assoc = in_assoc == vtkm::cont::Field::Association::Cells;
+      bool is_point_assoc = in_assoc == vtkm::cont::Field::Association::Points;
 
       if(!is_cell_assoc && !is_point_assoc)
       {
@@ -114,7 +114,7 @@ void Recenter::DoExecute()
         }
         else
         {
-          vtkm::filter::CellAverage avg;
+          vtkm::filter::field_conversion::CellAverage avg;
           avg.SetOutputFieldName(out_name);
           avg.SetActiveField(m_field_name);
           dataset = avg.Execute(dom);
diff --git a/src/vtkh/filters/Slice.cpp b/src/vtkh/filters/Slice.cpp
index 22b6c2d0..403b212e 100644
--- a/src/vtkh/filters/Slice.cpp
+++ b/src/vtkh/filters/Slice.cpp
@@ -168,12 +168,12 @@ class MergeContours
     {
       //check to see if this is a supported field ;
       const vtkm::cont::Field &scalar_field = m_in_data_sets[0].GetField(m_field_index);
-      bool is_supported = (scalar_field.GetAssociation() == vtkm::cont::Field::Association::POINTS ||
-                           scalar_field.GetAssociation() == vtkm::cont::Field::Association::CELL_SET);
+      bool is_supported = (scalar_field.GetAssociation() == vtkm::cont::Field::Association::Points ||
+                           scalar_field.GetAssociation() == vtkm::cont::Field::Association::Cells);
 
       if(!is_supported) return;
 
-      bool assoc_points = scalar_field.GetAssociation() == vtkm::cont::Field::Association::POINTS;
+      bool assoc_points = scalar_field.GetAssociation() == vtkm::cont::Field::Association::Points;
       vtkm::cont::ArrayHandle<T> out;
       if(assoc_points)
       {
@@ -221,8 +221,8 @@ class MergeContours
       // of contour is now explicit cell set,but we can still assume that
       // this output will be all triangles.
       // this becomes more complicated if we want to support mixed types
-      //if(!cell_set.IsSameType(vtkm::cont::CellSetSingleType<>())) continue;
-      if(!cell_set.IsSameType(vtkm::cont::CellSetExplicit<>()))
+      //if(!cell_set.CanConvert(vtkm::cont::CellSetSingleType<>())) continue;
+      if(!cell_set.CanConvert<vtkm::cont::CellSetExplicit<>>())
       {
         std::cout<<"expected explicit cell set as the result of contour\n";
 
@@ -255,8 +255,8 @@ class MergeContours
     {
       auto cell_set = doms[dom].GetCellSet();
 
-      //if(!cell_set.IsSameType(vtkm::cont::CellSetSingleType<>())) continue;
-      if(!cell_set.IsSameType(vtkm::cont::CellSetExplicit<>()))
+      //if(!cell_set.CanConvert(vtkm::cont::CellSetSingleType<>())) continue;
+      if(!cell_set.CanConvert<vtkm::cont::CellSetExplicit<>>())
       {
         std::cout<<"expected explicit cell set as the result of contour\n";
         continue;
@@ -265,7 +265,7 @@ class MergeContours
       // grab the connectivity and copy it into the larger array
       //vtkm::cont::CellSetSingleType<> single_type = cell_set.Cast<vtkm::cont::CellSetSingleType<>>();
       vtkm::cont::CellSetExplicit<> single_type =
-        cell_set.Cast<vtkm::cont::CellSetExplicit<>>();
+        cell_set.AsCellSet<vtkm::cont::CellSetExplicit<>>();
       const vtkm::cont::ArrayHandle<vtkm::Id> dconn = single_type.GetConnectivityArray(
         vtkm::TopologyElementTagCell(),
         vtkm::TopologyElementTagPoint());
@@ -412,7 +412,7 @@ Slice::DoExecute()
         .Invoke(dom.GetCoordinateSystem().GetData(), slice_field);
 
       dom.AddField(vtkm::cont::Field(fname,
-                                      vtkm::cont::Field::Association::POINTS,
+                                      vtkm::cont::Field::Association::Points,
                                       slice_field));
     } // each domain
 
diff --git a/src/vtkh/rendering/Annotator.cpp b/src/vtkh/rendering/Annotator.cpp
index b332034f..3c118e53 100644
--- a/src/vtkh/rendering/Annotator.cpp
+++ b/src/vtkh/rendering/Annotator.cpp
@@ -10,7 +10,7 @@ Annotator::Annotator(vtkm::rendering::Canvas &canvas,
     m_camera(camera),
     m_bounds(bounds)
 {
-  m_is_3d = m_camera.GetMode() == vtkm::rendering::Camera::MODE_3D;
+  m_is_3d = m_camera.GetMode() == vtkm::rendering::Camera::Mode::ThreeD;
   m_world_annotator = m_canvas.CreateWorldAnnotator();
   // add defualt color bar positions
   vtkm::Bounds p1(vtkm::Range(0.84, 0.92), vtkm::Range(+0.1, +0.8), vtkm::Range(0, 0));
diff --git a/src/vtkh/rendering/Renderer.cpp b/src/vtkh/rendering/Renderer.cpp
index 9348e599..3d821ece 100644
--- a/src/vtkh/rendering/Renderer.cpp
+++ b/src/vtkh/rendering/Renderer.cpp
@@ -211,7 +211,7 @@ Renderer::DoExecute()
       continue;
     }
 
-    const vtkm::cont::DynamicCellSet &cellset = data_set.GetCellSet();
+    const vtkm::cont::UnknownCellSet &cellset = data_set.GetCellSet();
     const vtkm::cont::Field &field = data_set.GetField(m_field_name);
     const vtkm::cont::CoordinateSystem &coords = data_set.GetCoordinateSystem();
 
diff --git a/src/vtkh/rendering/VolumeRenderer.cpp b/src/vtkh/rendering/VolumeRenderer.cpp
index c6f8bfce..7fe92432 100644
--- a/src/vtkh/rendering/VolumeRenderer.cpp
+++ b/src/vtkh/rendering/VolumeRenderer.cpp
@@ -232,7 +232,7 @@ class StructuredWrapper : public VolumeWrapper
          vtkm::rendering::CanvasRayTracer &canvas,
          std::vector<VolumePartial<float>> &partials) override
   {
-    const vtkm::cont::DynamicCellSet &cellset = m_data_set.GetCellSet();
+    const vtkm::cont::UnknownCellSet &cellset = m_data_set.GetCellSet();
     const vtkm::cont::Field &field = m_data_set.GetField(m_field_name);
     const vtkm::cont::CoordinateSystem &coords = m_data_set.GetCoordinateSystem();
 
@@ -250,7 +250,7 @@ class StructuredWrapper : public VolumeWrapper
     tracer.SetSampleDistance(m_sample_dist);
     tracer.SetData(coords,
                    field,
-                   cellset.Cast<vtkm::cont::CellSetStructured<3>>(),
+                   cellset.AsCellSet<vtkm::cont::CellSetStructured<3>>(),
                    m_scalar_range);
     tracer.SetColorMap(m_color_map);
 
@@ -507,7 +507,7 @@ VolumeRenderer::RenderOneDomainPerRank()
       continue;
     }
 
-    const vtkm::cont::DynamicCellSet &cellset = data_set.GetCellSet();
+    const vtkm::cont::UnknownCellSet &cellset = data_set.GetCellSet();
     const vtkm::cont::Field &field = data_set.GetField(m_field_name);
     const vtkm::cont::CoordinateSystem &coords = data_set.GetCoordinateSystem();
 
@@ -878,7 +878,7 @@ void VolumeRenderer::SetInput(DataSet *input)
     vtkm::Id domain_id;
     m_input->GetDomain(dom, data_set, domain_id);
 
-    const vtkm::cont::DynamicCellSet &cellset = data_set.GetCellSet();
+    const vtkm::cont::UnknownCellSet &cellset = data_set.GetCellSet();
     if(cellset.GetNumberOfCells() == 0)
     {
       continue;
diff --git a/src/vtkh/vtkm_filters/vtkmMeshQuality.cpp b/src/vtkh/vtkm_filters/vtkmMeshQuality.cpp
index 538f81f6..04c81d24 100644
--- a/src/vtkh/vtkm_filters/vtkmMeshQuality.cpp
+++ b/src/vtkh/vtkm_filters/vtkmMeshQuality.cpp
@@ -4,11 +4,11 @@ namespace vtkh
 {
 
 vtkm::cont::DataSet vtkmMeshQuality::Run(vtkm::cont::DataSet &input,
-                                         vtkm::filter::CellMetric metric,
+                                         vtkm::filter::mesh_info::CellMetric metric,
                                          vtkm::filter::FieldSelection map_fields)
 
 {
-  vtkm::filter::MeshQuality quali(metric);
+  vtkm::filter::mesh_info::MeshQuality quali(metric);
   quali.SetFieldsToPass(map_fields);
   auto output = quali.Execute(input);
   return output;
diff --git a/src/vtkh/vtkm_filters/vtkmMeshQuality.hpp b/src/vtkh/vtkm_filters/vtkmMeshQuality.hpp
index 092b14ea..c41a1051 100644
--- a/src/vtkh/vtkm_filters/vtkmMeshQuality.hpp
+++ b/src/vtkh/vtkm_filters/vtkmMeshQuality.hpp
@@ -12,7 +12,7 @@ class vtkmMeshQuality
 {
 public:
   vtkm::cont::DataSet Run(vtkm::cont::DataSet &input,
-                          vtkm::filter::CellMetric metric,
+                          vtkm::filter::mesh_info::CellMetric metric,
                           vtkm::filter::FieldSelection map_fields);
 };
 }

From f1b211be8cdbf1d28c28c00b4588d2bc6ec17a2d Mon Sep 17 00:00:00 2001
From: Nicole Marsaglia <marsagli@uoreogn.edu>
Date: Tue, 3 May 2022 13:20:57 -0700
Subject: [PATCH 9/9] more deprecations

---
 src/vtkh/DataSet.cpp                          | 20 +++++++++----------
 src/vtkh/vtkm_filters/CMakeLists.txt          |  2 +-
 src/vtkh/vtkm_filters/vtkmCellAverage.cpp     |  4 ++--
 src/vtkh/vtkm_filters/vtkmCleanGrid.cpp       |  4 ++--
 src/vtkh/vtkm_filters/vtkmClip.cpp            |  4 ++--
 src/vtkh/vtkm_filters/vtkmClipWithField.cpp   |  4 ++--
 .../vtkm_filters/vtkmExtractStructured.cpp    |  4 ++--
 src/vtkh/vtkm_filters/vtkmGradient.cpp        |  4 ++--
 src/vtkh/vtkm_filters/vtkmMarchingCubes.cpp   |  4 ++--
 src/vtkh/vtkm_filters/vtkmMeshQuality.hpp     |  2 +-
 src/vtkh/vtkm_filters/vtkmPointAverage.cpp    |  4 ++--
 src/vtkh/vtkm_filters/vtkmPointTransform.cpp  |  6 ++++--
 src/vtkh/vtkm_filters/vtkmTetrahedralize.cpp  |  4 ++--
 src/vtkh/vtkm_filters/vtkmTriangulate.cpp     |  4 ++--
 src/vtkh/vtkm_filters/vtkmVectorMagnitude.cpp |  4 ++--
 15 files changed, 38 insertions(+), 36 deletions(-)

diff --git a/src/vtkh/DataSet.cpp b/src/vtkh/DataSet.cpp
index 676c7e0c..5e79f635 100644
--- a/src/vtkh/DataSet.cpp
+++ b/src/vtkh/DataSet.cpp
@@ -675,7 +675,7 @@ DataSet::AddConstantPointField(const vtkm::Float32 value, const std::string fiel
     vtkm::Id num_points = m_domains[i].GetCoordinateSystem().GetData().GetNumberOfValues();
     vtkm::cont::ArrayHandle<vtkm::Float32> array;
     detail::MemSet(array, value, num_points);
-    vtkm::cont::Field field(fieldname, vtkm::cont::Field::Association::POINTS, array);
+    vtkm::cont::Field field(fieldname, vtkm::cont::Field::Association::Points, array);
     m_domains[i].AddField(field);
   }
 }
@@ -734,7 +734,7 @@ DataSet::GetFieldAssociation(const std::string field_name, bool &valid_field) co
   if(!this->GlobalFieldExists(field_name))
   {
     valid_field = false;
-    return vtkm::cont::Field::Association::ANY;
+    return vtkm::cont::Field::Association::Any;
   }
 
   int assoc_id = -1;
@@ -750,19 +750,19 @@ DataSet::GetFieldAssociation(const std::string field_name, bool &valid_field) co
       if(dom.HasField(field_name))
       {
         local_assoc = dom.GetField(field_name).GetAssociation();
-        if(local_assoc == vtkm::cont::Field::Association::ANY)
+        if(local_assoc == vtkm::cont::Field::Association::Any)
         {
           assoc_id = 0;
         }
-        else if ( local_assoc == vtkm::cont::Field::Association::WHOLE_MESH)
+        else if ( local_assoc == vtkm::cont::Field::Association::WholeMesh)
         {
           assoc_id = 1;
         }
-        else if ( local_assoc == vtkm::cont::Field::Association::POINTS)
+        else if ( local_assoc == vtkm::cont::Field::Association::Points)
         {
           assoc_id = 2;
         }
-        else if ( local_assoc == vtkm::cont::Field::Association::CELL_SET)
+        else if ( local_assoc == vtkm::cont::Field::Association::Cells)
         {
           assoc_id = 3;
         }
@@ -813,19 +813,19 @@ DataSet::GetFieldAssociation(const std::string field_name, bool &valid_field) co
 
   if(assoc_id == 0)
   {
-    assoc = vtkm::cont::Field::Association::ANY;
+    assoc = vtkm::cont::Field::Association::Any;
   }
   else if ( assoc_id == 1)
   {
-    assoc = vtkm::cont::Field::Association::WHOLE_MESH;
+    assoc = vtkm::cont::Field::Association::WholeMesh;
   }
   else if ( assoc_id == 2)
   {
-    assoc = vtkm::cont::Field::Association::POINTS;
+    assoc = vtkm::cont::Field::Association::Points;
   }
   else if ( assoc_id == 3)
   {
-    assoc = vtkm::cont::Field::Association::CELL_SET;
+    assoc = vtkm::cont::Field::Association::Cells;
   }
   else
   {
diff --git a/src/vtkh/vtkm_filters/CMakeLists.txt b/src/vtkh/vtkm_filters/CMakeLists.txt
index f4579ae1..17247979 100644
--- a/src/vtkh/vtkm_filters/CMakeLists.txt
+++ b/src/vtkh/vtkm_filters/CMakeLists.txt
@@ -44,7 +44,7 @@ set(vtkm_filters_install_headers
 
 # we use these specific vtk-m targets b/c our favorite version
 # of cmake does not yet support transitive deps for object libs
-set(vtkm_filters_deps vtkm_compiler_flags vtkm_diy )
+set(vtkm_filters_deps vtkm_compiler_flags vtkm_diy vtkm_filter)
 
 if(ENABLE_OPENMP)
   list(APPEND vtkm_filters_deps openmp)
diff --git a/src/vtkh/vtkm_filters/vtkmCellAverage.cpp b/src/vtkh/vtkm_filters/vtkmCellAverage.cpp
index 4631b245..6307a911 100644
--- a/src/vtkh/vtkm_filters/vtkmCellAverage.cpp
+++ b/src/vtkh/vtkm_filters/vtkmCellAverage.cpp
@@ -1,5 +1,5 @@
 #include "vtkmCellAverage.hpp"
-#include <vtkm/filter/CellAverage.h>
+#include <vtkm/filter/field_conversion/CellAverage.h>
 
 namespace vtkh
 {
@@ -9,7 +9,7 @@ vtkmCellAverage::Run(vtkm::cont::DataSet &input,
                      std::string output_field_name,
                      vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::CellAverage avg;
+  vtkm::filter::field_conversion::CellAverage avg;
   avg.SetOutputFieldName(output_field_name);
   avg.SetFieldsToPass(map_fields);
   avg.SetActiveField(field_name);
diff --git a/src/vtkh/vtkm_filters/vtkmCleanGrid.cpp b/src/vtkh/vtkm_filters/vtkmCleanGrid.cpp
index 4c1c3219..e2fff80e 100644
--- a/src/vtkh/vtkm_filters/vtkmCleanGrid.cpp
+++ b/src/vtkh/vtkm_filters/vtkmCleanGrid.cpp
@@ -1,5 +1,5 @@
 #include "vtkmCleanGrid.hpp"
-#include <vtkm/filter/CleanGrid.h>
+#include <vtkm/filter/clean_grid/CleanGrid.h>
 
 namespace vtkh
 {
@@ -14,7 +14,7 @@ vtkm::cont::DataSet
 vtkmCleanGrid::Run(vtkm::cont::DataSet &input,
                    vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::CleanGrid cleaner;
+  vtkm::filter::clean_grid::CleanGrid cleaner;
 
   if(m_tolerance != -1.)
   {
diff --git a/src/vtkh/vtkm_filters/vtkmClip.cpp b/src/vtkh/vtkm_filters/vtkmClip.cpp
index 88fe6ebb..ef5e70ac 100644
--- a/src/vtkh/vtkm_filters/vtkmClip.cpp
+++ b/src/vtkh/vtkm_filters/vtkmClip.cpp
@@ -1,5 +1,5 @@
 #include "vtkmClip.hpp"
-#include <vtkm/filter/ClipWithImplicitFunction.h>
+#include <vtkm/filter/contour/ClipWithImplicitFunction.h>
 
 namespace vtkh
 {
@@ -9,7 +9,7 @@ vtkmClip::Run(vtkm::cont::DataSet &input,
               bool invert,
               vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::ClipWithImplicitFunction clipper;
+  vtkm::filter::contour::ClipWithImplicitFunction clipper;
 
   clipper.SetImplicitFunction(func);
   clipper.SetInvertClip(invert);
diff --git a/src/vtkh/vtkm_filters/vtkmClipWithField.cpp b/src/vtkh/vtkm_filters/vtkmClipWithField.cpp
index 59f66403..3dd1cfef 100644
--- a/src/vtkh/vtkm_filters/vtkmClipWithField.cpp
+++ b/src/vtkh/vtkm_filters/vtkmClipWithField.cpp
@@ -1,5 +1,5 @@
 #include "vtkmClipWithField.hpp"
-#include <vtkm/filter/ClipWithField.h>
+#include <vtkm/filter/contour/ClipWithField.h>
 
 namespace vtkh
 {
@@ -10,7 +10,7 @@ vtkmClipWithField::Run(vtkm::cont::DataSet &input,
                        bool invert,
                        vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::ClipWithField clipper;
+  vtkm::filter::contour::ClipWithField clipper;
 
   clipper.SetClipValue(clip_value);
   clipper.SetInvertClip(invert);
diff --git a/src/vtkh/vtkm_filters/vtkmExtractStructured.cpp b/src/vtkh/vtkm_filters/vtkmExtractStructured.cpp
index 0b233c4b..61453457 100644
--- a/src/vtkh/vtkm_filters/vtkmExtractStructured.cpp
+++ b/src/vtkh/vtkm_filters/vtkmExtractStructured.cpp
@@ -1,5 +1,5 @@
 #include "vtkmExtractStructured.hpp"
-#include <vtkm/filter/ExtractStructured.h>
+#include <vtkm/filter/entity_extraction/ExtractStructured.h>
 
 namespace vtkh
 {
@@ -10,7 +10,7 @@ vtkmExtractStructured::Run(vtkm::cont::DataSet &input,
                            vtkm::filter::FieldSelection map_fields)
 {
 
-  vtkm::filter::ExtractStructured extract;
+  vtkm::filter::entity_extraction::ExtractStructured extract;
   extract.SetVOI(range);
   extract.SetSampleRate(sample_rate);
   extract.SetIncludeBoundary(true);
diff --git a/src/vtkh/vtkm_filters/vtkmGradient.cpp b/src/vtkh/vtkm_filters/vtkmGradient.cpp
index 9abbd0e2..fcdd2857 100644
--- a/src/vtkh/vtkm_filters/vtkmGradient.cpp
+++ b/src/vtkh/vtkm_filters/vtkmGradient.cpp
@@ -1,5 +1,5 @@
 #include "vtkmGradient.hpp"
-#include <vtkm/filter/Gradient.h>
+#include <vtkm/filter/vector_analysis/Gradient.h>
 
 namespace vtkh
 {
@@ -11,7 +11,7 @@ vtkmGradient::Run(vtkm::cont::DataSet &input,
                   GradientParameters params,
                   vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::Gradient grad;
+  vtkm::filter::vector_analysis::Gradient grad;
   grad.SetOutputFieldName(params.output_name);
   grad.SetFieldsToPass(map_fields);
   grad.SetActiveField(field_name);
diff --git a/src/vtkh/vtkm_filters/vtkmMarchingCubes.cpp b/src/vtkh/vtkm_filters/vtkmMarchingCubes.cpp
index 6359909b..7ef6d43c 100644
--- a/src/vtkh/vtkm_filters/vtkmMarchingCubes.cpp
+++ b/src/vtkh/vtkm_filters/vtkmMarchingCubes.cpp
@@ -1,5 +1,5 @@
 #include "vtkmMarchingCubes.hpp"
-#include <vtkm/filter/Contour.h>
+#include <vtkm/filter/contour/Contour.h>
 
 namespace vtkh
 {
@@ -9,7 +9,7 @@ vtkmMarchingCubes::Run(vtkm::cont::DataSet &input,
                        std::vector<double> iso_values,
                        vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::Contour marcher;
+  vtkm::filter::contour::Contour marcher;
 
   marcher.SetFieldsToPass(map_fields);
   marcher.SetIsoValues(iso_values);
diff --git a/src/vtkh/vtkm_filters/vtkmMeshQuality.hpp b/src/vtkh/vtkm_filters/vtkmMeshQuality.hpp
index c41a1051..e7d31917 100644
--- a/src/vtkh/vtkm_filters/vtkmMeshQuality.hpp
+++ b/src/vtkh/vtkm_filters/vtkmMeshQuality.hpp
@@ -3,7 +3,7 @@
 
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/filter/FieldSelection.h>
-#include <vtkm/filter/MeshQuality.h>
+#include <vtkm/filter/mesh_info/MeshQuality.h>
 
 namespace vtkh
 {
diff --git a/src/vtkh/vtkm_filters/vtkmPointAverage.cpp b/src/vtkh/vtkm_filters/vtkmPointAverage.cpp
index 2d6f8e11..ad192eb4 100644
--- a/src/vtkh/vtkm_filters/vtkmPointAverage.cpp
+++ b/src/vtkh/vtkm_filters/vtkmPointAverage.cpp
@@ -1,5 +1,5 @@
 #include "vtkmPointAverage.hpp"
-#include <vtkm/filter/PointAverage.h>
+#include <vtkm/filter/field_conversion/PointAverage.h>
 
 namespace vtkh
 {
@@ -9,7 +9,7 @@ vtkmPointAverage::Run(vtkm::cont::DataSet &input,
                       std::string output_field_name,
                       vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::PointAverage avg;
+  vtkm::filter::field_conversion::PointAverage avg;
   avg.SetOutputFieldName(output_field_name);
   avg.SetFieldsToPass(map_fields);
   avg.SetActiveField(field_name);
diff --git a/src/vtkh/vtkm_filters/vtkmPointTransform.cpp b/src/vtkh/vtkm_filters/vtkmPointTransform.cpp
index dadf0c01..555297f0 100644
--- a/src/vtkh/vtkm_filters/vtkmPointTransform.cpp
+++ b/src/vtkh/vtkm_filters/vtkmPointTransform.cpp
@@ -1,5 +1,6 @@
 #include "vtkmPointTransform.hpp"
-#include <vtkm/filter/PointTransform.h>
+//#include <vtkm/filter/PointTransform.h>
+#include <vtkm/filter/field_transform/PointTransform.h>
 
 namespace vtkh
 {
@@ -8,7 +9,8 @@ vtkmPointTransform::Run(vtkm::cont::DataSet &input,
                         vtkm::Matrix<double,4,4> &transform,
                         vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::PointTransform trans;
+  //vtkm::filter::PointTransform trans;
+  vtkm::filter::field_transform::PointTransform trans;
 
   trans.SetChangeCoordinateSystem(true);
   trans.SetFieldsToPass(map_fields);
diff --git a/src/vtkh/vtkm_filters/vtkmTetrahedralize.cpp b/src/vtkh/vtkm_filters/vtkmTetrahedralize.cpp
index f334d4bb..1ab2552a 100644
--- a/src/vtkh/vtkm_filters/vtkmTetrahedralize.cpp
+++ b/src/vtkh/vtkm_filters/vtkmTetrahedralize.cpp
@@ -1,6 +1,6 @@
 #include "vtkmTetrahedralize.hpp"
 
-#include <vtkm/filter/Tetrahedralize.h>
+#include <vtkm/filter/geometry_refinement/Tetrahedralize.h>
 
 namespace vtkh
 {
@@ -9,7 +9,7 @@ vtkm::cont::DataSet
 vtkmTetrahedralize::Run(vtkm::cont::DataSet &input,
                         vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::Tetrahedralize tet;
+  vtkm::filter::geometry_refinement::Tetrahedralize tet;
   tet.SetFieldsToPass(map_fields);
   auto output = tet.Execute(input);
   return output;
diff --git a/src/vtkh/vtkm_filters/vtkmTriangulate.cpp b/src/vtkh/vtkm_filters/vtkmTriangulate.cpp
index 8f46718b..e165fa4f 100644
--- a/src/vtkh/vtkm_filters/vtkmTriangulate.cpp
+++ b/src/vtkh/vtkm_filters/vtkmTriangulate.cpp
@@ -1,6 +1,6 @@
 #include "vtkmTriangulate.hpp"
 
-#include <vtkm/filter/Triangulate.h>
+#include <vtkm/filter/geometry_refinement/Triangulate.h>
 
 namespace vtkh
 {
@@ -9,7 +9,7 @@ vtkm::cont::DataSet
 vtkmTriangulate::Run(vtkm::cont::DataSet &input,
                      vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::Triangulate tri;
+  vtkm::filter::geometry_refinement::Triangulate tri;
   tri.SetFieldsToPass(map_fields);
   auto output = tri.Execute(input);
   return output;
diff --git a/src/vtkh/vtkm_filters/vtkmVectorMagnitude.cpp b/src/vtkh/vtkm_filters/vtkmVectorMagnitude.cpp
index 71fdb7c8..2b38ea19 100644
--- a/src/vtkh/vtkm_filters/vtkmVectorMagnitude.cpp
+++ b/src/vtkh/vtkm_filters/vtkmVectorMagnitude.cpp
@@ -1,6 +1,6 @@
 #include "vtkmVectorMagnitude.hpp"
 
-#include <vtkm/filter/VectorMagnitude.h>
+#include <vtkm/filter/vector_analysis/VectorMagnitude.h>
 
 namespace vtkh
 {
@@ -10,7 +10,7 @@ vtkmVectorMagnitude::Run(vtkm::cont::DataSet &input,
                          std::string out_field_name,
                          vtkm::filter::FieldSelection map_fields)
 {
-  vtkm::filter::VectorMagnitude mag;
+  vtkm::filter::vector_analysis::VectorMagnitude mag;
   mag.SetActiveField(field_name);
   mag.SetOutputFieldName(out_field_name);
   mag.SetFieldsToPass(map_fields);