From 294a489f5bfc541fff4e1c99b0435e99c349e432 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 23 May 2022 15:29:54 -0400
Subject: [PATCH 001/104] Rough draft at particle advection filters.

---
 vtkm/filter/CMakeLists.txt                    |   4 +-
 vtkm/filter/FilterParticleAdvection.h         |  19 +-
 vtkm/filter/FilterParticleAdvection.hxx       |   3 +
 vtkm/filter/ParticleAdvection.hxx             |   9 +-
 vtkm/filter/ParticleAdvection2.h              |  48 +++
 vtkm/filter/ParticleAdvection2.hxx            | 102 +++++
 vtkm/filter/PathParticle.hxx                  |  10 +-
 vtkm/filter/Pathline.hxx                      |   4 +
 vtkm/filter/Streamline.hxx                    |   9 +-
 vtkm/filter/particleadvection/ABA.h           | 381 ++++++++++++++++++
 .../particleadvection/AdvectorBaseAlgorithm.h |  37 +-
 .../AdvectorBaseThreadedAlgorithm.h           |   2 +
 vtkm/filter/particleadvection/BoundsMap.h     |   2 +-
 vtkm/filter/particleadvection/CMakeLists.txt  |   4 +
 vtkm/filter/particleadvection/DSI.h           | 100 +++++
 vtkm/filter/particleadvection/DSI.hxx         |  95 +++++
 .../particleadvection/DataSetIntegrator.h     |   1 +
 vtkm/filter/particleadvection/PAV.h           |  70 ++++
 .../ParticleAdvectionAlgorithm.h              |   4 +-
 .../ParticleAdvectionTypes.h                  |  42 ++
 .../particleadvection/ParticleMessenger.cxx   |  54 ++-
 .../particleadvection/ParticleMessenger.h     |  19 +-
 .../testing/UnitTestStreamlineFilter.cxx      |  13 +-
 23 files changed, 975 insertions(+), 57 deletions(-)
 create mode 100644 vtkm/filter/ParticleAdvection2.h
 create mode 100644 vtkm/filter/ParticleAdvection2.hxx
 create mode 100644 vtkm/filter/particleadvection/ABA.h
 create mode 100644 vtkm/filter/particleadvection/DSI.h
 create mode 100644 vtkm/filter/particleadvection/DSI.hxx
 create mode 100644 vtkm/filter/particleadvection/PAV.h
 create mode 100644 vtkm/filter/particleadvection/ParticleAdvectionTypes.h

diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index 45b3cd7ab..356356bbf 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -105,6 +105,7 @@ set(extra_headers
   LagrangianStructures.h
   MIRFilter.h
   ParticleAdvection.h
+  ParticleAdvection2.h
   Pathline.h
   PathParticle.h
   Streamline.h
@@ -120,6 +121,7 @@ set(extra_header_template_sources
   LagrangianStructures.hxx
   MIRFilter.hxx
   ParticleAdvection.hxx
+  ParticleAdvection2.hxx
   Pathline.hxx
   PathParticle.hxx
   Streamline.hxx
@@ -128,7 +130,7 @@ set(extra_header_template_sources
 
 set(extra_sources_device
   particleadvection/Messenger.cxx
-  particleadvection/ParticleMessenger.cxx
+  #particleadvection/ParticleMessenger.cxx
   )
 
 set(core_headers
diff --git a/vtkm/filter/FilterParticleAdvection.h b/vtkm/filter/FilterParticleAdvection.h
index 8567ca494..5abbc056c 100644
--- a/vtkm/filter/FilterParticleAdvection.h
+++ b/vtkm/filter/FilterParticleAdvection.h
@@ -15,6 +15,7 @@
 #include <vtkm/filter/FilterDataSetWithField.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
 #include <vtkm/filter/particleadvection/DataSetIntegrator.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
 {
@@ -47,6 +48,17 @@ public:
     this->Seeds = vtkm::cont::make_ArrayHandle(seeds, copyFlag);
   }
 
+  VTKM_CONT
+  void SetSolverRK4()
+  {
+    this->SolverType = vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE;
+  }
+  VTKM_CONT
+  void SetSolverEuler()
+  {
+    this->SolverType = vtkm::filter::particleadvection::IntegrationSolverType::EULER_TYPE;
+  }
+
   VTKM_CONT
   void SetSeeds(vtkm::cont::ArrayHandle<ParticleType>& seeds) { this->Seeds = seeds; }
 
@@ -71,14 +83,19 @@ public:
 protected:
   VTKM_CONT virtual void ValidateOptions() const;
 
+  /*
   VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegrator>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
                            const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
+  */
 
   vtkm::Id NumberOfSteps;
-  vtkm::FloatDefault StepSize;
+  vtkm::filter::particleadvection::ParticleAdvectionResultType ResultType;
   vtkm::cont::ArrayHandle<ParticleType> Seeds;
+  vtkm::filter::particleadvection::IntegrationSolverType SolverType;
+  vtkm::FloatDefault StepSize;
   bool UseThreadedAlgorithm;
+  vtkm::filter::particleadvection::VectorFieldType VecFieldType;
 
 private:
 };
diff --git a/vtkm/filter/FilterParticleAdvection.hxx b/vtkm/filter/FilterParticleAdvection.hxx
index dee896cda..7627e6d79 100644
--- a/vtkm/filter/FilterParticleAdvection.hxx
+++ b/vtkm/filter/FilterParticleAdvection.hxx
@@ -22,6 +22,7 @@ template <typename Derived, typename ParticleType>
 inline VTKM_CONT FilterParticleAdvection<Derived, ParticleType>::FilterParticleAdvection()
   : vtkm::filter::FilterDataSetWithField<Derived>()
   , NumberOfSteps(0)
+  , SolverType(vtkm::filter::particleadvection::RK4_TYPE)
   , StepSize(0)
   , UseThreadedAlgorithm(false)
 {
@@ -40,6 +41,7 @@ void FilterParticleAdvection<Derived, ParticleType>::ValidateOptions() const
     throw vtkm::cont::ErrorFilterExecution("Step size not specified.");
 }
 
+/*
 template <typename Derived, typename ParticleType>
 std::vector<vtkm::filter::particleadvection::DataSetIntegrator>
 FilterParticleAdvection<Derived, ParticleType>::CreateDataSetIntegrators(
@@ -66,6 +68,7 @@ FilterParticleAdvection<Derived, ParticleType>::CreateDataSetIntegrators(
 
   return dsi;
 }
+  */
 
 //-----------------------------------------------------------------------------
 template <typename Derived, typename ParticleType>
diff --git a/vtkm/filter/ParticleAdvection.hxx b/vtkm/filter/ParticleAdvection.hxx
index 3b910b592..cafec087a 100644
--- a/vtkm/filter/ParticleAdvection.hxx
+++ b/vtkm/filter/ParticleAdvection.hxx
@@ -36,11 +36,13 @@ ParticleAdvectionBase<ParticleType>::PrepareForExecution(
   const vtkm::cont::PartitionedDataSet& input,
   const vtkm::filter::PolicyBase<DerivedPolicy>&)
 {
-  using AlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionAlgorithm;
-  using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
-  using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
+  //  using AlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionAlgorithm;
+  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
+  //  using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
 
   this->ValidateOptions();
+  return input;
+#if 0
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
@@ -50,6 +52,7 @@ ParticleAdvectionBase<ParticleType>::PrepareForExecution(
   else
     return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
       boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+#endif
 }
 
 }
diff --git a/vtkm/filter/ParticleAdvection2.h b/vtkm/filter/ParticleAdvection2.h
new file mode 100644
index 000000000..a7e03aaea
--- /dev/null
+++ b/vtkm/filter/ParticleAdvection2.h
@@ -0,0 +1,48 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_ParticleAdvection2_h
+#define vtk_m_filter_ParticleAdvection2_h
+
+#include <vtkm/Particle.h>
+#include <vtkm/filter/FilterParticleAdvection.h>
+
+namespace vtkm
+{
+namespace filter
+{
+/// \brief Advect particles in a vector field.
+
+/// Takes as input a vector field and seed locations and generates the
+/// end points for each seed through the vector field.
+
+class ParticleAdvection2
+  : public vtkm::filter::FilterParticleAdvection<ParticleAdvection2, vtkm::Particle>
+{
+public:
+  VTKM_CONT ParticleAdvection2();
+
+  template <typename DerivedPolicy>
+  vtkm::cont::PartitionedDataSet PrepareForExecution(
+    const vtkm::cont::PartitionedDataSet& input,
+    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
+
+
+  vtkm::cont::UnknownArrayHandle SeedArray;
+};
+
+}
+} // namespace vtkm::filter
+
+#ifndef vtk_m_filter_ParticleAdvection2_hxx
+#include <vtkm/filter/ParticleAdvection2.hxx>
+#endif
+
+#endif // vtk_m_filter_ParticleAdvection_h
diff --git a/vtkm/filter/ParticleAdvection2.hxx b/vtkm/filter/ParticleAdvection2.hxx
new file mode 100644
index 000000000..819693e64
--- /dev/null
+++ b/vtkm/filter/ParticleAdvection2.hxx
@@ -0,0 +1,102 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+#ifndef vtk_m_filter_ParticleAdvection2_hxx
+#define vtk_m_filter_ParticleAdvection2_hxx
+
+#include <vtkm/cont/ErrorFilterExecution.h>
+#include <vtkm/filter/ParticleAdvection2.h>
+#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
+
+#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+
+namespace vtkm
+{
+namespace filter
+{
+
+//-----------------------------------------------------------------------------
+inline VTKM_CONT ParticleAdvection2::ParticleAdvection2()
+  : vtkm::filter::FilterParticleAdvection<ParticleAdvection2, vtkm::Particle>()
+{
+}
+
+//-----------------------------------------------------------------------------
+template <typename DerivedPolicy>
+inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForExecution(
+  const vtkm::cont::PartitionedDataSet& input,
+  const vtkm::filter::PolicyBase<DerivedPolicy>&)
+{
+  //  using AlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionAlgorithm;
+  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
+  using DSIType = vtkm::filter::particleadvection::DSI;
+
+  this->ValidateOptions();
+  //Make sure everything matches up ok.
+  this->VecFieldType = vtkm::filter::particleadvection::VELOCITY_FIELD_TYPE;
+
+  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
+  std::string activeField = this->GetActiveFieldName();
+
+  std::vector<DSIType> dsi;
+  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
+  {
+    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
+    auto ds = input.GetPartition(i);
+    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
+      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
+
+    dsi.push_back(DSIType(ds, blockId, activeField, this->SolverType, this->VecFieldType));
+  }
+
+  std::vector<vtkm::Particle> seeds;
+  seeds.push_back(this->Seeds.ReadPortal().Get(0));
+  seeds.push_back(this->Seeds.ReadPortal().Get(1));
+  seeds.push_back(this->Seeds.ReadPortal().Get(2));
+  std::cout << "SEEDS= " << seeds[0].Pos << " " << seeds[1].Pos << " " << seeds[2].Pos << std::endl;
+
+  //this->SeedArray = this->Seeds;
+  //vtkm::cont::UncertainArrayHandle<vtkm::List<vtkm::Particle>, vtkm::cont::StorageListBasic> arr;
+  //arr = this->Seeds;
+
+  vtkm::filter::particleadvection::PAV pav(boundsMap, dsi, this->UseThreadedAlgorithm);
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
+
+#if 0
+  //std::vector<DSIType> ddsi;
+  /*
+  vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
+    boundsMap, ddsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  */
+
+  vtkm::cont::PartitionedDataSet output;
+  return output;
+
+  /*
+  //using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
+  //std::vector<DSIType> dsi;
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
+
+  if (this->GetUseThreadedAlgorithm())
+    return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
+      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  else
+    return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
+      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  */
+#endif
+}
+
+}
+} // namespace vtkm::filter
+#endif
diff --git a/vtkm/filter/PathParticle.hxx b/vtkm/filter/PathParticle.hxx
index aa82da0ef..960491b05 100644
--- a/vtkm/filter/PathParticle.hxx
+++ b/vtkm/filter/PathParticle.hxx
@@ -36,10 +36,13 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticleBase<ParticleType>::
   const vtkm::cont::PartitionedDataSet& input,
   const vtkm::filter::PolicyBase<DerivedPolicy>&)
 {
-  using AlgorithmType = vtkm::filter::particleadvection::PathParticleAlgorithm;
-  using ThreadedAlgorithmType = vtkm::filter::particleadvection::PathParticleThreadedAlgorithm;
-  using TDSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
+  //  using AlgorithmType = vtkm::filter::particleadvection::PathParticleAlgorithm;
+  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::PathParticleThreadedAlgorithm;
+  //  using TDSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
 
+  return input;
+
+  /*
   this->ValidateOptions(input);
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
@@ -51,6 +54,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticleBase<ParticleType>::
   else
     return vtkm::filter::particleadvection::RunAlgo<TDSIType, AlgorithmType>(
       boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  */
 }
 
 }
diff --git a/vtkm/filter/Pathline.hxx b/vtkm/filter/Pathline.hxx
index a25476b7c..ec932a5d3 100644
--- a/vtkm/filter/Pathline.hxx
+++ b/vtkm/filter/Pathline.hxx
@@ -36,10 +36,12 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathlineBase<ParticleType>::Prep
   const vtkm::cont::PartitionedDataSet& input,
   const vtkm::filter::PolicyBase<DerivedPolicy>&)
 {
+  /*
   using AlgorithmType = vtkm::filter::particleadvection::PathlineAlgorithm;
   using ThreadedAlgorithmType = vtkm::filter::particleadvection::PathlineThreadedAlgorithm;
   using TDSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
 
+
   this->ValidateOptions(input);
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
@@ -51,6 +53,8 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathlineBase<ParticleType>::Prep
   else
     return vtkm::filter::particleadvection::RunAlgo<TDSIType, AlgorithmType>(
       boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  */
+  return input;
 }
 
 }
diff --git a/vtkm/filter/Streamline.hxx b/vtkm/filter/Streamline.hxx
index 86316193a..4c82b541f 100644
--- a/vtkm/filter/Streamline.hxx
+++ b/vtkm/filter/Streamline.hxx
@@ -35,11 +35,13 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet StreamlineBase<ParticleType>::Pr
   const vtkm::cont::PartitionedDataSet& input,
   const vtkm::filter::PolicyBase<DerivedPolicy>&)
 {
-  using AlgorithmType = vtkm::filter::particleadvection::StreamlineAlgorithm;
-  using ThreadedAlgorithmType = vtkm::filter::particleadvection::StreamlineThreadedAlgorithm;
-  using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
+  //  using AlgorithmType = vtkm::filter::particleadvection::StreamlineAlgorithm;
+  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::StreamlineThreadedAlgorithm;
+  //  using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
 
   this->ValidateOptions();
+  return input;
+#if 0
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
@@ -49,6 +51,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet StreamlineBase<ParticleType>::Pr
   else
     return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
       boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+#endif
 }
 
 }
diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/ABA.h
new file mode 100644
index 000000000..ad7a38176
--- /dev/null
+++ b/vtkm/filter/particleadvection/ABA.h
@@ -0,0 +1,381 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_ABA_h
+#define vtk_m_filter_ABA_h
+
+#include <vtkm/cont/PartitionedDataSet.h>
+#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/ParticleMessenger.h>
+
+
+namespace vtkm
+{
+namespace filter
+{
+namespace particleadvection
+{
+
+template <template <typename> class ResultType, typename ParticleType>
+class ABA
+{
+public:
+  ABA(const vtkm::filter::particleadvection::BoundsMap& bm, const std::vector<DSI>& blocks)
+    : Blocks(blocks)
+    , BoundsMap(bm)
+    , NumRanks(this->Comm.size())
+    , Rank(this->Comm.rank())
+  {
+  }
+
+  void Execute(vtkm::Id numSteps,
+               vtkm::FloatDefault stepSize,
+               const vtkm::cont::ArrayHandle<ParticleType>& seeds)
+  {
+    this->SetNumberOfSteps(numSteps);
+    this->SetStepSize(stepSize);
+    this->SetSeeds(seeds);
+    this->Go();
+  }
+
+  vtkm::cont::PartitionedDataSet GetOutput()
+  {
+    std::cout << "GetOutput: " << __FILE__ << " " << __LINE__ << std::endl;
+    auto output = internal::ResultHelper<ResultType, ParticleType>::GetOutput(this->Results);
+    output.PrintSummary(std::cout);
+
+    return output;
+  }
+
+  void SetStepSize(vtkm::FloatDefault stepSize) { this->StepSize = stepSize; }
+  void SetNumberOfSteps(vtkm::Id numSteps) { this->NumberOfSteps = numSteps; }
+  void SetSeeds(const vtkm::cont::ArrayHandle<ParticleType>& seeds)
+  {
+    this->ClearParticles();
+
+    vtkm::Id n = seeds.GetNumberOfValues();
+    auto portal = seeds.ReadPortal();
+    std::cout << "SetSeeds: n= " << n << std::endl;
+
+    std::vector<std::vector<vtkm::Id>> blockIDs;
+    std::vector<ParticleType> particles;
+    for (vtkm::Id i = 0; i < n; i++)
+    {
+      const ParticleType p = portal.Get(i);
+      std::vector<vtkm::Id> ids = this->BoundsMap.FindBlocks(p.Pos);
+      std::cout << "  " << i << " " << p.Pos << " ids= " << ids.size()
+                << " BM= " << this->BoundsMap.GlobalBounds << " "
+                << this->BoundsMap.FindRank(ids[0]) << " " << this->Rank << std::endl;
+
+      if (!ids.empty() && this->BoundsMap.FindRank(ids[0]) == this->Rank)
+      {
+        particles.push_back(p);
+        blockIDs.push_back(ids);
+      }
+    }
+
+    this->SetSeedArray(particles, blockIDs);
+  }
+
+
+  //Advect all the particles.
+  virtual void Go()
+  {
+    vtkm::filter::particleadvection::ParticleMessenger<ParticleType> messenger(
+      this->Comm, this->BoundsMap, 1, 128);
+
+    vtkm::Id nLocal = static_cast<vtkm::Id>(this->Active.size() + this->Inactive.size());
+    this->ComputeTotalNumParticles(nLocal);
+    this->TotalNumTerminatedParticles = 0;
+    std::cout << "Go() nParticles= " << nLocal << std::endl;
+    std::cout << "    BM= " << this->BoundsMap.GlobalBounds << std::endl;
+
+    while (this->TotalNumTerminatedParticles < this->TotalNumParticles)
+    {
+      std::cout << __FILE__ << " " << __LINE__ << std::endl;
+      std::vector<ParticleType> v;
+      vtkm::Id numTerm = 0, blockId = -1;
+      if (GetActiveParticles(v, blockId))
+      {
+        const auto& block = this->GetDataSet(blockId);
+        ResultType<ParticleType> r;
+        block.Advect(v, this->StepSize, this->NumberOfSteps, r);
+        numTerm = this->UpdateResult(r, blockId);
+        std::cout << " Advect: " << v.size() << " NT= " << numTerm << std::endl;
+      }
+
+      vtkm::Id numTermMessages = 0;
+      this->Communicate(messenger, numTerm, numTermMessages);
+
+      this->TotalNumTerminatedParticles += (numTerm + numTermMessages);
+      if (this->TotalNumTerminatedParticles > this->TotalNumParticles)
+        throw vtkm::cont::ErrorFilterExecution("Particle count error");
+    }
+  }
+
+  virtual void ClearParticles()
+  {
+    this->Active.clear();
+    this->Inactive.clear();
+    this->ParticleBlockIDsMap.clear();
+  }
+
+  void ComputeTotalNumParticles(const vtkm::Id& numLocal)
+  {
+    long long total = static_cast<long long>(numLocal);
+#ifdef VTKM_ENABLE_MPI
+    MPI_Comm mpiComm = vtkmdiy::mpi::mpi_cast(this->Comm.handle());
+    MPI_Allreduce(MPI_IN_PLACE, &total, 1, MPI_LONG_LONG, MPI_SUM, mpiComm);
+#endif
+    this->TotalNumParticles = static_cast<vtkm::Id>(total);
+  }
+
+  const DSI& GetDataSet(vtkm::Id id) const
+  {
+    for (const auto& it : this->Blocks)
+      if (it.GetID() == id)
+        return it;
+    throw vtkm::cont::ErrorFilterExecution("Bad block");
+  }
+
+  virtual void SetSeedArray(const std::vector<ParticleType>& particles,
+                            const std::vector<std::vector<vtkm::Id>>& blockIds)
+  {
+    VTKM_ASSERT(particles.size() == blockIds.size());
+
+    auto pit = particles.begin();
+    auto bit = blockIds.begin();
+    while (pit != particles.end() && bit != blockIds.end())
+    {
+      this->ParticleBlockIDsMap[pit->ID] = *bit;
+      pit++;
+      bit++;
+    }
+
+    this->Active.insert(this->Active.end(), particles.begin(), particles.end());
+    std::cout << " numActive= " << this->Active.size() << " p= " << particles.size() << std::endl;
+  }
+
+  virtual bool GetActiveParticles(std::vector<ParticleType>& particles, vtkm::Id& blockId)
+  {
+    particles.clear();
+    blockId = -1;
+    if (this->Active.empty())
+      return false;
+
+    blockId = this->ParticleBlockIDsMap[this->Active.front().ID][0];
+    auto it = this->Active.begin();
+    while (it != this->Active.end())
+    {
+      auto p = *it;
+      if (blockId == this->ParticleBlockIDsMap[p.ID][0])
+      {
+        particles.push_back(p);
+        it = this->Active.erase(it);
+      }
+      else
+        it++;
+    }
+
+    return !particles.empty();
+  }
+
+  virtual void Communicate(
+    vtkm::filter::particleadvection::ParticleMessenger<ParticleType>& messenger,
+    vtkm::Id numLocalTerminations,
+    vtkm::Id& numTermMessages)
+  {
+    std::vector<ParticleType> incoming;
+    std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> incomingIDs;
+    numTermMessages = 0;
+    messenger.Exchange(this->Inactive,
+                       this->ParticleBlockIDsMap,
+                       numLocalTerminations,
+                       incoming,
+                       incomingIDs,
+                       numTermMessages,
+                       this->GetBlockAndWait(numLocalTerminations));
+
+    this->Inactive.clear();
+    this->UpdateActive(incoming, incomingIDs);
+  }
+
+  virtual void UpdateActive(const std::vector<ParticleType>& particles,
+                            const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMap)
+  {
+    this->Update(this->Active, particles, idsMap);
+  }
+
+  virtual void UpdateInactive(const std::vector<ParticleType>& particles,
+                              const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMap)
+  {
+    this->Update(this->Inactive, particles, idsMap);
+  }
+
+  void Update(std::vector<ParticleType>& arr,
+              const std::vector<ParticleType>& particles,
+              const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMap)
+  {
+    VTKM_ASSERT(particles.size() == idsMap.size());
+
+    arr.insert(arr.end(), particles.begin(), particles.end());
+    for (const auto& it : idsMap)
+      this->ParticleBlockIDsMap[it.first] = it.second;
+  }
+
+  void UpdateTerminated(const vtkm::cont::ArrayHandle<ParticleType>& particles,
+                        const std::vector<vtkm::Id>& idxTerm)
+  {
+    auto portal = particles.ReadPortal();
+    for (const auto& idx : idxTerm)
+      this->ParticleBlockIDsMap.erase(portal.Get(idx).ID);
+  }
+
+  void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
+                         std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMapA,
+                         std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMapI,
+                         std::vector<ParticleType>& A,
+                         std::vector<ParticleType>& I,
+                         std::vector<vtkm::Id>& termIdx) const
+  {
+    A.clear();
+    I.clear();
+    termIdx.clear();
+    idsMapI.clear();
+    idsMapA.clear();
+
+    auto portal = particles.WritePortal();
+    vtkm::Id n = portal.GetNumberOfValues();
+
+    for (vtkm::Id i = 0; i < n; i++)
+    {
+      auto p = portal.Get(i);
+
+      if (p.Status.CheckTerminate())
+        termIdx.push_back(i);
+      else
+      {
+        const auto& it = this->ParticleBlockIDsMap.find(p.ID);
+        VTKM_ASSERT(it != this->ParticleBlockIDsMap.end());
+        auto currBIDs = it->second;
+        VTKM_ASSERT(!currBIDs.empty());
+
+        std::vector<vtkm::Id> newIDs;
+        if (p.Status.CheckSpatialBounds() && !p.Status.CheckTookAnySteps())
+          newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
+        else
+          newIDs = this->BoundsMap.FindBlocks(p.Pos, currBIDs);
+
+        //reset the particle status.
+        p.Status = vtkm::ParticleStatus();
+
+        if (newIDs.empty()) //No blocks, we're done.
+        {
+          p.Status.SetTerminate();
+          termIdx.push_back(i);
+        }
+        else
+        {
+          //If we have more than blockId, we want to minimize communication
+          //and put any blocks owned by this rank first.
+          if (newIDs.size() > 1)
+          {
+            for (auto idit = newIDs.begin(); idit != newIDs.end(); idit++)
+            {
+              vtkm::Id bid = *idit;
+              if (this->BoundsMap.FindRank(bid) == this->Rank)
+              {
+                newIDs.erase(idit);
+                newIDs.insert(newIDs.begin(), bid);
+                break;
+              }
+            }
+          }
+
+          int dstRank = this->BoundsMap.FindRank(newIDs[0]);
+          if (dstRank == this->Rank)
+          {
+            A.push_back(p);
+            idsMapA[p.ID] = newIDs;
+          }
+          else
+          {
+            I.push_back(p);
+            idsMapI[p.ID] = newIDs;
+          }
+        }
+        portal.Set(i, p);
+      }
+    }
+
+    //Make sure we didn't miss anything. Every particle goes into a single bucket.
+    VTKM_ASSERT(static_cast<std::size_t>(n) == (A.size() + I.size() + termIdx.size()));
+  }
+
+  vtkm::Id UpdateResult(ResultType<ParticleType>& res, vtkm::Id blockId)
+  {
+    std::cout << "UpdateResult: blockId= " << blockId << std::endl;
+    std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> idsMapI, idsMapA;
+    std::vector<ParticleType> A, I;
+    std::vector<vtkm::Id> termIdx;
+    this->ClassifyParticles(res.Particles, idsMapA, idsMapI, A, I, termIdx);
+
+    //Update active, inactive and terminated
+    this->UpdateActive(A, idsMapA);
+    this->UpdateInactive(I, idsMapI);
+
+    vtkm::Id numTerm = static_cast<vtkm::Id>(termIdx.size());
+    if (numTerm > 0)
+      this->UpdateTerminated(res.Particles, termIdx);
+
+    internal::ResultHelper<ResultType, ParticleType>::Store(this->Results, res, blockId, termIdx);
+
+    return numTerm;
+  }
+
+  virtual bool GetBlockAndWait(const vtkm::Id& numLocalTerm)
+  {
+    //There are only two cases where blocking would deadlock.
+    //1. There are active particles.
+    //2. numLocalTerm + this->TotalNumberOfTerminatedParticles == this->TotalNumberOfParticles
+    //So, if neither are true, we can safely block and wait for communication to come in.
+
+    if (this->Active.empty() && this->Inactive.empty() &&
+        (numLocalTerm + this->TotalNumTerminatedParticles < this->TotalNumParticles))
+    {
+      return true;
+    }
+
+    return false;
+  }
+
+  //Member data
+  std::vector<ParticleType> Active;
+  std::vector<DSI> Blocks;
+  vtkm::filter::particleadvection::BoundsMap BoundsMap;
+  vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
+  std::vector<ParticleType> Inactive;
+  vtkm::Id NumberOfSteps;
+  vtkm::Id NumRanks;
+  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
+  vtkm::Id Rank;
+  std::map<vtkm::Id, std::vector<ResultType<ParticleType>>> Results;
+  vtkm::FloatDefault StepSize;
+  vtkm::Id TotalNumParticles;
+  vtkm::Id TotalNumTerminatedParticles;
+};
+
+}
+}
+}
+
+
+#endif //vtk_m_filter_ABA_h
diff --git a/vtkm/filter/particleadvection/AdvectorBaseAlgorithm.h b/vtkm/filter/particleadvection/AdvectorBaseAlgorithm.h
index 8695b62b9..5384dc709 100644
--- a/vtkm/filter/particleadvection/AdvectorBaseAlgorithm.h
+++ b/vtkm/filter/particleadvection/AdvectorBaseAlgorithm.h
@@ -33,32 +33,37 @@ namespace internal
 {
 
 //Helper class to store the different result types.
-template <typename ResultType>
+//template <typename ResultType>
+template <template <typename> class ResultType, typename ParticleType>
 class ResultHelper;
 
 //Specialization for ParticleAdvectionResult
-using PAType = vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>;
+//using PAType = vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>;
 
-template <>
-class ResultHelper<PAType>
+template <typename ParticleType>
+class ResultHelper<vtkm::worklet::ParticleAdvectionResult, ParticleType>
 {
+  using PAType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+
 public:
   static void Store(std::map<vtkm::Id, std::vector<PAType>>& results,
                     const PAType& res,
                     vtkm::Id blockId,
                     const std::vector<vtkm::Id>& indices)
   {
+    std::cout << "Store: indices= " << indices.size() << std::endl;
     if (indices.empty())
       return;
 
     //Selected out the terminated particles and store them.
-    vtkm::cont::ArrayHandle<vtkm::Particle> termParticles;
+    vtkm::cont::ArrayHandle<ParticleType> termParticles;
     auto indicesAH = vtkm::cont::make_ArrayHandle(indices, vtkm::CopyFlag::Off);
     auto perm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, res.Particles);
 
     vtkm::cont::Algorithm::Copy(perm, termParticles);
     PAType termRes(termParticles);
     results[blockId].push_back(termRes);
+    std::cout << "Store: " << results.size() << std::endl;
   }
 
   static vtkm::cont::PartitionedDataSet GetOutput(
@@ -71,7 +76,7 @@ public:
       if (nResults == 0)
         continue;
 
-      std::vector<vtkm::cont::ArrayHandle<vtkm::Particle>> allParticles;
+      std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
       allParticles.reserve(static_cast<std::size_t>(nResults));
 
       for (const auto& res : it.second)
@@ -102,11 +107,13 @@ public:
 };
 
 //Specialization for StreamlineResult
-using SLType = vtkm::worklet::StreamlineResult<vtkm::Particle>;
+//using SLType = vtkm::worklet::StreamlineResult<vtkm::Particle>;
 
-template <>
-class ResultHelper<SLType>
+template <typename ParticleType>
+class ResultHelper<vtkm::worklet::StreamlineResult, ParticleType>
 {
+  using SLType = vtkm::worklet::StreamlineResult<ParticleType>;
+
 public:
   static void Store(std::map<vtkm::Id, std::vector<SLType>>& results,
                     const SLType& res,
@@ -204,6 +211,7 @@ public:
 };
 };
 
+
 template <typename DataSetIntegratorType, typename AlgorithmType>
 vtkm::cont::PartitionedDataSet RunAlgo(const vtkm::filter::particleadvection::BoundsMap& boundsMap,
                                        const std::vector<DataSetIntegratorType>& dsi,
@@ -220,6 +228,7 @@ vtkm::cont::PartitionedDataSet RunAlgo(const vtkm::filter::particleadvection::Bo
   return algo.GetOutput();
 }
 
+#if 0
 //
 // Base class for particle advector
 //
@@ -299,7 +308,9 @@ public:
 
   vtkm::cont::PartitionedDataSet GetOutput() const
   {
-    return internal::ResultHelper<ResultType>::GetOutput(this->Results);
+    std::cout<<" ************************** "<<__FILE__<<" "<<__LINE__<<std::endl;
+    //return internal::ResultHelper<ResultType, vtkm::Particle>::GetOutput(this->Results);
+    return vtkm::cont::PartitionedDataSet();
   }
 
 protected:
@@ -501,7 +512,7 @@ protected:
   }
 
 
-  vtkm::Id UpdateResult(ResultType& res, vtkm::Id blockId)
+  vtkm::Id UpdateResult(ResultType& res, vtkm::Id /*blockId*/)
   {
     std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> idsMapI, idsMapA;
     std::vector<vtkm::Particle> A, I;
@@ -516,7 +527,8 @@ protected:
     if (numTerm > 0)
       this->UpdateTerminated(res.Particles, termIdx);
 
-    internal::ResultHelper<ResultType>::Store(this->Results, res, blockId, termIdx);
+    std::cout<<" ************************** "<<__FILE__<<" "<<__LINE__<<std::endl;
+    //internal::ResultHelper<ResultType, vtkm::Particle>::Store(this->Results, res, blockId, termIdx);
 
     return numTerm;
   }
@@ -552,6 +564,7 @@ protected:
   vtkm::Id TotalNumParticles;
   vtkm::Id TotalNumTerminatedParticles;
 };
+#endif
 
 }
 }
diff --git a/vtkm/filter/particleadvection/AdvectorBaseThreadedAlgorithm.h b/vtkm/filter/particleadvection/AdvectorBaseThreadedAlgorithm.h
index 5421a1f4b..d6bb94610 100644
--- a/vtkm/filter/particleadvection/AdvectorBaseThreadedAlgorithm.h
+++ b/vtkm/filter/particleadvection/AdvectorBaseThreadedAlgorithm.h
@@ -22,6 +22,7 @@ namespace filter
 namespace particleadvection
 {
 
+#if 0
 template <typename DataSetIntegratorType, typename ResultType>
 class VTKM_ALWAYS_EXPORT AdvectorBaseThreadedAlgorithm
   : public AdvectorBaseAlgorithm<DataSetIntegratorType, ResultType>
@@ -181,6 +182,7 @@ protected:
   std::condition_variable WorkerActivateCondition;
   std::unordered_map<vtkm::Id, std::vector<ResultType>> WorkerResults;
 };
+#endif
 
 }
 }
diff --git a/vtkm/filter/particleadvection/BoundsMap.h b/vtkm/filter/particleadvection/BoundsMap.h
index 705aba99a..4af93e954 100644
--- a/vtkm/filter/particleadvection/BoundsMap.h
+++ b/vtkm/filter/particleadvection/BoundsMap.h
@@ -107,7 +107,7 @@ public:
   vtkm::Id GetTotalNumBlocks() const { return this->TotalNumBlocks; }
   vtkm::Id GetLocalNumBlocks() const { return this->LocalNumBlocks; }
 
-private:
+  //private:
   void Init(const std::vector<vtkm::cont::DataSet>& dataSets)
   {
     vtkm::cont::AssignerPartitionedDataSet assigner(this->LocalNumBlocks);
diff --git a/vtkm/filter/particleadvection/CMakeLists.txt b/vtkm/filter/particleadvection/CMakeLists.txt
index 765954149..d5077bf2b 100644
--- a/vtkm/filter/particleadvection/CMakeLists.txt
+++ b/vtkm/filter/particleadvection/CMakeLists.txt
@@ -18,6 +18,10 @@ set(headers
   Messenger.h
   ParticleAdvectionAlgorithm.h
   ParticleMessenger.h
+  DSI.h
+  ABA.h
+  PAV.h
+  ParticleAdvectionTypes.h
 )
 
 #-----------------------------------------------------------------------------
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
new file mode 100644
index 000000000..21c9f1e8d
--- /dev/null
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -0,0 +1,100 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_DSI_h
+#define vtk_m_filter_DSI_h
+
+#include <vtkm/cont/DataSet.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/worklet/ParticleAdvection.h>
+#include <vtkm/worklet/particleadvection/EulerIntegrator.h>
+#include <vtkm/worklet/particleadvection/IntegratorStatus.h>
+#include <vtkm/worklet/particleadvection/RK4Integrator.h>
+#include <vtkm/worklet/particleadvection/Stepper.h>
+
+namespace vtkm
+{
+namespace filter
+{
+namespace particleadvection
+{
+
+class DSI
+{
+public:
+  DSI(const vtkm::cont::DataSet& ds,
+      vtkm::Id id,
+      const std::string& fieldNm,
+      vtkm::filter::particleadvection::IntegrationSolverType solverType,
+      vtkm::filter::particleadvection::VectorFieldType vecFieldType)
+  {
+    this->SolverType = solverType;
+    this->VecFieldType = vecFieldType;
+    this->DataSet = ds;
+    this->Id = id;
+    this->FieldName = fieldNm;
+
+    //check that things are valid.
+  }
+
+  VTKM_CONT vtkm::Id GetID() const { return this->Id; }
+  VTKM_CONT void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
+
+  //template <typename ParticleType, typename ResultType>
+  template <typename ParticleType, template <typename> class ResultType>
+  VTKM_CONT void Advect(std::vector<ParticleType>& v,
+                        vtkm::FloatDefault stepSize, //move these to member data(?)
+                        vtkm::Id maxSteps,
+                        ResultType<ParticleType>& result) const;
+
+  template <typename ArrayType>
+  VTKM_CONT void GetVelocityField(
+    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
+  {
+    auto assoc = this->DataSet.GetField(this->FieldName).GetAssociation();
+    ArrayType arr;
+    vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(), arr);
+
+    velocityField = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr, assoc);
+  }
+
+  template <typename ArrayType>
+  VTKM_CONT void GetElectroMagneticField(
+    vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& elecMagField) const
+  {
+    ArrayType arr1, arr2;
+    vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(), arr1);
+    vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(),
+                                           arr2); //fieldname 2
+    auto assoc = this->DataSet.GetField(this->FieldName).GetAssociation();
+
+    elecMagField =
+      vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>(arr1, arr2, assoc);
+  }
+
+  //private:
+  vtkm::cont::DataSet DataSet;
+  vtkm::Id Id;
+  std::string FieldName;
+  vtkm::filter::particleadvection::IntegrationSolverType SolverType;
+  vtkm::filter::particleadvection::VectorFieldType VecFieldType;
+  bool CopySeedArray = false;
+  //Add results array?
+};
+
+}
+}
+}
+
+#ifndef vtk_m_filter_particleadvection_DSI_hxx
+#include <vtkm/filter/particleadvection/DSI.hxx>
+#endif
+
+#endif //vtk_m_filter_DSI_h
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
new file mode 100644
index 000000000..717578e26
--- /dev/null
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -0,0 +1,95 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_DSI_hxx
+#define vtk_m_filter_DSI_hxx
+
+namespace vtkm
+{
+namespace filter
+{
+namespace particleadvection
+{
+
+template <typename ParticleType, template <typename> class ResultType>
+VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
+                           vtkm::FloatDefault stepSize,
+                           vtkm::Id maxSteps,
+                           ResultType<ParticleType>& result) const
+{
+  //using Association = vtkm::cont::Field::Association;
+  using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+
+  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
+  auto seedArray = vtkm::cont::make_ArrayHandle(v, copyFlag);
+
+  std::cout << "DSI::Advect() " << v.size() << std::endl;
+
+  if (this->SolverType == IntegrationSolverType::RK4_TYPE)
+  {
+    if (this->VecFieldType == VELOCITY_FIELD_TYPE) //vtkm::Particle, VelocityField
+    {
+      using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+      using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+      using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
+      using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
+
+      FieldType velField;
+      this->GetVelocityField(velField);
+
+      GridEvType eval(this->DataSet, velField);
+      StepperType stepper(eval, stepSize);
+      vtkm::worklet::ParticleAdvection Worklet;
+      result = Worklet.Run(stepper, seedArray, maxSteps);
+      //Put results in unknown array??
+    }
+    else if (this->VecFieldType == ELECTRO_MAGNETIC_FIELD_TYPE) //vtkm::ChargedParticle
+    {
+      using FieldType = vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>;
+      using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+      using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
+      using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
+
+      FieldType velField;
+      this->GetElectroMagneticField(velField);
+
+      GridEvType eval(this->DataSet, velField);
+      StepperType stepper(eval, stepSize);
+      vtkm::worklet::ParticleAdvection Worklet;
+      result = Worklet.Run(stepper, seedArray, maxSteps);
+    }
+  }
+
+  else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
+  {
+    if (this->VecFieldType == VELOCITY_FIELD_TYPE) //vtkm::Particle, VelocityField
+    {
+      using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+      using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+      using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
+      using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
+
+      FieldType velField;
+      this->GetVelocityField(velField);
+
+      GridEvType eval(this->DataSet, velField);
+      StepperType stepper(eval, stepSize);
+      vtkm::worklet::ParticleAdvection Worklet;
+      result = Worklet.Run(stepper, seedArray, maxSteps);
+      //Put results in unknown array??
+    }
+  }
+}
+
+}
+}
+}
+
+#endif //vtk_m_filter_DSI_hxx
diff --git a/vtkm/filter/particleadvection/DataSetIntegrator.h b/vtkm/filter/particleadvection/DataSetIntegrator.h
index 793c7ed9c..0e04de28d 100644
--- a/vtkm/filter/particleadvection/DataSetIntegrator.h
+++ b/vtkm/filter/particleadvection/DataSetIntegrator.h
@@ -14,6 +14,7 @@
 #include <vtkm/cont/ArrayHandleTransform.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/worklet/ParticleAdvection.h>
+#include <vtkm/worklet/particleadvection/EulerIntegrator.h>
 #include <vtkm/worklet/particleadvection/RK4Integrator.h>
 #include <vtkm/worklet/particleadvection/Stepper.h>
 #include <vtkm/worklet/particleadvection/TemporalGridEvaluators.h>
diff --git a/vtkm/filter/particleadvection/PAV.h b/vtkm/filter/particleadvection/PAV.h
new file mode 100644
index 000000000..d8f05e36b
--- /dev/null
+++ b/vtkm/filter/particleadvection/PAV.h
@@ -0,0 +1,70 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_particleadvection_PAV_h
+#define vtk_m_filter_particleadvection_PAV_h
+
+#include <vtkm/filter/particleadvection/ABA.h>
+#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/particleadvection/DSI.h>
+
+namespace vtkm
+{
+namespace filter
+{
+namespace particleadvection
+{
+
+class PAV
+{
+public:
+  PAV(const vtkm::filter::particleadvection::BoundsMap& bm,
+      const std::vector<DSI>& blocks,
+      const bool& useThreaded)
+    : Blocks(blocks)
+    , BoundsMap(bm)
+    , UseThreadedAlgorithm(useThreaded)
+  {
+  }
+
+  vtkm::cont::PartitionedDataSet Execute(vtkm::Id numSteps,
+                                         vtkm::FloatDefault stepSize,
+                                         const vtkm::cont::ArrayHandle<vtkm::Particle>& seeds)
+  {
+    if (!this->UseThreadedAlgorithm)
+    {
+      using AlgorithmType =
+        vtkm::filter::particleadvection::ABA<vtkm::worklet::ParticleAdvectionResult,
+                                             vtkm::Particle>;
+
+      AlgorithmType algo(this->BoundsMap, this->Blocks);
+      algo.Execute(numSteps, stepSize, seeds);
+      return algo.GetOutput();
+    }
+    else
+    {
+      //using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
+      //AlgorithmType algo;
+    }
+
+    throw vtkm::cont::ErrorFilterExecution("Unsupported options in ABA");
+  }
+
+  std::vector<DSI> Blocks;
+  vtkm::filter::particleadvection::BoundsMap BoundsMap;
+  bool UseThreadedAlgorithm;
+};
+
+}
+}
+}
+
+
+#endif //vtk_m_filter_particleadvection_PAV_h
diff --git a/vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h b/vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h
index d75cb9237..7dc3d244c 100644
--- a/vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h
+++ b/vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h
@@ -22,6 +22,8 @@ namespace filter
 namespace particleadvection
 {
 
+#if 0
+
 using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
 using TDSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
 
@@ -142,7 +144,7 @@ public:
   }
 };
 
-
+#endif
 
 }
 }
diff --git a/vtkm/filter/particleadvection/ParticleAdvectionTypes.h b/vtkm/filter/particleadvection/ParticleAdvectionTypes.h
new file mode 100644
index 000000000..9851c5020
--- /dev/null
+++ b/vtkm/filter/particleadvection/ParticleAdvectionTypes.h
@@ -0,0 +1,42 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+#ifndef vtk_m_filter_particleadvection_ParticleAdvectionTypes_h
+#define vtk_m_filter_particleadvection_ParticleAdvectionTypes_h
+
+namespace vtkm
+{
+namespace filter
+{
+namespace particleadvection
+{
+enum IntegrationSolverType
+{
+  RK4_TYPE = 0,
+  EULER_TYPE,
+};
+
+enum VectorFieldType
+{
+  VELOCITY_FIELD_TYPE = 0,
+  ELECTRO_MAGNETIC_FIELD_TYPE,
+};
+
+enum ParticleAdvectionResultType
+{
+  PARTICLE_ADVECT_TYPE = 0,
+  STREAMLINE_TYPE,
+};
+
+}
+}
+}
+
+
+#endif // vtk_m_filter_particleadvection_ParticleAdvectionTypes_h
diff --git a/vtkm/filter/particleadvection/ParticleMessenger.cxx b/vtkm/filter/particleadvection/ParticleMessenger.cxx
index b65f6460b..b26963c20 100644
--- a/vtkm/filter/particleadvection/ParticleMessenger.cxx
+++ b/vtkm/filter/particleadvection/ParticleMessenger.cxx
@@ -23,11 +23,13 @@ namespace particleadvection
 {
 
 VTKM_CONT
-ParticleMessenger::ParticleMessenger(vtkmdiy::mpi::communicator& comm,
-                                     const vtkm::filter::particleadvection::BoundsMap& boundsMap,
-                                     int msgSz,
-                                     int numParticles,
-                                     int numBlockIds)
+template <typename ParticleType>
+ParticleMessenger<ParticleType>::ParticleMessenger(
+  vtkmdiy::mpi::communicator& comm,
+  const vtkm::filter::particleadvection::BoundsMap& boundsMap,
+  int msgSz,
+  int numParticles,
+  int numBlockIds)
   : Messenger(comm)
 #ifdef VTKM_ENABLE_MPI
   , BoundsMap(boundsMap)
@@ -43,7 +45,9 @@ ParticleMessenger::ParticleMessenger(vtkmdiy::mpi::communicator& comm,
 #endif
 }
 
-std::size_t ParticleMessenger::CalcParticleBufferSize(std::size_t nParticles, std::size_t nBlockIds)
+template <typename ParticleType>
+std::size_t ParticleMessenger<ParticleType>::CalcParticleBufferSize(std::size_t nParticles,
+                                                                    std::size_t nBlockIds)
 {
   constexpr std::size_t pSize = sizeof(vtkm::Vec3f) // Pos
     + sizeof(vtkm::Id)                              // ID
@@ -53,10 +57,10 @@ std::size_t ParticleMessenger::CalcParticleBufferSize(std::size_t nParticles, st
 
 #ifndef NDEBUG
   vtkmdiy::MemoryBuffer buff;
-  vtkm::Particle p;
+  ParticleType p;
   vtkmdiy::save(buff, p);
 
-  //If this assert fires, vtkm::Particle changed
+  //If this assert fires, ParticleType changed
   //and pSize should be updated.
   VTKM_ASSERT(pSize == buff.size());
 #endif
@@ -64,10 +68,10 @@ std::size_t ParticleMessenger::CalcParticleBufferSize(std::size_t nParticles, st
   return
     // rank
     sizeof(int)
-    //std::vector<vtkm::Particle> p;
+    //std::vector<ParticleType> p;
     //p.size()
     + sizeof(std::size_t)
-    //nParticles of vtkm::Particle
+    //nParticles of ParticleType
     + nParticles * pSize
     // std::vector<vtkm::Id> blockIDs for each particle.
     // blockIDs.size() for each particle
@@ -77,11 +81,12 @@ std::size_t ParticleMessenger::CalcParticleBufferSize(std::size_t nParticles, st
 }
 
 VTKM_CONT
-void ParticleMessenger::SerialExchange(
-  const std::vector<vtkm::Particle>& outData,
+template <typename ParticleType>
+void ParticleMessenger<ParticleType>::SerialExchange(
+  const std::vector<ParticleType>& outData,
   const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
   vtkm::Id vtkmNotUsed(numLocalTerm),
-  std::vector<vtkm::Particle>& inData,
+  std::vector<ParticleType>& inData,
   std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
   bool vtkmNotUsed(blockAndWait)) const
 {
@@ -94,11 +99,12 @@ void ParticleMessenger::SerialExchange(
 }
 
 VTKM_CONT
-void ParticleMessenger::Exchange(
-  const std::vector<vtkm::Particle>& outData,
+template <typename ParticleType>
+void ParticleMessenger<ParticleType>::Exchange(
+  const std::vector<ParticleType>& outData,
   const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
   vtkm::Id numLocalTerm,
-  std::vector<vtkm::Particle>& inData,
+  std::vector<ParticleType>& inData,
   std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
   vtkm::Id& numTerminateMessages,
   bool blockAndWait)
@@ -154,7 +160,8 @@ void ParticleMessenger::Exchange(
 #ifdef VTKM_ENABLE_MPI
 
 VTKM_CONT
-void ParticleMessenger::RegisterMessages(int msgSz, int nParticles, int numBlockIds)
+template <typename ParticleType>
+void ParticleMessenger<ParticleType>::RegisterMessages(int msgSz, int nParticles, int numBlockIds)
 {
   //Determine buffer size for msg and particle tags.
   std::size_t messageBuffSz = CalcMessageBufferSize(msgSz + 1);
@@ -169,7 +176,8 @@ void ParticleMessenger::RegisterMessages(int msgSz, int nParticles, int numBlock
 }
 
 VTKM_CONT
-void ParticleMessenger::SendMsg(int dst, const std::vector<int>& msg)
+template <typename ParticleType>
+void ParticleMessenger<ParticleType>::SendMsg(int dst, const std::vector<int>& msg)
 {
   vtkmdiy::MemoryBuffer buff;
 
@@ -180,7 +188,8 @@ void ParticleMessenger::SendMsg(int dst, const std::vector<int>& msg)
 }
 
 VTKM_CONT
-void ParticleMessenger::SendAllMsg(const std::vector<int>& msg)
+template <typename ParticleType>
+void ParticleMessenger<ParticleType>::SendAllMsg(const std::vector<int>& msg)
 {
   for (int i = 0; i < this->GetNumRanks(); i++)
     if (i != this->GetRank())
@@ -188,9 +197,10 @@ void ParticleMessenger::SendAllMsg(const std::vector<int>& msg)
 }
 
 VTKM_CONT
-bool ParticleMessenger::RecvAny(std::vector<MsgCommType>* msgs,
-                                std::vector<ParticleRecvCommType>* recvParticles,
-                                bool blockAndWait)
+template <typename ParticleType>
+bool ParticleMessenger<ParticleType>::RecvAny(std::vector<MsgCommType>* msgs,
+                                              std::vector<ParticleRecvCommType>* recvParticles,
+                                              bool blockAndWait)
 {
   std::set<int> tags;
   if (msgs)
diff --git a/vtkm/filter/particleadvection/ParticleMessenger.h b/vtkm/filter/particleadvection/ParticleMessenger.h
index 87435804a..7ceb7b124 100644
--- a/vtkm/filter/particleadvection/ParticleMessenger.h
+++ b/vtkm/filter/particleadvection/ParticleMessenger.h
@@ -30,13 +30,14 @@ namespace filter
 namespace particleadvection
 {
 
+template <typename ParticleType>
 class VTKM_FILTER_EXTRA_EXPORT ParticleMessenger : public vtkm::filter::particleadvection::Messenger
 {
   //sendRank, message
   using MsgCommType = std::pair<int, std::vector<int>>;
 
   //particle + blockIDs.
-  using ParticleCommType = std::pair<vtkm::Particle, std::vector<vtkm::Id>>;
+  using ParticleCommType = std::pair<ParticleType, std::vector<vtkm::Id>>;
 
   //sendRank, vector of ParticleCommType.
   using ParticleRecvCommType = std::pair<int, std::vector<ParticleCommType>>;
@@ -49,10 +50,10 @@ public:
                               int numBlockIds = 2);
   VTKM_CONT ~ParticleMessenger() {}
 
-  VTKM_CONT void Exchange(const std::vector<vtkm::Particle>& outData,
+  VTKM_CONT void Exchange(const std::vector<ParticleType>& outData,
                           const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
                           vtkm::Id numLocalTerm,
-                          std::vector<vtkm::Particle>& inData,
+                          std::vector<ParticleType>& inData,
                           std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
                           vtkm::Id& numTerminateMessages,
                           bool blockAndWait = false);
@@ -98,10 +99,10 @@ protected:
 #endif
 
   VTKM_CONT void SerialExchange(
-    const std::vector<vtkm::Particle>& outData,
+    const std::vector<ParticleType>& outData,
     const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
     vtkm::Id numLocalTerm,
-    std::vector<vtkm::Particle>& inData,
+    std::vector<ParticleType>& inData,
     std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
     bool blockAndWait) const;
 
@@ -111,8 +112,10 @@ protected:
 
 #ifdef VTKM_ENABLE_MPI
 VTKM_CONT
+template <typename ParticleType>
 template <typename P, template <typename, typename> class Container, typename Allocator>
-inline void ParticleMessenger::SendParticles(int dst, const Container<P, Allocator>& c)
+inline void ParticleMessenger<ParticleType>::SendParticles(int dst,
+                                                           const Container<P, Allocator>& c)
 {
   if (dst == this->GetRank())
   {
@@ -129,8 +132,9 @@ inline void ParticleMessenger::SendParticles(int dst, const Container<P, Allocat
 }
 
 VTKM_CONT
+template <typename ParticleType>
 template <typename P, template <typename, typename> class Container, typename Allocator>
-inline void ParticleMessenger::SendParticles(
+inline void ParticleMessenger<ParticleType>::SendParticles(
   const std::unordered_map<int, Container<P, Allocator>>& m)
 {
   for (const auto& mit : m)
@@ -142,5 +146,6 @@ inline void ParticleMessenger::SendParticles(
 }
 } // namespace vtkm::filter::particleadvection
 
+#include <vtkm/filter/particleadvection/ParticleMessenger.cxx>
 
 #endif
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index 3b6def36f..51ef4acf3 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -11,6 +11,7 @@
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/ParticleAdvection.h>
+#include <vtkm/filter/ParticleAdvection2.h>
 #include <vtkm/filter/PathParticle.h>
 #include <vtkm/filter/Pathline.h>
 #include <vtkm/filter/Streamline.h>
@@ -63,7 +64,7 @@ void TestStreamline()
                                      vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
                                      vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
 
-    vtkm::filter::Streamline streamline;
+    vtkm::filter::ParticleAdvection2 streamline;
 
     streamline.SetStepSize(0.1f);
     streamline.SetNumberOfSteps(20);
@@ -76,8 +77,8 @@ void TestStreamline()
     VTKM_TEST_ASSERT(output.GetNumberOfCoordinateSystems() == 1,
                      "Wrong number of coordinate systems in the output dataset");
 
-    vtkm::cont::CoordinateSystem coords = output.GetCoordinateSystem();
-    VTKM_TEST_ASSERT(coords.GetNumberOfPoints() == 63, "Wrong number of coordinates");
+    //    vtkm::cont::CoordinateSystem coords = output.GetCoordinateSystem();
+    //    VTKM_TEST_ASSERT(coords.GetNumberOfPoints() == 63, "Wrong number of coordinates");
 
     vtkm::cont::UnknownCellSet dcells = output.GetCellSet();
     VTKM_TEST_ASSERT(dcells.GetNumberOfCells() == 3, "Wrong number of cells");
@@ -579,6 +580,11 @@ void TestStreamlineFile(const std::string& fname,
 
 void TestStreamlineFilters()
 {
+
+  vtkm::filter::ParticleAdvection2 filter;
+  TestStreamline();
+
+  /*
   std::vector<bool> flags = { true, false };
   std::vector<FilterType> fTypes = { FilterType::PARTICLE_ADVECTION,
                                      FilterType::STREAMLINE,
@@ -641,6 +647,7 @@ void TestStreamlineFilters()
 
   for (auto useSL : flags)
     TestStreamlineFile(amrWindFile, amrWindPts, amrWindStep, 10000, amrWindEndPts, useSL);
+*/
 }
 }
 

From 6618597711d859dddd0e4c3f2f940afd14d099b9 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 23 Jun 2022 15:25:31 -0400
Subject: [PATCH 002/104] Use types for different options in PA filters.

---
 vtkm/VecTraits.h                              |  41 ++-
 vtkm/cont/ArrayExtractComponent.h             |  38 +--
 vtkm/cont/ArrayHandle.h                       |  10 +-
 vtkm/cont/UnknownArrayHandle.h                |  27 +-
 vtkm/filter/FilterParticleAdvection.h         |   3 +-
 vtkm/filter/ParticleAdvection2.h              |  15 +
 vtkm/filter/ParticleAdvection2.hxx            |  37 ++-
 vtkm/filter/particleadvection/ABA.h           |  49 ++-
 vtkm/filter/particleadvection/DSI.h           |  59 +++-
 vtkm/filter/particleadvection/DSI.hxx         | 294 +++++++++++++++++-
 vtkm/filter/particleadvection/PAV.h           |  62 +++-
 .../ParticleAdvectionTypes.h                  |   3 +-
 .../testing/UnitTestStreamlineFilter.cxx      |   5 +-
 13 files changed, 557 insertions(+), 86 deletions(-)

diff --git a/vtkm/VecTraits.h b/vtkm/VecTraits.h
index 968836b47..1d6cb1c45 100644
--- a/vtkm/VecTraits.h
+++ b/vtkm/VecTraits.h
@@ -498,6 +498,7 @@ struct VTKM_NEVER_EXPORT VecTraits<vtkm::VecCConst<T>>
 
 namespace internal
 {
+
 /// Used for overriding VecTraits for basic scalar types.
 ///
 template <typename ScalarType>
@@ -539,6 +540,44 @@ struct VTKM_NEVER_EXPORT VecTraitsBasic
     dest[0] = src;
   }
 };
+
+namespace detail
+{
+
+template <typename T, typename = vtkm::HasVecTraits<T>>
+struct VTKM_NEVER_EXPORT SafeVecTraitsImpl;
+
+template <typename T>
+struct VTKM_NEVER_EXPORT SafeVecTraitsImpl<T, std::true_type> : vtkm::VecTraits<T>
+{
+};
+
+template <typename T>
+struct VTKM_NEVER_EXPORT SafeVecTraitsImpl<T, std::false_type> : vtkm::internal::VecTraitsBasic<T>
+{
+};
+
+} // namespace detail
+
+/// \brief A version of VecTraits that will be available for any type.
+///
+/// The `VecTraits` template is only defined for types that have a specific specialization
+/// for it. That means if you use `VecTraits` in a template, that template will likely
+/// fail to build for types that are not defined for `VecTraits`.
+///
+/// To use `VecTraits` in a class that should support all types, not just those with
+/// defined `VecTraits`, you can use this "safe" version. `SafeVecTraits` is the same as
+/// `VecTraits` if the latter is defined. If the `VecTraits` are not defined, then
+/// `SafeVecTraits` treats the type as a simple scalar value.
+///
+/// This template ensures that it will work reasonably well for all types. But be careful
+/// as if `VecTraits` is later defined, the template is likely to change.
+///
+template <typename T>
+struct VTKM_NEVER_EXPORT SafeVecTraits : detail::SafeVecTraitsImpl<T>
+{
+};
+
 } // namespace internal
 
 /// \brief VecTraits for Pair types
@@ -554,7 +593,7 @@ struct VTKM_NEVER_EXPORT VecTraits<vtkm::Pair<T, U>>
 {
 };
 
-} // anonymous namespace
+} // namespace vtkm
 
 #define VTKM_BASIC_TYPE_VECTOR(type)                                                     \
   namespace vtkm                                                                         \
diff --git a/vtkm/cont/ArrayExtractComponent.h b/vtkm/cont/ArrayExtractComponent.h
index 12dc1eeaa..4d412a51d 100644
--- a/vtkm/cont/ArrayExtractComponent.h
+++ b/vtkm/cont/ArrayExtractComponent.h
@@ -37,7 +37,7 @@ namespace internal
 // is defined rather than where it is resolved. This causes problems when extracting
 // components of, say, an ArrayHandleMultiplexer holding an ArrayHandleSOA.
 template <typename T, typename S>
-vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType>
+vtkm::cont::ArrayHandleStride<typename vtkm::internal::SafeVecTraits<T>::BaseComponentType>
 ArrayExtractComponentFallback(const vtkm::cont::ArrayHandle<T, S>& src,
                               vtkm::IdComponent componentIndex,
                               vtkm::CopyFlag allowCopy)
@@ -53,7 +53,7 @@ ArrayExtractComponentFallback(const vtkm::cont::ArrayHandle<T, S>& src,
                                      << vtkm::cont::TypeToString<vtkm::cont::ArrayHandle<T, S>>()
                                      << " requires an inefficient memory copy.");
 
-  using BaseComponentType = typename vtkm::VecTraits<T>::BaseComponentType;
+  using BaseComponentType = typename vtkm::internal::SafeVecTraits<T>::BaseComponentType;
   vtkm::Id numValues = src.GetNumberOfValues();
   vtkm::cont::ArrayHandleBasic<BaseComponentType> dest;
   dest.Allocate(numValues);
@@ -78,10 +78,10 @@ template <typename S>
 struct ArrayExtractComponentImpl : ArrayExtractComponentImplInefficient
 {
   template <typename T>
-  vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType> operator()(
-    const vtkm::cont::ArrayHandle<T, S>& src,
-    vtkm::IdComponent componentIndex,
-    vtkm::CopyFlag allowCopy) const
+  vtkm::cont::ArrayHandleStride<typename vtkm::internal::SafeVecTraits<T>::BaseComponentType>
+  operator()(const vtkm::cont::ArrayHandle<T, S>& src,
+             vtkm::IdComponent componentIndex,
+             vtkm::CopyFlag allowCopy) const
   {
     // This is the slow "default" implementation. ArrayHandle implementations should provide
     // more efficient overloads where applicable.
@@ -93,13 +93,15 @@ template <>
 struct ArrayExtractComponentImpl<vtkm::cont::StorageTagStride>
 {
   template <typename T>
-  vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType> operator()(
-    const vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagStride>& src,
-    vtkm::IdComponent componentIndex,
-    vtkm::CopyFlag allowCopy) const
+  vtkm::cont::ArrayHandleStride<typename vtkm::internal::SafeVecTraits<T>::BaseComponentType>
+  operator()(const vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagStride>& src,
+             vtkm::IdComponent componentIndex,
+             vtkm::CopyFlag allowCopy) const
   {
-    return this->DoExtract(
-      src, componentIndex, allowCopy, typename vtkm::VecTraits<T>::HasMultipleComponents{});
+    return this->DoExtract(src,
+                           componentIndex,
+                           allowCopy,
+                           typename vtkm::internal::SafeVecTraits<T>::HasMultipleComponents{});
   }
 
 private:
@@ -110,7 +112,7 @@ private:
                  vtkm::VecTraitsTagSingleComponent) const
   {
     VTKM_ASSERT(componentIndex == 0);
-    using VTraits = vtkm::VecTraits<T>;
+    using VTraits = vtkm::internal::SafeVecTraits<T>;
     using TBase = typename VTraits::BaseComponentType;
     VTKM_STATIC_ASSERT(VTraits::NUM_COMPONENTS == 1);
 
@@ -133,7 +135,7 @@ private:
                  vtkm::CopyFlag allowCopy,
                  vtkm::VecTraitsTagMultipleComponents) const
   {
-    using VTraits = vtkm::VecTraits<VecType>;
+    using VTraits = vtkm::internal::SafeVecTraits<VecType>;
     using T = typename VTraits::ComponentType;
     constexpr vtkm::IdComponent N = VTraits::NUM_COMPONENTS;
 
@@ -252,10 +254,10 @@ using ArrayExtractComponentIsInefficient = typename std::is_base_of<
 /// `vtkm::cont::internal::ArrayExtractComponentImpl`.
 ///
 template <typename T, typename S>
-vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType> ArrayExtractComponent(
-  const vtkm::cont::ArrayHandle<T, S>& src,
-  vtkm::IdComponent componentIndex,
-  vtkm::CopyFlag allowCopy = vtkm::CopyFlag::On)
+vtkm::cont::ArrayHandleStride<typename vtkm::internal::SafeVecTraits<T>::BaseComponentType>
+ArrayExtractComponent(const vtkm::cont::ArrayHandle<T, S>& src,
+                      vtkm::IdComponent componentIndex,
+                      vtkm::CopyFlag allowCopy = vtkm::CopyFlag::On)
 {
   return internal::ArrayExtractComponentImpl<S>{}(src, componentIndex, allowCopy);
 }
diff --git a/vtkm/cont/ArrayHandle.h b/vtkm/cont/ArrayHandle.h
index 8b5addedd..25dcea1c3 100644
--- a/vtkm/cont/ArrayHandle.h
+++ b/vtkm/cont/ArrayHandle.h
@@ -831,9 +831,9 @@ VTKM_NEVER_EXPORT VTKM_CONT inline void printSummary_ArrayHandle_Value(
   std::ostream& out,
   vtkm::VecTraitsTagMultipleComponents)
 {
-  using Traits = vtkm::VecTraits<T>;
+  using Traits = vtkm::internal::SafeVecTraits<T>;
   using ComponentType = typename Traits::ComponentType;
-  using IsVecOfVec = typename vtkm::VecTraits<ComponentType>::HasMultipleComponents;
+  using IsVecOfVec = typename vtkm::internal::SafeVecTraits<ComponentType>::HasMultipleComponents;
   vtkm::IdComponent numComponents = Traits::GetNumberOfComponents(value);
   out << "(";
   printSummary_ArrayHandle_Value(Traits::GetComponent(value, 0), out, IsVecOfVec());
@@ -853,10 +853,10 @@ VTKM_NEVER_EXPORT VTKM_CONT inline void printSummary_ArrayHandle_Value(
 {
   out << "{";
   printSummary_ArrayHandle_Value(
-    value.first, out, typename vtkm::VecTraits<T1>::HasMultipleComponents());
+    value.first, out, typename vtkm::internal::SafeVecTraits<T1>::HasMultipleComponents());
   out << ",";
   printSummary_ArrayHandle_Value(
-    value.second, out, typename vtkm::VecTraits<T2>::HasMultipleComponents());
+    value.second, out, typename vtkm::internal::SafeVecTraits<T2>::HasMultipleComponents());
   out << "}";
 }
 
@@ -872,7 +872,7 @@ VTKM_NEVER_EXPORT VTKM_CONT inline void printSummary_ArrayHandle(
 {
   using ArrayType = vtkm::cont::ArrayHandle<T, StorageT>;
   using PortalType = typename ArrayType::ReadPortalType;
-  using IsVec = typename vtkm::VecTraits<T>::HasMultipleComponents;
+  using IsVec = typename vtkm::internal::SafeVecTraits<T>::HasMultipleComponents;
 
   vtkm::Id sz = array.GetNumberOfValues();
 
diff --git a/vtkm/cont/UnknownArrayHandle.h b/vtkm/cont/UnknownArrayHandle.h
index 770d2bbf3..e7933af5a 100644
--- a/vtkm/cont/UnknownArrayHandle.h
+++ b/vtkm/cont/UnknownArrayHandle.h
@@ -55,12 +55,12 @@ vtkm::Id UnknownAHNumberOfValues(void* mem)
   return arrayHandle->GetNumberOfValues();
 }
 
-template <typename T, typename StaticSize = typename vtkm::VecTraits<T>::IsSizeStatic>
+template <typename T, typename StaticSize = typename vtkm::internal::SafeVecTraits<T>::IsSizeStatic>
 struct UnknownAHNumberOfComponentsImpl;
 template <typename T>
 struct UnknownAHNumberOfComponentsImpl<T, vtkm::VecTraitsTagSizeStatic>
 {
-  static constexpr vtkm::IdComponent Value = vtkm::VecTraits<T>::NUM_COMPONENTS;
+  static constexpr vtkm::IdComponent Value = vtkm::internal::SafeVecTraits<T>::NUM_COMPONENTS;
 };
 template <typename T>
 struct UnknownAHNumberOfComponentsImpl<T, vtkm::VecTraitsTagSizeVariable>
@@ -74,18 +74,25 @@ vtkm::IdComponent UnknownAHNumberOfComponents()
   return UnknownAHNumberOfComponentsImpl<T>::Value;
 }
 
-template <typename T, typename StaticSize = typename vtkm::VecTraits<T>::IsSizeStatic>
+template <typename T,
+          typename = typename vtkm::internal::SafeVecTraits<T>::IsSizeStatic,
+          typename = vtkm::HasVecTraits<T>>
 struct UnknownAHNumberOfComponentsFlatImpl;
 template <typename T>
-struct UnknownAHNumberOfComponentsFlatImpl<T, vtkm::VecTraitsTagSizeStatic>
+struct UnknownAHNumberOfComponentsFlatImpl<T, vtkm::VecTraitsTagSizeStatic, std::true_type>
 {
   static constexpr vtkm::IdComponent Value = vtkm::VecFlat<T>::NUM_COMPONENTS;
 };
 template <typename T>
-struct UnknownAHNumberOfComponentsFlatImpl<T, vtkm::VecTraitsTagSizeVariable>
+struct UnknownAHNumberOfComponentsFlatImpl<T, vtkm::VecTraitsTagSizeVariable, std::true_type>
 {
   static constexpr vtkm::IdComponent Value = 0;
 };
+template <typename T>
+struct UnknownAHNumberOfComponentsFlatImpl<T, vtkm::VecTraitsTagSizeStatic, std::false_type>
+{
+  static constexpr vtkm::IdComponent Value = 1;
+};
 
 template <typename T>
 vtkm::IdComponent UnknownAHNumberOfComponentsFlat()
@@ -306,13 +313,14 @@ std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceBasic(vtkm::VecTraitsTag
 template <typename T>
 std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceBasic()
 {
-  return UnknownAHNewInstanceBasic<T>(typename vtkm::VecTraits<T>::IsSizeStatic{});
+  return UnknownAHNewInstanceBasic<T>(typename vtkm::internal::SafeVecTraits<T>::IsSizeStatic{});
 }
 
 template <typename T>
 std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceFloatBasic(vtkm::VecTraitsTagSizeStatic)
 {
-  using FloatT = typename vtkm::VecTraits<T>::template ReplaceBaseComponentType<vtkm::FloatDefault>;
+  using FloatT = typename vtkm::internal::SafeVecTraits<T>::template ReplaceBaseComponentType<
+    vtkm::FloatDefault>;
   return UnknownAHContainer::Make(vtkm::cont::ArrayHandleBasic<FloatT>{});
 }
 template <typename T>
@@ -324,7 +332,8 @@ std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceFloatBasic(vtkm::VecTrai
 template <typename T>
 std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceFloatBasic()
 {
-  return UnknownAHNewInstanceFloatBasic<T>(typename vtkm::VecTraits<T>::IsSizeStatic{});
+  return UnknownAHNewInstanceFloatBasic<T>(
+    typename vtkm::internal::SafeVecTraits<T>::IsSizeStatic{});
 }
 
 template <typename T, typename S>
@@ -333,7 +342,7 @@ inline UnknownAHContainer::UnknownAHContainer(const vtkm::cont::ArrayHandle<T, S
   , ValueType(typeid(T))
   , StorageType(typeid(S))
   , BaseComponentType(
-      UnknownAHComponentInfo::Make<typename vtkm::VecTraits<T>::BaseComponentType>())
+      UnknownAHComponentInfo::Make<typename vtkm::internal::SafeVecTraits<T>::BaseComponentType>())
   , DeleteFunction(detail::UnknownAHDelete<T, S>)
   , NewInstance(detail::UnknownAHNewInstance<T, S>)
   , NewInstanceBasic(detail::UnknownAHNewInstanceBasic<T>)
diff --git a/vtkm/filter/FilterParticleAdvection.h b/vtkm/filter/FilterParticleAdvection.h
index 5abbc056c..126f9ff0a 100644
--- a/vtkm/filter/FilterParticleAdvection.h
+++ b/vtkm/filter/FilterParticleAdvection.h
@@ -90,7 +90,8 @@ protected:
   */
 
   vtkm::Id NumberOfSteps;
-  vtkm::filter::particleadvection::ParticleAdvectionResultType ResultType;
+  vtkm::filter::particleadvection::ParticleAdvectionResultType ResultType =
+    vtkm::filter::particleadvection::UNKNOWN_TYPE;
   vtkm::cont::ArrayHandle<ParticleType> Seeds;
   vtkm::filter::particleadvection::IntegrationSolverType SolverType;
   vtkm::FloatDefault StepSize;
diff --git a/vtkm/filter/ParticleAdvection2.h b/vtkm/filter/ParticleAdvection2.h
index a7e03aaea..ae4330dc7 100644
--- a/vtkm/filter/ParticleAdvection2.h
+++ b/vtkm/filter/ParticleAdvection2.h
@@ -13,6 +13,8 @@
 
 #include <vtkm/Particle.h>
 #include <vtkm/filter/FilterParticleAdvection.h>
+#include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
 {
@@ -38,6 +40,19 @@ public:
   vtkm::cont::UnknownArrayHandle SeedArray;
 };
 
+class ParticleAdvection3 : public vtkm::filter::NewFilterField
+{
+public:
+  //  VTKM_CONT ParticleAdvection3() {}
+
+protected:
+  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
+  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
+    const vtkm::cont::PartitionedDataSet& inData) override;
+
+  vtkm::cont::UnknownArrayHandle SeedArray;
+};
+
 }
 } // namespace vtkm::filter
 
diff --git a/vtkm/filter/ParticleAdvection2.hxx b/vtkm/filter/ParticleAdvection2.hxx
index 819693e64..df68e435b 100644
--- a/vtkm/filter/ParticleAdvection2.hxx
+++ b/vtkm/filter/ParticleAdvection2.hxx
@@ -29,6 +29,7 @@ namespace filter
 inline VTKM_CONT ParticleAdvection2::ParticleAdvection2()
   : vtkm::filter::FilterParticleAdvection<ParticleAdvection2, vtkm::Particle>()
 {
+  this->ResultType = vtkm::filter::particleadvection::PARTICLE_ADVECT_TYPE;
 }
 
 //-----------------------------------------------------------------------------
@@ -56,21 +57,17 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForEx
     if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
       throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-    dsi.push_back(DSIType(ds, blockId, activeField, this->SolverType, this->VecFieldType));
+    dsi.push_back(
+      DSIType(ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
   }
 
-  std::vector<vtkm::Particle> seeds;
-  seeds.push_back(this->Seeds.ReadPortal().Get(0));
-  seeds.push_back(this->Seeds.ReadPortal().Get(1));
-  seeds.push_back(this->Seeds.ReadPortal().Get(2));
-  std::cout << "SEEDS= " << seeds[0].Pos << " " << seeds[1].Pos << " " << seeds[2].Pos << std::endl;
-
-  //this->SeedArray = this->Seeds;
-  //vtkm::cont::UncertainArrayHandle<vtkm::List<vtkm::Particle>, vtkm::cont::StorageListBasic> arr;
-  //arr = this->Seeds;
-
-  vtkm::filter::particleadvection::PAV pav(boundsMap, dsi, this->UseThreadedAlgorithm);
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
+  this->SeedArray = this->Seeds;
+  vtkm::filter::particleadvection::PAV pav(
+    boundsMap,
+    dsi,
+    this->UseThreadedAlgorithm,
+    vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE);
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
 
 #if 0
   //std::vector<DSIType> ddsi;
@@ -97,6 +94,20 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForEx
 #endif
 }
 
+VTKM_CONT vtkm::cont::DataSet ParticleAdvection3::DoExecute(const vtkm::cont::DataSet& inData)
+{
+  std::cout << "Meow DS" << std::endl;
+  auto result = this->DoExecutePartitions(inData);
+  return result.GetPartition(0);
+}
+
+VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection3::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& inData)
+{
+  std::cout << "Meow pDS" << std::endl;
+  return inData;
+}
+
 }
 } // namespace vtkm::filter
 #endif
diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/ABA.h
index ad7a38176..5ce8b1ab2 100644
--- a/vtkm/filter/particleadvection/ABA.h
+++ b/vtkm/filter/particleadvection/ABA.h
@@ -48,8 +48,13 @@ public:
 
   vtkm::cont::PartitionedDataSet GetOutput()
   {
+    vtkm::cont::PartitionedDataSet output;
+
+    for (const auto& b : this->Blocks)
+      output.AppendPartition(b.GetOutput<ParticleType>());
+
     std::cout << "GetOutput: " << __FILE__ << " " << __LINE__ << std::endl;
-    auto output = internal::ResultHelper<ResultType, ParticleType>::GetOutput(this->Results);
+    //auto output = internal::ResultHelper<ResultType, ParticleType>::GetOutput(this->Results);
     output.PrintSummary(std::cout);
 
     return output;
@@ -100,15 +105,17 @@ public:
 
     while (this->TotalNumTerminatedParticles < this->TotalNumParticles)
     {
-      std::cout << __FILE__ << " " << __LINE__ << std::endl;
       std::vector<ParticleType> v;
       vtkm::Id numTerm = 0, blockId = -1;
-      if (GetActiveParticles(v, blockId))
+      if (this->GetActiveParticles(v, blockId))
       {
-        const auto& block = this->GetDataSet(blockId);
-        ResultType<ParticleType> r;
-        block.Advect(v, this->StepSize, this->NumberOfSteps, r);
-        numTerm = this->UpdateResult(r, blockId);
+        //make this a pointer to avoid the copy?
+        auto& block = this->GetDataSet(blockId);
+        //block.Advect(v, this->StepSize, this->NumberOfSteps, r);
+        DSIStuff<ParticleType> stuff(this->BoundsMap, this->ParticleBlockIDsMap);
+        block.Advect(v, this->StepSize, this->NumberOfSteps, stuff);
+        numTerm = this->UpdateResult(stuff);
+        //numTerm = this->UpdateResult(r, blockId);
         std::cout << " Advect: " << v.size() << " NT= " << numTerm << std::endl;
       }
 
@@ -138,9 +145,9 @@ public:
     this->TotalNumParticles = static_cast<vtkm::Id>(total);
   }
 
-  const DSI& GetDataSet(vtkm::Id id) const
+  DSI& GetDataSet(vtkm::Id id)
   {
-    for (const auto& it : this->Blocks)
+    for (auto& it : this->Blocks)
       if (it.GetID() == id)
         return it;
     throw vtkm::cont::ErrorFilterExecution("Bad block");
@@ -231,6 +238,7 @@ public:
       this->ParticleBlockIDsMap[it.first] = it.second;
   }
 
+  /*
   void UpdateTerminated(const vtkm::cont::ArrayHandle<ParticleType>& particles,
                         const std::vector<vtkm::Id>& idxTerm)
   {
@@ -238,7 +246,9 @@ public:
     for (const auto& idx : idxTerm)
       this->ParticleBlockIDsMap.erase(portal.Get(idx).ID);
   }
+  */
 
+  /*
   void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
                          std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMapA,
                          std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMapI,
@@ -319,10 +329,28 @@ public:
     //Make sure we didn't miss anything. Every particle goes into a single bucket.
     VTKM_ASSERT(static_cast<std::size_t>(n) == (A.size() + I.size() + termIdx.size()));
   }
+  */
 
+  vtkm::Id UpdateResult(const DSIStuff<ParticleType>& stuff)
+  {
+    this->UpdateActive(stuff.A, stuff.IdMapA);
+    this->UpdateInactive(stuff.I, stuff.IdMapI);
+
+    vtkm::Id numTerm = static_cast<vtkm::Id>(stuff.TermID.size());
+    //Update terminated particles.
+    if (numTerm > 0)
+    {
+      for (const auto& id : stuff.TermID)
+        this->ParticleBlockIDsMap.erase(id);
+    }
+
+    return numTerm;
+  }
+
+  /*
   vtkm::Id UpdateResult(ResultType<ParticleType>& res, vtkm::Id blockId)
   {
-    std::cout << "UpdateResult: blockId= " << blockId << std::endl;
+    std::cout<<"UpdateResult: blockId= "<<blockId<<std::endl;
     std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> idsMapI, idsMapA;
     std::vector<ParticleType> A, I;
     std::vector<vtkm::Id> termIdx;
@@ -340,6 +368,7 @@ public:
 
     return numTerm;
   }
+  */
 
   virtual bool GetBlockAndWait(const vtkm::Id& numLocalTerm)
   {
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index 21c9f1e8d..af359c4ba 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -19,6 +19,8 @@
 #include <vtkm/worklet/particleadvection/RK4Integrator.h>
 #include <vtkm/worklet/particleadvection/Stepper.h>
 
+#include <vtkm/exec/internal/Variant.h>
+
 namespace vtkm
 {
 namespace filter
@@ -26,6 +28,23 @@ namespace filter
 namespace particleadvection
 {
 
+template <typename ParticleType>
+struct DSIStuff
+{
+  DSIStuff(const vtkm::filter::particleadvection::BoundsMap& boundsMap,
+           const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& particleBlockIDsMap)
+    : BoundsMap(boundsMap)
+    , ParticleBlockIDsMap(particleBlockIDsMap)
+  {
+  }
+
+  std::vector<ParticleType> A, I;
+  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> IdMapA, IdMapI;
+  std::vector<vtkm::Id> TermID;
+  const vtkm::filter::particleadvection::BoundsMap BoundsMap;
+  const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
+};
+
 class DSI
 {
 public:
@@ -33,10 +52,13 @@ public:
       vtkm::Id id,
       const std::string& fieldNm,
       vtkm::filter::particleadvection::IntegrationSolverType solverType,
-      vtkm::filter::particleadvection::VectorFieldType vecFieldType)
+      vtkm::filter::particleadvection::VectorFieldType vecFieldType,
+      vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
+    : Rank(this->Comm.rank())
   {
     this->SolverType = solverType;
     this->VecFieldType = vecFieldType;
+    this->ResType = resultType;
     this->DataSet = ds;
     this->Id = id;
     this->FieldName = fieldNm;
@@ -47,12 +69,19 @@ public:
   VTKM_CONT vtkm::Id GetID() const { return this->Id; }
   VTKM_CONT void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
 
-  //template <typename ParticleType, typename ResultType>
-  template <typename ParticleType, template <typename> class ResultType>
+
+  template <typename ParticleType>
   VTKM_CONT void Advect(std::vector<ParticleType>& v,
                         vtkm::FloatDefault stepSize, //move these to member data(?)
                         vtkm::Id maxSteps,
-                        ResultType<ParticleType>& result) const;
+                        DSIStuff<ParticleType>& stuff);
+
+  template <typename ParticleType>
+  VTKM_CONT vtkm::cont::DataSet GetOutput() const;
+
+protected:
+  template <typename ParticleType, template <typename> class ResultType>
+  VTKM_CONT void UpdateResult(ResultType<ParticleType>& result, DSIStuff<ParticleType>& stuff);
 
   template <typename ArrayType>
   VTKM_CONT void GetVelocityField(
@@ -69,6 +98,7 @@ public:
   VTKM_CONT void GetElectroMagneticField(
     vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& elecMagField) const
   {
+    std::cout << "FIX ME: need fieldname2" << std::endl;
     ArrayType arr1, arr2;
     vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(), arr1);
     vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(),
@@ -79,14 +109,31 @@ public:
       vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>(arr1, arr2, assoc);
   }
 
-  //private:
+  template <typename ParticleType>
+  VTKM_CONT void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
+                                   DSIStuff<ParticleType>& stuff) const;
+
+  template <typename ParticleType, template <typename> class ResultType>
+  VTKM_CONT vtkm::cont::DataSet ResultToDataSet() const;
+
+  vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
+  vtkm::Id Rank;
   vtkm::cont::DataSet DataSet;
   vtkm::Id Id;
   std::string FieldName;
   vtkm::filter::particleadvection::IntegrationSolverType SolverType;
   vtkm::filter::particleadvection::VectorFieldType VecFieldType;
+  vtkm::filter::particleadvection::ParticleAdvectionResultType ResType =
+    vtkm::filter::particleadvection::UNKNOWN_TYPE;
   bool CopySeedArray = false;
-  //Add results array?
+
+  using ResultVariantType =
+    vtkm::exec::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
+                                  vtkm::worklet::StreamlineResult<vtkm::Particle>,
+                                  vtkm::worklet::ParticleAdvectionResult<vtkm::ChargedParticle>,
+                                  vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
+
+  std::vector<ResultVariantType> Results;
 };
 
 }
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index 717578e26..6bcb7c3c3 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -17,12 +17,264 @@ namespace filter
 {
 namespace particleadvection
 {
+#if 0
+namespace internal
+{
+//Helper class to store the different result types.
+//template <typename ResultType>
+template <template <typename> class ResultType, typename ParticleType>
+class ResultHelper2;
+
+template <typename ParticleType>
+class ResultHelper2<vtkm::worklet::ParticleAdvectionResult, ParticleType>
+{
+  using PAType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+
+public:
+  static void Store(const PAType& result)
+  {
+  }
+
+  static vtkm::cont::DataSet
+  GetOutput()
+  {
+    vtkm::cont::DataSet ds;
+
+    return ds;
+  }
+};
+
+template <typename ParticleType>
+class ResultHelper2<vtkm::worklet::StreamlineResult, ParticleType>
+{
+  using PAType = vtkm::worklet::StreamlineResult<ParticleType>;
+
+public:
+  static void Store(const PAType& result)
+  {
+  }
+
+  static vtkm::cont::DataSet
+  GetOutput()
+  {
+    vtkm::cont::DataSet ds;
+
+    return ds;
+  }
+};
+
+}
+#endif
+
+template <typename ParticleType>
+VTKM_CONT vtkm::cont::DataSet DSI::GetOutput() const
+{
+  vtkm::cont::DataSet ds;
+
+  std::size_t nResults = this->Results.size();
+  if (nResults == 0)
+    return ds;
+
+  std::cout << "Check the variant type!" << std::endl;
+
+  if (this->ResType == PARTICLE_ADVECT_TYPE)
+  {
+    using RType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+
+    std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
+    allParticles.reserve(nResults);
+
+    //Get all the particles and put them into a single ArrayHandle: pts
+    for (const auto& vres : this->Results)
+      allParticles.push_back(vres.Get<RType>().Particles);
+
+    vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
+    vtkm::cont::ParticleArrayCopy(allParticles, pts);
+
+    vtkm::Id numPoints = pts.GetNumberOfValues();
+    if (numPoints > 0)
+    {
+      //Create coordinate system and vertex cell set.
+      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", pts));
+
+      vtkm::cont::CellSetSingleType<> cells;
+      vtkm::cont::ArrayHandleIndex conn(numPoints);
+      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
+
+      vtkm::cont::ArrayCopy(conn, connectivity);
+      cells.Fill(numPoints, vtkm::CELL_SHAPE_VERTEX, 1, connectivity);
+      ds.SetCellSet(cells);
+    }
+  }
+  else if (this->ResType == STREAMLINE_TYPE)
+  {
+    using ResultType = vtkm::worklet::StreamlineResult<ParticleType>;
+
+    //Easy case with one result.
+    if (nResults == 1)
+    {
+      const auto& res = this->Results[0].Get<ResultType>();
+      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", res.Positions));
+      ds.SetCellSet(res.PolyLines);
+    }
+    else
+    {
+      std::vector<vtkm::Id> posOffsets(nResults, 0);
+      vtkm::Id totalNumCells = 0, totalNumPts = 0;
+      for (std::size_t i = 0; i < nResults; i++)
+      {
+        const auto& res = this->Results[i].Get<ResultType>();
+        if (i == 0)
+          posOffsets[i] = 0;
+        else
+          posOffsets[i] = totalNumPts;
+
+        totalNumPts += res.Positions.GetNumberOfValues();
+        totalNumCells += res.PolyLines.GetNumberOfCells();
+      }
+
+      //Append all the points together.
+      vtkm::cont::ArrayHandle<vtkm::Vec3f> appendPts;
+      appendPts.Allocate(totalNumPts);
+      for (std::size_t i = 0; i < nResults; i++)
+      {
+        const auto& res = this->Results[i].Get<ResultType>();
+        // copy all values into appendPts starting at offset.
+        vtkm::cont::Algorithm::CopySubRange(
+          res.Positions, 0, res.Positions.GetNumberOfValues(), appendPts, posOffsets[i]);
+      }
+      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", appendPts));
+
+      //Create polylines.
+      std::vector<vtkm::Id> numPtsPerCell(static_cast<std::size_t>(totalNumCells));
+      std::size_t off = 0;
+      for (std::size_t i = 0; i < nResults; i++)
+      {
+        const auto& res = this->Results[i].Get<ResultType>();
+        vtkm::Id nCells = res.PolyLines.GetNumberOfCells();
+        for (vtkm::Id j = 0; j < nCells; j++)
+          numPtsPerCell[off++] = static_cast<vtkm::Id>(res.PolyLines.GetNumberOfPointsInCell(j));
+      }
+
+      auto numPointsPerCellArray = vtkm::cont::make_ArrayHandle(numPtsPerCell, vtkm::CopyFlag::Off);
+
+      vtkm::cont::ArrayHandle<vtkm::Id> cellIndex;
+      vtkm::Id connectivityLen =
+        vtkm::cont::Algorithm::ScanExclusive(numPointsPerCellArray, cellIndex);
+      vtkm::cont::ArrayHandleIndex connCount(connectivityLen);
+      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
+      vtkm::cont::ArrayCopy(connCount, connectivity);
+
+      vtkm::cont::ArrayHandle<vtkm::UInt8> cellTypes;
+      auto polyLineShape = vtkm::cont::make_ArrayHandleConstant<vtkm::UInt8>(
+        vtkm::CELL_SHAPE_POLY_LINE, totalNumCells);
+      vtkm::cont::ArrayCopy(polyLineShape, cellTypes);
+      auto offsets = vtkm::cont::ConvertNumComponentsToOffsets(numPointsPerCellArray);
+
+      vtkm::cont::CellSetExplicit<> polyLines;
+      polyLines.Fill(totalNumPts, cellTypes, connectivity, offsets);
+      ds.SetCellSet(polyLines);
+    }
+  }
+  else
+  {
+    throw vtkm::cont::ErrorFilterExecution("Unsupported ParticleAdvectionResultType");
+  }
+
+  return ds;
+}
 
 template <typename ParticleType, template <typename> class ResultType>
+VTKM_CONT void DSI::UpdateResult(ResultType<ParticleType>& result, DSIStuff<ParticleType>& stuff)
+{
+  this->ClassifyParticles(result.Particles, stuff);
+  this->Results.push_back(result);
+}
+
+template <typename ParticleType>
+VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
+                                      DSIStuff<ParticleType>& stuff) const
+{
+  stuff.A.clear();
+  stuff.I.clear();
+  stuff.TermID.clear();
+  stuff.IdMapI.clear();
+  stuff.IdMapA.clear();
+
+  auto portal = particles.WritePortal();
+  vtkm::Id n = portal.GetNumberOfValues();
+
+  for (vtkm::Id i = 0; i < n; i++)
+  {
+    auto p = portal.Get(i);
+
+    if (p.Status.CheckTerminate())
+      stuff.TermID.push_back(p.ID);
+    else
+    {
+      const auto& it = stuff.ParticleBlockIDsMap.find(p.ID);
+      VTKM_ASSERT(it != stuff.ParticleBlockIDsMap.end());
+      auto currBIDs = it->second;
+      VTKM_ASSERT(!currBIDs.empty());
+
+      std::vector<vtkm::Id> newIDs;
+      if (p.Status.CheckSpatialBounds() && !p.Status.CheckTookAnySteps())
+        newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
+      else
+        newIDs = stuff.BoundsMap.FindBlocks(p.Pos, currBIDs);
+
+      //reset the particle status.
+      p.Status = vtkm::ParticleStatus();
+
+      if (newIDs.empty()) //No blocks, we're done.
+      {
+        p.Status.SetTerminate();
+        stuff.TermID.push_back(p.ID);
+      }
+      else
+      {
+        //If we have more than blockId, we want to minimize communication
+        //and put any blocks owned by this rank first.
+        if (newIDs.size() > 1)
+        {
+          for (auto idit = newIDs.begin(); idit != newIDs.end(); idit++)
+          {
+            vtkm::Id bid = *idit;
+            if (stuff.BoundsMap.FindRank(bid) == this->Rank)
+            {
+              newIDs.erase(idit);
+              newIDs.insert(newIDs.begin(), bid);
+              break;
+            }
+          }
+        }
+
+        int dstRank = stuff.BoundsMap.FindRank(newIDs[0]);
+        if (dstRank == this->Rank)
+        {
+          stuff.A.push_back(p);
+          stuff.IdMapA[p.ID] = newIDs;
+        }
+        else
+        {
+          stuff.I.push_back(p);
+          stuff.IdMapI[p.ID] = newIDs;
+        }
+      }
+      portal.Set(i, p);
+    }
+  }
+
+  //Make sure we didn't miss anything. Every particle goes into a single bucket.
+  VTKM_ASSERT(static_cast<std::size_t>(n) ==
+              (stuff.A.size() + stuff.I.size() + stuff.TermID.size()));
+}
+
+template <typename ParticleType>
 VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
                            vtkm::FloatDefault stepSize,
                            vtkm::Id maxSteps,
-                           ResultType<ParticleType>& result) const
+                           DSIStuff<ParticleType>& stuff)
 {
   //using Association = vtkm::cont::Field::Association;
   using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
@@ -46,9 +298,22 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
 
       GridEvType eval(this->DataSet, velField);
       StepperType stepper(eval, stepSize);
-      vtkm::worklet::ParticleAdvection Worklet;
-      result = Worklet.Run(stepper, seedArray, maxSteps);
-      //Put results in unknown array??
+
+      //make this a template
+      if (this->ResType == PARTICLE_ADVECT_TYPE)
+      {
+        vtkm::worklet::ParticleAdvection Worklet;
+        auto r = Worklet.Run(stepper, seedArray, maxSteps);
+        this->UpdateResult(r, stuff);
+        // /*result =*/ Worklet.Run(stepper, seedArray, maxSteps);
+      }
+      else
+      {
+        vtkm::worklet::Streamline Worklet;
+        auto r = Worklet.Run(stepper, seedArray, maxSteps);
+        this->UpdateResult(r, stuff);
+        //Put results in unknown array??
+      }
     }
     else if (this->VecFieldType == ELECTRO_MAGNETIC_FIELD_TYPE) //vtkm::ChargedParticle
     {
@@ -62,8 +327,21 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
 
       GridEvType eval(this->DataSet, velField);
       StepperType stepper(eval, stepSize);
-      vtkm::worklet::ParticleAdvection Worklet;
-      result = Worklet.Run(stepper, seedArray, maxSteps);
+
+      if (this->ResType == PARTICLE_ADVECT_TYPE)
+      {
+        vtkm::worklet::ParticleAdvection Worklet;
+        auto r = Worklet.Run(stepper, seedArray, maxSteps);
+        this->UpdateResult(r, stuff);
+        ///*result =*/ auto r = Worklet.Run(stepper, seedArray, maxSteps);
+      }
+      else
+      {
+        vtkm::worklet::Streamline Worklet;
+        auto r = Worklet.Run(stepper, seedArray, maxSteps);
+        this->UpdateResult(r, stuff);
+        ///*result =*/ Worklet.Run(stepper, seedArray, maxSteps);
+      }
     }
   }
 
@@ -81,8 +359,8 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
 
       GridEvType eval(this->DataSet, velField);
       StepperType stepper(eval, stepSize);
-      vtkm::worklet::ParticleAdvection Worklet;
-      result = Worklet.Run(stepper, seedArray, maxSteps);
+      //      vtkm::worklet::ParticleAdvection Worklet;
+      //      result = Worklet.Run(stepper, seedArray, maxSteps);
       //Put results in unknown array??
     }
   }
diff --git a/vtkm/filter/particleadvection/PAV.h b/vtkm/filter/particleadvection/PAV.h
index d8f05e36b..820223c8c 100644
--- a/vtkm/filter/particleadvection/PAV.h
+++ b/vtkm/filter/particleadvection/PAV.h
@@ -27,38 +27,78 @@ class PAV
 public:
   PAV(const vtkm::filter::particleadvection::BoundsMap& bm,
       const std::vector<DSI>& blocks,
-      const bool& useThreaded)
+      const bool& useThreaded,
+      const vtkm::filter::particleadvection::ParticleAdvectionResultType& parType)
     : Blocks(blocks)
     , BoundsMap(bm)
+    , ResultType(parType)
     , UseThreadedAlgorithm(useThreaded)
   {
   }
 
   vtkm::cont::PartitionedDataSet Execute(vtkm::Id numSteps,
                                          vtkm::FloatDefault stepSize,
-                                         const vtkm::cont::ArrayHandle<vtkm::Particle>& seeds)
+                                         const vtkm::cont::UnknownArrayHandle& seeds)
+  {
+    using ParticleArray = vtkm::cont::ArrayHandle<vtkm::Particle>;
+    using ChargedParticleArray = vtkm::cont::ArrayHandle<vtkm::ChargedParticle>;
+
+    if (seeds.IsBaseComponentType<vtkm::Particle>())
+      return this->Execute(numSteps, stepSize, seeds.AsArrayHandle<ParticleArray>());
+    else if (seeds.IsBaseComponentType<vtkm::ChargedParticle>())
+      return this->Execute(numSteps, stepSize, seeds.AsArrayHandle<ChargedParticleArray>());
+
+    throw vtkm::cont::ErrorFilterExecution("Unsupported options in ABA");
+  }
+
+private:
+  template <typename ParticleType>
+  vtkm::cont::PartitionedDataSet Execute(vtkm::Id numSteps,
+                                         vtkm::FloatDefault stepSize,
+                                         const vtkm::cont::ArrayHandle<ParticleType>& seeds)
   {
     if (!this->UseThreadedAlgorithm)
     {
+      //make a templated algorithm execution()
+      if (this->ResultType ==
+          vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+      {
+        using AlgorithmType =
+          vtkm::filter::particleadvection::ABA<vtkm::worklet::ParticleAdvectionResult,
+                                               ParticleType>;
+
+        AlgorithmType algo(this->BoundsMap, this->Blocks);
+        algo.Execute(numSteps, stepSize, seeds);
+        return algo.GetOutput();
+      }
+      else
+      {
+        using AlgorithmType =
+          vtkm::filter::particleadvection::ABA<vtkm::worklet::StreamlineResult, ParticleType>;
+
+        AlgorithmType algo(this->BoundsMap, this->Blocks);
+        algo.Execute(numSteps, stepSize, seeds);
+        return algo.GetOutput();
+      }
+    }
+    else
+    {
+      std::cout << "Change me to threaded ABA" << std::endl;
       using AlgorithmType =
-        vtkm::filter::particleadvection::ABA<vtkm::worklet::ParticleAdvectionResult,
-                                             vtkm::Particle>;
+        vtkm::filter::particleadvection::ABA<vtkm::worklet::ParticleAdvectionResult, ParticleType>;
 
       AlgorithmType algo(this->BoundsMap, this->Blocks);
       algo.Execute(numSteps, stepSize, seeds);
       return algo.GetOutput();
     }
-    else
-    {
-      //using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
-      //AlgorithmType algo;
-    }
-
-    throw vtkm::cont::ErrorFilterExecution("Unsupported options in ABA");
   }
 
+
+
+
   std::vector<DSI> Blocks;
   vtkm::filter::particleadvection::BoundsMap BoundsMap;
+  ParticleAdvectionResultType ResultType;
   bool UseThreadedAlgorithm;
 };
 
diff --git a/vtkm/filter/particleadvection/ParticleAdvectionTypes.h b/vtkm/filter/particleadvection/ParticleAdvectionTypes.h
index 9851c5020..7d11ebbfa 100644
--- a/vtkm/filter/particleadvection/ParticleAdvectionTypes.h
+++ b/vtkm/filter/particleadvection/ParticleAdvectionTypes.h
@@ -30,7 +30,8 @@ enum VectorFieldType
 
 enum ParticleAdvectionResultType
 {
-  PARTICLE_ADVECT_TYPE = 0,
+  UNKNOWN_TYPE = -1,
+  PARTICLE_ADVECT_TYPE,
   STREAMLINE_TYPE,
 };
 
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index 51ef4acf3..4e2e968e6 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -65,7 +65,6 @@ void TestStreamline()
                                      vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
 
     vtkm::filter::ParticleAdvection2 streamline;
-
     streamline.SetStepSize(0.1f);
     streamline.SetNumberOfSteps(20);
     streamline.SetSeeds(seedArray);
@@ -584,7 +583,7 @@ void TestStreamlineFilters()
   vtkm::filter::ParticleAdvection2 filter;
   TestStreamline();
 
-  /*
+
   std::vector<bool> flags = { true, false };
   std::vector<FilterType> fTypes = { FilterType::PARTICLE_ADVECTION,
                                      FilterType::STREAMLINE,
@@ -601,7 +600,7 @@ void TestStreamlineFilters()
 
   TestStreamline();
   TestPathline();
-
+  /*
   for (auto useSL : flags)
     TestAMRStreamline(useSL);
 

From ab1cd81a62659dd033bd0198073246637792ce30 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 23 Jun 2022 15:55:09 -0400
Subject: [PATCH 003/104] Fix templated class member specialization issue.

---
 vtkm/filter/particleadvection/ABA.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/ABA.h
index 5ce8b1ab2..a71854e4e 100644
--- a/vtkm/filter/particleadvection/ABA.h
+++ b/vtkm/filter/particleadvection/ABA.h
@@ -51,7 +51,7 @@ public:
     vtkm::cont::PartitionedDataSet output;
 
     for (const auto& b : this->Blocks)
-      output.AppendPartition(b.GetOutput<ParticleType>());
+      output.AppendPartition(b.template GetOutput<ParticleType>());
 
     std::cout << "GetOutput: " << __FILE__ << " " << __LINE__ << std::endl;
     //auto output = internal::ResultHelper<ResultType, ParticleType>::GetOutput(this->Results);

From 35d7b926748e63d24c12d95c6059ce5794709b41 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 23 Jun 2022 16:13:17 -0400
Subject: [PATCH 004/104] ParticleMessenger needs a template param.

---
 vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx b/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx
index dca664c08..c390b7705 100644
--- a/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx
+++ b/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx
@@ -23,7 +23,7 @@ using MCommType = std::pair<int, std::vector<int>>;
 using PCommType = std::pair<vtkm::Particle, std::vector<vtkm::Id>>;
 using PRecvCommType = std::pair<int, std::vector<PCommType>>;
 
-class TestMessenger : public vtkm::filter::particleadvection::ParticleMessenger
+class TestMessenger : public vtkm::filter::particleadvection::ParticleMessenger<vtkm::Particle>
 {
 public:
   TestMessenger(vtkmdiy::mpi::communicator& comm,

From c7f11ae5bc42ac2e2477414de4a95921dd2286c9 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 29 Jun 2022 09:38:24 -0400
Subject: [PATCH 005/104] Fixes for PA and SL filters.

---
 vtkm/cont/ArrayHandle.h                       |   5 +-
 vtkm/filter/CMakeLists.txt                    |   2 +
 vtkm/filter/ParticleAdvection2.h              |   3 +-
 vtkm/filter/ParticleAdvection2.hxx            |   6 +-
 vtkm/filter/Streamline2.h                     |  61 ++++++++
 vtkm/filter/Streamline2.hxx                   | 110 +++++++++++++++
 vtkm/filter/particleadvection/ABA.h           |  30 ++--
 vtkm/filter/particleadvection/DSI.h           |  29 ++--
 vtkm/filter/particleadvection/DSI.hxx         | 133 +++++++++++++++---
 vtkm/filter/particleadvection/PAV.h           |  13 +-
 .../testing/UnitTestStreamlineFilter.cxx      |  52 ++++---
 vtkm/worklet/ParticleAdvection.h              |  45 ++++++
 12 files changed, 422 insertions(+), 67 deletions(-)
 create mode 100644 vtkm/filter/Streamline2.h
 create mode 100644 vtkm/filter/Streamline2.hxx

diff --git a/vtkm/cont/ArrayHandle.h b/vtkm/cont/ArrayHandle.h
index 25dcea1c3..adc476ae4 100644
--- a/vtkm/cont/ArrayHandle.h
+++ b/vtkm/cont/ArrayHandle.h
@@ -371,7 +371,10 @@ public:
   /// with CUDA), then the automatically generated destructor could be
   /// created for all devices, and it would not be valid for all devices.
   ///
-  VTKM_CONT ~ArrayHandle() {}
+  VTKM_CONT ~ArrayHandle()
+  {
+    //    std::cout<<"ArrayHandle dtor: "<<(void*)this<<std::endl;
+  }
 
   /// \brief Copies an ArrayHandle
   ///
diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index 356356bbf..4e40d6477 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -109,6 +109,7 @@ set(extra_headers
   Pathline.h
   PathParticle.h
   Streamline.h
+  Streamline2.h
   StreamSurface.h
   )
 
@@ -125,6 +126,7 @@ set(extra_header_template_sources
   Pathline.hxx
   PathParticle.hxx
   Streamline.hxx
+  Streamline2.hxx
   StreamSurface.hxx
   )
 
diff --git a/vtkm/filter/ParticleAdvection2.h b/vtkm/filter/ParticleAdvection2.h
index ae4330dc7..6fad92ed9 100644
--- a/vtkm/filter/ParticleAdvection2.h
+++ b/vtkm/filter/ParticleAdvection2.h
@@ -36,7 +36,6 @@ public:
     const vtkm::cont::PartitionedDataSet& input,
     const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
 
-
   vtkm::cont::UnknownArrayHandle SeedArray;
 };
 
@@ -60,4 +59,4 @@ protected:
 #include <vtkm/filter/ParticleAdvection2.hxx>
 #endif
 
-#endif // vtk_m_filter_ParticleAdvection_h
+#endif // vtk_m_filter_ParticleAdvection2_h
diff --git a/vtkm/filter/ParticleAdvection2.hxx b/vtkm/filter/ParticleAdvection2.hxx
index df68e435b..e5600343e 100644
--- a/vtkm/filter/ParticleAdvection2.hxx
+++ b/vtkm/filter/ParticleAdvection2.hxx
@@ -49,7 +49,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForEx
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   std::string activeField = this->GetActiveFieldName();
 
-  std::vector<DSIType> dsi;
+  std::vector<DSIType*> dsi;
   for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
   {
     vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
@@ -57,8 +57,8 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForEx
     if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
       throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-    dsi.push_back(
-      DSIType(ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
+    dsi.push_back(new DSIType(
+      ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
   }
 
   this->SeedArray = this->Seeds;
diff --git a/vtkm/filter/Streamline2.h b/vtkm/filter/Streamline2.h
new file mode 100644
index 000000000..f369753bc
--- /dev/null
+++ b/vtkm/filter/Streamline2.h
@@ -0,0 +1,61 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_Streamline2_h
+#define vtk_m_filter_Streamline2_h
+
+#include <vtkm/Particle.h>
+#include <vtkm/filter/FilterParticleAdvection.h>
+#include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+
+namespace vtkm
+{
+namespace filter
+{
+/// \brief Advect particles in a vector field.
+
+/// Takes as input a vector field and seed locations and generates the
+/// end points for each seed through the vector field.
+
+class Streamline2 : public vtkm::filter::FilterParticleAdvection<Streamline2, vtkm::Particle>
+{
+public:
+  VTKM_CONT Streamline2();
+
+  template <typename DerivedPolicy>
+  vtkm::cont::PartitionedDataSet PrepareForExecution(
+    const vtkm::cont::PartitionedDataSet& input,
+    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
+
+  vtkm::cont::UnknownArrayHandle SeedArray;
+};
+
+class Streamline3 : public vtkm::filter::NewFilterField
+{
+public:
+  //  VTKM_CONT Streamline3() {}
+
+protected:
+  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
+  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
+    const vtkm::cont::PartitionedDataSet& inData) override;
+
+  vtkm::cont::UnknownArrayHandle SeedArray;
+};
+
+}
+} // namespace vtkm::filter
+
+#ifndef vtk_m_filter_Streamline2_hxx
+#include <vtkm/filter/Streamline2.hxx>
+#endif
+
+#endif // vtk_m_filter_Streamline2_h
diff --git a/vtkm/filter/Streamline2.hxx b/vtkm/filter/Streamline2.hxx
new file mode 100644
index 000000000..001b20e7b
--- /dev/null
+++ b/vtkm/filter/Streamline2.hxx
@@ -0,0 +1,110 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+#ifndef vtk_m_filter_Streamline2_hxx
+#define vtk_m_filter_Streamline2_hxx
+
+#include <vtkm/cont/ErrorFilterExecution.h>
+#include <vtkm/filter/Streamline2.h>
+#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
+
+#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+
+namespace vtkm
+{
+namespace filter
+{
+
+//-----------------------------------------------------------------------------
+inline VTKM_CONT Streamline2::Streamline2()
+  : vtkm::filter::FilterParticleAdvection<Streamline2, vtkm::Particle>()
+{
+  this->ResultType = vtkm::filter::particleadvection::STREAMLINE_TYPE;
+}
+
+//-----------------------------------------------------------------------------
+template <typename DerivedPolicy>
+inline VTKM_CONT vtkm::cont::PartitionedDataSet Streamline2::PrepareForExecution(
+  const vtkm::cont::PartitionedDataSet& input,
+  const vtkm::filter::PolicyBase<DerivedPolicy>&)
+{
+  //  using AlgorithmType = vtkm::filter::particleadvection::StreamlineAlgorithm;
+  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::StreamlineThreadedAlgorithm;
+  using DSIType = vtkm::filter::particleadvection::DSI;
+
+  this->ValidateOptions();
+  //Make sure everything matches up ok.
+  this->VecFieldType = vtkm::filter::particleadvection::VELOCITY_FIELD_TYPE;
+
+  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
+  std::string activeField = this->GetActiveFieldName();
+
+  std::vector<DSIType*> dsi;
+  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
+  {
+    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
+    auto ds = input.GetPartition(i);
+    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
+      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
+
+    dsi.push_back(new DSIType(
+      ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
+  }
+
+  this->SeedArray = this->Seeds;
+  vtkm::filter::particleadvection::PAV pav(
+    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
+
+#if 0
+  //std::vector<DSIType> ddsi;
+  /*
+  vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
+    boundsMap, ddsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  */
+
+  vtkm::cont::PartitionedDataSet output;
+  return output;
+
+  /*
+  //using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
+  //std::vector<DSIType> dsi;
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
+
+  if (this->GetUseThreadedAlgorithm())
+    return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
+      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  else
+    return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
+      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  */
+#endif
+}
+
+VTKM_CONT vtkm::cont::DataSet Streamline3::DoExecute(const vtkm::cont::DataSet& inData)
+{
+  std::cout << "Meow DS" << std::endl;
+  auto result = this->DoExecutePartitions(inData);
+  return result.GetPartition(0);
+}
+
+VTKM_CONT vtkm::cont::PartitionedDataSet Streamline3::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& inData)
+{
+  std::cout << "Meow pDS" << std::endl;
+  return inData;
+}
+
+}
+} // namespace vtkm::filter
+#endif
diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/ABA.h
index a71854e4e..839b98a13 100644
--- a/vtkm/filter/particleadvection/ABA.h
+++ b/vtkm/filter/particleadvection/ABA.h
@@ -28,7 +28,7 @@ template <template <typename> class ResultType, typename ParticleType>
 class ABA
 {
 public:
-  ABA(const vtkm::filter::particleadvection::BoundsMap& bm, const std::vector<DSI>& blocks)
+  ABA(const vtkm::filter::particleadvection::BoundsMap& bm, std::vector<DSI*>& blocks)
     : Blocks(blocks)
     , BoundsMap(bm)
     , NumRanks(this->Comm.size())
@@ -36,6 +36,8 @@ public:
   {
   }
 
+  void Meow(const char* func, const int& lineNum) const { this->Blocks[0]->Meow(func, lineNum); }
+
   void Execute(vtkm::Id numSteps,
                vtkm::FloatDefault stepSize,
                const vtkm::cont::ArrayHandle<ParticleType>& seeds)
@@ -51,11 +53,14 @@ public:
     vtkm::cont::PartitionedDataSet output;
 
     for (const auto& b : this->Blocks)
-      output.AppendPartition(b.template GetOutput<ParticleType>());
+    {
+      vtkm::cont::DataSet ds;
+      if (b->template GetOutput<ParticleType>(ds))
+        output.AppendPartition(ds);
+    }
 
-    std::cout << "GetOutput: " << __FILE__ << " " << __LINE__ << std::endl;
-    //auto output = internal::ResultHelper<ResultType, ParticleType>::GetOutput(this->Results);
-    output.PrintSummary(std::cout);
+    //std::cout<<"GetOutput: "<<__FILE__<<" "<<__LINE__<<std::endl;
+    //output.PrintSummary(std::cout);
 
     return output;
   }
@@ -110,12 +115,10 @@ public:
       if (this->GetActiveParticles(v, blockId))
       {
         //make this a pointer to avoid the copy?
-        auto& block = this->GetDataSet(blockId);
-        //block.Advect(v, this->StepSize, this->NumberOfSteps, r);
+        auto block = this->GetDataSet(blockId);
         DSIStuff<ParticleType> stuff(this->BoundsMap, this->ParticleBlockIDsMap);
-        block.Advect(v, this->StepSize, this->NumberOfSteps, stuff);
+        block->Advect(v, this->StepSize, this->NumberOfSteps, stuff);
         numTerm = this->UpdateResult(stuff);
-        //numTerm = this->UpdateResult(r, blockId);
         std::cout << " Advect: " << v.size() << " NT= " << numTerm << std::endl;
       }
 
@@ -128,6 +131,7 @@ public:
     }
   }
 
+
   virtual void ClearParticles()
   {
     this->Active.clear();
@@ -145,11 +149,12 @@ public:
     this->TotalNumParticles = static_cast<vtkm::Id>(total);
   }
 
-  DSI& GetDataSet(vtkm::Id id)
+  DSI* GetDataSet(vtkm::Id id)
   {
     for (auto& it : this->Blocks)
-      if (it.GetID() == id)
+      if (it->GetID() == id)
         return it;
+
     throw vtkm::cont::ErrorFilterExecution("Bad block");
   }
 
@@ -388,7 +393,7 @@ public:
 
   //Member data
   std::vector<ParticleType> Active;
-  std::vector<DSI> Blocks;
+  std::vector<DSI*> Blocks;
   vtkm::filter::particleadvection::BoundsMap BoundsMap;
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
   std::vector<ParticleType> Inactive;
@@ -406,5 +411,6 @@ public:
 }
 }
 
+//#include <vtkm/filter/particleadvection/ABA.hxx>
 
 #endif //vtk_m_filter_ABA_h
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index af359c4ba..697ca28dd 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -19,7 +19,9 @@
 #include <vtkm/worklet/particleadvection/RK4Integrator.h>
 #include <vtkm/worklet/particleadvection/Stepper.h>
 
-#include <vtkm/exec/internal/Variant.h>
+#include <vtkm/cont/internal/Variant.h>
+
+#include <variant>
 
 namespace vtkm
 {
@@ -40,7 +42,7 @@ struct DSIStuff
 
   std::vector<ParticleType> A, I;
   std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> IdMapA, IdMapI;
-  std::vector<vtkm::Id> TermID;
+  std::vector<vtkm::Id> TermIdx, TermID;
   const vtkm::filter::particleadvection::BoundsMap BoundsMap;
   const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
 };
@@ -77,11 +79,13 @@ public:
                         DSIStuff<ParticleType>& stuff);
 
   template <typename ParticleType>
-  VTKM_CONT vtkm::cont::DataSet GetOutput() const;
+  VTKM_CONT bool GetOutput(vtkm::cont::DataSet& ds) const;
+
+  //protected:
 
-protected:
   template <typename ParticleType, template <typename> class ResultType>
-  VTKM_CONT void UpdateResult(ResultType<ParticleType>& result, DSIStuff<ParticleType>& stuff);
+  VTKM_CONT void UpdateResult(const ResultType<ParticleType>& result,
+                              DSIStuff<ParticleType>& stuff);
 
   template <typename ArrayType>
   VTKM_CONT void GetVelocityField(
@@ -109,6 +113,9 @@ protected:
       vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>(arr1, arr2, assoc);
   }
 
+  //template <typename ParticleType>
+  void Meow(const char* func, const int& lineNum) const;
+
   template <typename ParticleType>
   VTKM_CONT void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
                                    DSIStuff<ParticleType>& stuff) const;
@@ -127,13 +134,13 @@ protected:
     vtkm::filter::particleadvection::UNKNOWN_TYPE;
   bool CopySeedArray = false;
 
-  using ResultVariantType =
-    vtkm::exec::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
-                                  vtkm::worklet::StreamlineResult<vtkm::Particle>,
-                                  vtkm::worklet::ParticleAdvectionResult<vtkm::ChargedParticle>,
-                                  vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
 
-  std::vector<ResultVariantType> Results;
+  using ResultType =
+    vtkm::cont::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
+                                  vtkm::worklet::ParticleAdvectionResult<vtkm::ChargedParticle>,
+                                  vtkm::worklet::StreamlineResult<vtkm::Particle>,
+                                  vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
+  std::vector<ResultType> Results;
 };
 
 }
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index 6bcb7c3c3..c86295968 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -66,14 +66,46 @@ public:
 }
 #endif
 
-template <typename ParticleType>
-VTKM_CONT vtkm::cont::DataSet DSI::GetOutput() const
+//template <typename ParticleType>
+void
+//DSI<ParticleType>::Meow() const
+DSI::Meow(const char* func, const int& lineNum) const
 {
-  vtkm::cont::DataSet ds;
+  if (this->Results.empty())
+  {
+    //std::cout<<"   no results!"<<std::endl;
+    return;
+  }
 
+  std::cout << " ******************************";
+  std::cout << func << " " << lineNum << " ";
+  using RType = vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>;
+
+  //const auto& R0 = this->Results[0]->Get<RType>();
+  //const auto& P0 = R0.Particles.ReadPortal().Get(0);
+  //RType* r = static_cast<RType*>(this->Results[0]);
+  //const auto& P0 = r->Particles.ReadPortal().Get(0);
+  const auto& P0 = this->Results[0].Get<RType>().Particles.ReadPortal().Get(0);
+  std::cout << "   PT0=  " << P0.Pos << std::endl;
+
+  //std::cout<<"   PT0=  "<<P0.Pos<<std::endl;
+
+  /*
+  auto& R0 = this->Results[0].Get<RType>();
+  auto P0 = R0.Particles.ReadPortal().Get(0);
+  std::cout<<"   PT0=  "<<P0.Pos<<std::endl;
+  auto ppp = R0.Particles;
+  std::cout<<"   ptrs: RP= "<<(void*)&(R0)<<" pPtr= "<<(void*)&ppp<<std::endl;
+  */
+}
+
+template <typename ParticleType>
+VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
+{
   std::size_t nResults = this->Results.size();
   if (nResults == 0)
-    return ds;
+    return false;
+
 
   std::cout << "Check the variant type!" << std::endl;
 
@@ -83,13 +115,13 @@ VTKM_CONT vtkm::cont::DataSet DSI::GetOutput() const
 
     std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
     allParticles.reserve(nResults);
-
-    //Get all the particles and put them into a single ArrayHandle: pts
     for (const auto& vres : this->Results)
       allParticles.push_back(vres.Get<RType>().Particles);
 
     vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
     vtkm::cont::ParticleArrayCopy(allParticles, pts);
+    std::cout << "DSI::GetOutput() pts= ";
+    vtkm::cont::printSummary_ArrayHandle(pts, std::cout);
 
     vtkm::Id numPoints = pts.GetNumberOfValues();
     if (numPoints > 0)
@@ -108,12 +140,12 @@ VTKM_CONT vtkm::cont::DataSet DSI::GetOutput() const
   }
   else if (this->ResType == STREAMLINE_TYPE)
   {
-    using ResultType = vtkm::worklet::StreamlineResult<ParticleType>;
+    using RType = vtkm::worklet::StreamlineResult<ParticleType>;
 
     //Easy case with one result.
     if (nResults == 1)
     {
-      const auto& res = this->Results[0].Get<ResultType>();
+      const auto& res = this->Results[0].Get<RType>();
       ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", res.Positions));
       ds.SetCellSet(res.PolyLines);
     }
@@ -123,7 +155,7 @@ VTKM_CONT vtkm::cont::DataSet DSI::GetOutput() const
       vtkm::Id totalNumCells = 0, totalNumPts = 0;
       for (std::size_t i = 0; i < nResults; i++)
       {
-        const auto& res = this->Results[i].Get<ResultType>();
+        const auto& res = this->Results[i].Get<RType>();
         if (i == 0)
           posOffsets[i] = 0;
         else
@@ -138,7 +170,7 @@ VTKM_CONT vtkm::cont::DataSet DSI::GetOutput() const
       appendPts.Allocate(totalNumPts);
       for (std::size_t i = 0; i < nResults; i++)
       {
-        const auto& res = this->Results[i].Get<ResultType>();
+        const auto& res = this->Results[i].Get<RType>();
         // copy all values into appendPts starting at offset.
         vtkm::cont::Algorithm::CopySubRange(
           res.Positions, 0, res.Positions.GetNumberOfValues(), appendPts, posOffsets[i]);
@@ -150,7 +182,7 @@ VTKM_CONT vtkm::cont::DataSet DSI::GetOutput() const
       std::size_t off = 0;
       for (std::size_t i = 0; i < nResults; i++)
       {
-        const auto& res = this->Results[i].Get<ResultType>();
+        const auto& res = this->Results[i].Get<RType>();
         vtkm::Id nCells = res.PolyLines.GetNumberOfCells();
         for (vtkm::Id j = 0; j < nCells; j++)
           numPtsPerCell[off++] = static_cast<vtkm::Id>(res.PolyLines.GetNumberOfPointsInCell(j));
@@ -181,14 +213,73 @@ VTKM_CONT vtkm::cont::DataSet DSI::GetOutput() const
     throw vtkm::cont::ErrorFilterExecution("Unsupported ParticleAdvectionResultType");
   }
 
-  return ds;
+  return true;
 }
 
+namespace internal
+{
+using ResultVariantType =
+  vtkm::cont::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
+                                vtkm::worklet::ParticleAdvectionResult<vtkm::ChargedParticle>,
+                                vtkm::worklet::StreamlineResult<vtkm::Particle>,
+                                vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
+
+template <template <typename> class ResultType, typename ParticleType>
+class ResultHelper
+{
+public:
+  static void Store(const vtkm::worklet::ParticleAdvectionResult<ParticleType>& res,
+                    std::vector<ResultVariantType>& results)
+  {
+    results.push_back(res);
+  }
+};
+
+
+/*
+template <typename ParticleType>
+class ResultHelper<vtkm::worklet::ParticleAdvectionResult, ParticleType>
+{
+public:
+  static void Store(const vtkm::worklet::ParticleAdvectionResult<ParticleType>>& res,
+                    std::vector<ResultVariantType>& results)
+  {
+    results.push_back(res);
+  }
+};
+  */
+};
+
 template <typename ParticleType, template <typename> class ResultType>
-VTKM_CONT void DSI::UpdateResult(ResultType<ParticleType>& result, DSIStuff<ParticleType>& stuff)
+VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
+                                 DSIStuff<ParticleType>& stuff)
 {
   this->ClassifyParticles(result.Particles, stuff);
-  this->Results.push_back(result);
+
+  //this->Meow(__PRETTY_FUNCTION__, __LINE__);
+
+  //template this for PA and SL
+  if (this->ResType == vtkm::filter::particleadvection::PARTICLE_ADVECT_TYPE)
+  {
+    if (stuff.TermIdx.empty())
+      return;
+
+    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+    auto indicesAH = vtkm::cont::make_ArrayHandle(stuff.TermIdx, vtkm::CopyFlag::Off);
+    auto termPerm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, result.Particles);
+
+    vtkm::cont::ArrayHandle<ParticleType> termParticles;
+    vtkm::cont::Algorithm::Copy(termPerm, termParticles);
+
+    ResType termRes(termParticles);
+    this->Results.push_back(termRes);
+  }
+  else if (this->ResType == vtkm::filter::particleadvection::STREAMLINE_TYPE)
+  {
+    this->Results.push_back(result);
+  }
+
+  //this->Meow(__PRETTY_FUNCTION__, __LINE__);
 }
 
 template <typename ParticleType>
@@ -198,6 +289,7 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
   stuff.A.clear();
   stuff.I.clear();
   stuff.TermID.clear();
+  stuff.TermIdx.clear();
   stuff.IdMapI.clear();
   stuff.IdMapA.clear();
 
@@ -207,9 +299,13 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
   for (vtkm::Id i = 0; i < n; i++)
   {
     auto p = portal.Get(i);
+    std::cout << "****** ClassifyParticles: " << p.Pos << " ID= " << p.ID << std::endl;
 
     if (p.Status.CheckTerminate())
+    {
+      stuff.TermIdx.push_back(i);
       stuff.TermID.push_back(p.ID);
+    }
     else
     {
       const auto& it = stuff.ParticleBlockIDsMap.find(p.ID);
@@ -229,6 +325,7 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
       if (newIDs.empty()) //No blocks, we're done.
       {
         p.Status.SetTerminate();
+        stuff.TermIdx.push_back(i);
         stuff.TermID.push_back(p.ID);
       }
       else
@@ -267,7 +364,8 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
 
   //Make sure we didn't miss anything. Every particle goes into a single bucket.
   VTKM_ASSERT(static_cast<std::size_t>(n) ==
-              (stuff.A.size() + stuff.I.size() + stuff.TermID.size()));
+              (stuff.A.size() + stuff.I.size() + stuff.TermIdx.size()));
+  VTKM_ASSERT(stuff.TermIdx.size() == stuff.TermID.size());
 }
 
 template <typename ParticleType>
@@ -303,9 +401,8 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
       if (this->ResType == PARTICLE_ADVECT_TYPE)
       {
         vtkm::worklet::ParticleAdvection Worklet;
-        auto r = Worklet.Run(stepper, seedArray, maxSteps);
-        this->UpdateResult(r, stuff);
-        // /*result =*/ Worklet.Run(stepper, seedArray, maxSteps);
+        auto result = Worklet.Run(stepper, seedArray, maxSteps);
+        this->UpdateResult(result, stuff);
       }
       else
       {
diff --git a/vtkm/filter/particleadvection/PAV.h b/vtkm/filter/particleadvection/PAV.h
index 820223c8c..38d16867a 100644
--- a/vtkm/filter/particleadvection/PAV.h
+++ b/vtkm/filter/particleadvection/PAV.h
@@ -26,7 +26,7 @@ class PAV
 {
 public:
   PAV(const vtkm::filter::particleadvection::BoundsMap& bm,
-      const std::vector<DSI>& blocks,
+      const std::vector<DSI*> blocks,
       const bool& useThreaded,
       const vtkm::filter::particleadvection::ParticleAdvectionResultType& parType)
     : Blocks(blocks)
@@ -69,6 +69,13 @@ private:
 
         AlgorithmType algo(this->BoundsMap, this->Blocks);
         algo.Execute(numSteps, stepSize, seeds);
+        algo.Meow(__PRETTY_FUNCTION__, __LINE__);
+
+        //std::cout<<__FILE__<<" "<<__LINE__<<std::endl;
+        //using RType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+        //auto p0 = this->Blocks[0].Results[0].Get<RType>().Particles.ReadPortal().Get(0);
+        //std::cout<<__FILE__<<" "<<__LINE__<<" pt= "<<p0.Pos<<std::endl;
+
         return algo.GetOutput();
       }
       else
@@ -94,9 +101,7 @@ private:
   }
 
 
-
-
-  std::vector<DSI> Blocks;
+  std::vector<DSI*> Blocks;
   vtkm::filter::particleadvection::BoundsMap BoundsMap;
   ParticleAdvectionResultType ResultType;
   bool UseThreadedAlgorithm;
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index 4e2e968e6..30537dcc4 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -15,7 +15,9 @@
 #include <vtkm/filter/PathParticle.h>
 #include <vtkm/filter/Pathline.h>
 #include <vtkm/filter/Streamline.h>
+#include <vtkm/filter/Streamline2.h>
 #include <vtkm/io/VTKDataSetReader.h>
+#include <vtkm/io/VTKDataSetWriter.h>
 #include <vtkm/worklet/testing/GenerateTestDataSets.h>
 
 namespace
@@ -64,7 +66,8 @@ void TestStreamline()
                                      vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
                                      vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
 
-    vtkm::filter::ParticleAdvection2 streamline;
+    vtkm::filter::Streamline streamline;
+
     streamline.SetStepSize(0.1f);
     streamline.SetNumberOfSteps(20);
     streamline.SetSeeds(seedArray);
@@ -76,8 +79,8 @@ void TestStreamline()
     VTKM_TEST_ASSERT(output.GetNumberOfCoordinateSystems() == 1,
                      "Wrong number of coordinate systems in the output dataset");
 
-    //    vtkm::cont::CoordinateSystem coords = output.GetCoordinateSystem();
-    //    VTKM_TEST_ASSERT(coords.GetNumberOfPoints() == 63, "Wrong number of coordinates");
+    vtkm::cont::CoordinateSystem coords = output.GetCoordinateSystem();
+    VTKM_TEST_ASSERT(coords.GetNumberOfPoints() == 63, "Wrong number of coordinates");
 
     vtkm::cont::UnknownCellSet dcells = output.GetCellSet();
     VTKM_TEST_ASSERT(dcells.GetNumberOfCells() == 3, "Wrong number of cells");
@@ -293,7 +296,7 @@ void TestAMRStreamline(bool useSL)
     }
     else
     {
-      vtkm::filter::ParticleAdvection filter;
+      vtkm::filter::ParticleAdvection2 filter;
       filter.SetStepSize(0.1f);
       filter.SetNumberOfSteps(100000);
       filter.SetSeeds(seedArray);
@@ -370,12 +373,24 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
                                                vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1) });
     vtkm::Id numSeeds = seedArray.GetNumberOfValues();
 
+    if (idx == 0)
+    {
+      for (int j = 0; j < pds.GetNumberOfPartitions(); j++)
+      {
+        auto ds_j = pds.GetPartition(j);
+        std::string nm = "ds_" + std::to_string(j) + ".vtk";
+        vtkm::io::VTKDataSetWriter wrt(nm);
+        wrt.WriteDataSet(ds_j);
+      }
+    }
+
+
     if (fType == FilterType::STREAMLINE || fType == FilterType::PATHLINE)
     {
       vtkm::cont::PartitionedDataSet out;
       if (fType == FilterType::STREAMLINE)
       {
-        vtkm::filter::Streamline streamline;
+        vtkm::filter::Streamline2 streamline;
         streamline.SetStepSize(0.1f);
         streamline.SetNumberOfSteps(100000);
         streamline.SetSeeds(seedArray);
@@ -400,6 +415,9 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
         out = pathline.Execute(pds);
       }
 
+      //std::cout<<"Num IN DS= "<<pds.GetNumberOfPartitions()<<std::endl;
+      //out.PrintSummary(std::cout);
+
       for (vtkm::Id i = 0; i < num; i++)
       {
         auto outputDS = out.GetPartition(i);
@@ -439,7 +457,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
       vtkm::cont::PartitionedDataSet out;
       if (fType == FilterType::PARTICLE_ADVECTION)
       {
-        vtkm::filter::ParticleAdvection particleAdvection;
+        vtkm::filter::ParticleAdvection2 particleAdvection;
 
         particleAdvection.SetStepSize(0.1f);
         particleAdvection.SetNumberOfSteps(100000);
@@ -465,6 +483,12 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
         out = pathParticle.Execute(pds);
       }
 
+
+      std::cout << "*************************************************************" << std::endl;
+      std::cout << "*************************************************************" << std::endl;
+      std::cout << "*************************************************************" << std::endl;
+      std::cout << "DS.NumP()= " << out.GetNumberOfPartitions()
+                << " pds.NumP()= " << pds.GetNumberOfPartitions() << std::endl;
       VTKM_TEST_ASSERT(out.GetNumberOfPartitions() == 1, "Wrong number of partitions in output");
       auto ds = out.GetPartition(0);
       //Validate the result is correct.
@@ -551,7 +575,7 @@ void TestStreamlineFile(const std::string& fname,
   }
   else
   {
-    vtkm::filter::ParticleAdvection particleAdvection;
+    vtkm::filter::ParticleAdvection2 particleAdvection;
     particleAdvection.SetStepSize(stepSize);
     particleAdvection.SetNumberOfSteps(maxSteps);
     particleAdvection.SetSeeds(seedArray);
@@ -579,28 +603,25 @@ void TestStreamlineFile(const std::string& fname,
 
 void TestStreamlineFilters()
 {
-
-  vtkm::filter::ParticleAdvection2 filter;
-  TestStreamline();
-
-
   std::vector<bool> flags = { true, false };
   std::vector<FilterType> fTypes = { FilterType::PARTICLE_ADVECTION,
                                      FilterType::STREAMLINE,
                                      FilterType::PATHLINE,
                                      FilterType::PATH_PARTICLE };
+
+  fTypes = { FilterType::PARTICLE_ADVECTION, FilterType::STREAMLINE };
   for (int n = 1; n < 3; n++)
   {
     for (auto useGhost : flags)
       for (auto ft : fTypes)
-      {
         TestPartitionedDataSet(n, useGhost, ft);
-      }
   }
 
+  return;
+
   TestStreamline();
   TestPathline();
-  /*
+
   for (auto useSL : flags)
     TestAMRStreamline(useSL);
 
@@ -646,7 +667,6 @@ void TestStreamlineFilters()
 
   for (auto useSL : flags)
     TestStreamlineFile(amrWindFile, amrWindPts, amrWindStep, 10000, amrWindEndPts, useSL);
-*/
 }
 }
 
diff --git a/vtkm/worklet/ParticleAdvection.h b/vtkm/worklet/ParticleAdvection.h
index 66e3dee86..1cd2397aa 100644
--- a/vtkm/worklet/ParticleAdvection.h
+++ b/vtkm/worklet/ParticleAdvection.h
@@ -55,13 +55,45 @@ struct ParticleAdvectionResult
   ParticleAdvectionResult()
     : Particles()
   {
+    std::cout << "PAR ctor0  ptr= " << (void*)this << " pPtr= " << (void*)&(this->Particles)
+              << std::endl;
   }
 
   ParticleAdvectionResult(const vtkm::cont::ArrayHandle<ParticleType>& p)
     : Particles(p)
   {
+    std::cout << "PAR ctor1  ptr= " << (void*)this << " pPtr= " << (void*)&(this->Particles)
+              << std::endl;
   }
 
+  /*
+  ParticleAdvectionResult(const vtkm::worklet::ParticleAdvectionResult<ParticleType>& pr)
+    : Particles(pr.Particles)
+  {
+    std::cout<<"PAR ctor2  ptr= "<<(void*)this<<" pPtr= "<<(void*)&(this->Particles)<<std::endl;
+  }
+
+
+  ~ParticleAdvectionResult()
+  {
+    std::cout<<"**** Tossing a PAResult= "<<(void*)this<<" pPtr= "<<(void*)(&this->Particles)<<std::endl;
+  }
+
+  vtkm::worklet::ParticleAdvectionResult<ParticleType>&
+  operator=(const vtkm::worklet::ParticleAdvectionResult<ParticleType>& src)
+  {
+    this->Particles = src.Particles;
+    return *this;
+  }
+
+  vtkm::worklet::ParticleAdvectionResult<ParticleType>&
+  operator=(const vtkm::worklet::ParticleAdvectionResult<ParticleType>&& src)
+  {
+    this->Particles = src.Particles;
+    return *this;
+  }
+  */
+
   vtkm::cont::ArrayHandle<ParticleType> Particles;
 };
 
@@ -70,6 +102,19 @@ class ParticleAdvection
 public:
   ParticleAdvection() {}
 
+  template <typename IntegratorType, typename ParticleType, typename ParticleStorage>
+  void Run2(const IntegratorType& it,
+            vtkm::cont::ArrayHandle<ParticleType, ParticleStorage>& particles,
+            vtkm::Id MaxSteps,
+            ParticleAdvectionResult<ParticleType>& result)
+  {
+    vtkm::worklet::particleadvection::ParticleAdvectionWorklet<IntegratorType, ParticleType>
+      worklet;
+
+    worklet.Run(it, particles, MaxSteps);
+    result = ParticleAdvectionResult<ParticleType>(particles);
+  }
+
   template <typename IntegratorType, typename ParticleType, typename ParticleStorage>
   ParticleAdvectionResult<ParticleType> Run(
     const IntegratorType& it,

From 6e097a5eb3401303efa05308094cbf0f37358c10 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 29 Jun 2022 09:51:07 -0400
Subject: [PATCH 006/104] remove std::variant include

---
 vtkm/filter/CMakeLists.txt                    |   2 +
 vtkm/filter/Pathline2.h                       |  61 ++++++++++
 vtkm/filter/Pathline2.hxx                     | 110 ++++++++++++++++++
 vtkm/filter/particleadvection/DSI.h           |   2 -
 .../testing/UnitTestStreamlineFilter.cxx      |   7 +-
 5 files changed, 177 insertions(+), 5 deletions(-)
 create mode 100644 vtkm/filter/Pathline2.h
 create mode 100644 vtkm/filter/Pathline2.hxx

diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index 4e40d6477..14d24bb46 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -107,6 +107,7 @@ set(extra_headers
   ParticleAdvection.h
   ParticleAdvection2.h
   Pathline.h
+  Pathline2.h
   PathParticle.h
   Streamline.h
   Streamline2.h
@@ -124,6 +125,7 @@ set(extra_header_template_sources
   ParticleAdvection.hxx
   ParticleAdvection2.hxx
   Pathline.hxx
+  Pathline2.hxx
   PathParticle.hxx
   Streamline.hxx
   Streamline2.hxx
diff --git a/vtkm/filter/Pathline2.h b/vtkm/filter/Pathline2.h
new file mode 100644
index 000000000..3aff0f46b
--- /dev/null
+++ b/vtkm/filter/Pathline2.h
@@ -0,0 +1,61 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_Pathline2_h
+#define vtk_m_filter_Pathline2_h
+
+#include <vtkm/Particle.h>
+#include <vtkm/filter/FilterParticleAdvection.h>
+#include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+
+namespace vtkm
+{
+namespace filter
+{
+/// \brief Advect particles in a vector field.
+
+/// Takes as input a vector field and seed locations and generates the
+/// end points for each seed through the vector field.
+
+class Pathline2 : public vtkm::filter::FilterTemporalParticleAdvection<Pathline2, vtkm::Particle>
+{
+public:
+  VTKM_CONT Pathline2();
+
+  template <typename DerivedPolicy>
+  vtkm::cont::PartitionedDataSet PrepareForExecution(
+    const vtkm::cont::PartitionedDataSet& input,
+    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
+
+  vtkm::cont::UnknownArrayHandle SeedArray;
+};
+
+class Pathline3 : public vtkm::filter::NewFilterField
+{
+public:
+  //  VTKM_CONT Pathline3() {}
+
+protected:
+  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
+  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
+    const vtkm::cont::PartitionedDataSet& inData) override;
+
+  vtkm::cont::UnknownArrayHandle SeedArray;
+};
+
+}
+} // namespace vtkm::filter
+
+#ifndef vtk_m_filter_Pathline2_hxx
+#include <vtkm/filter/Pathline2.hxx>
+#endif
+
+#endif // vtk_m_filter_Pathline2_h
diff --git a/vtkm/filter/Pathline2.hxx b/vtkm/filter/Pathline2.hxx
new file mode 100644
index 000000000..61c418f80
--- /dev/null
+++ b/vtkm/filter/Pathline2.hxx
@@ -0,0 +1,110 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+#ifndef vtk_m_filter_Pathline2_hxx
+#define vtk_m_filter_Pathline2_hxx
+
+#include <vtkm/cont/ErrorFilterExecution.h>
+#include <vtkm/filter/Pathline2.h>
+#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
+
+#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+
+namespace vtkm
+{
+namespace filter
+{
+
+//-----------------------------------------------------------------------------
+inline VTKM_CONT Pathline2::Pathline2()
+  : vtkm::filter::FilterTemporalParticleAdvection<Pathline2, vtkm::Particle>()
+{
+  this->ResultType = vtkm::filter::particleadvection::PARTICLE_ADVECT_TYPE;
+}
+
+//-----------------------------------------------------------------------------
+template <typename DerivedPolicy>
+inline VTKM_CONT vtkm::cont::PartitionedDataSet Pathline2::PrepareForExecution(
+  const vtkm::cont::PartitionedDataSet& input,
+  const vtkm::filter::PolicyBase<DerivedPolicy>&)
+{
+  //  using AlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionAlgorithm;
+  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
+  using DSIType = vtkm::filter::particleadvection::DSI;
+
+  this->ValidateOptions();
+  //Make sure everything matches up ok.
+  this->VecFieldType = vtkm::filter::particleadvection::VELOCITY_FIELD_TYPE;
+
+  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
+  std::string activeField = this->GetActiveFieldName();
+
+  std::vector<DSIType*> dsi;
+  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
+  {
+    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
+    auto ds = input.GetPartition(i);
+    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
+      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
+
+    dsi.push_back(new DSIType(
+      ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
+  }
+
+  this->SeedArray = this->Seeds;
+  vtkm::filter::particleadvection::PAV pav(
+    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
+
+#if 0
+  //std::vector<DSIType> ddsi;
+  /*
+  vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
+    boundsMap, ddsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  */
+
+  vtkm::cont::PartitionedDataSet output;
+  return output;
+
+  /*
+  //using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
+  //std::vector<DSIType> dsi;
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
+
+  if (this->GetUseThreadedAlgorithm())
+    return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
+      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  else
+    return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
+      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  */
+#endif
+}
+
+VTKM_CONT vtkm::cont::DataSet Pathline3::DoExecute(const vtkm::cont::DataSet& inData)
+{
+  std::cout << "Meow DS" << std::endl;
+  auto result = this->DoExecutePartitions(inData);
+  return result.GetPartition(0);
+}
+
+VTKM_CONT vtkm::cont::PartitionedDataSet Pathline3::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& inData)
+{
+  std::cout << "Meow pDS" << std::endl;
+  return inData;
+}
+
+}
+} // namespace vtkm::filter
+#endif
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index 697ca28dd..8fdf1c137 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -21,8 +21,6 @@
 
 #include <vtkm/cont/internal/Variant.h>
 
-#include <variant>
-
 namespace vtkm
 {
 namespace filter
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index 30537dcc4..05bb71a00 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -14,6 +14,7 @@
 #include <vtkm/filter/ParticleAdvection2.h>
 #include <vtkm/filter/PathParticle.h>
 #include <vtkm/filter/Pathline.h>
+#include <vtkm/filter/Pathline2.h>
 #include <vtkm/filter/Streamline.h>
 #include <vtkm/filter/Streamline2.h>
 #include <vtkm/io/VTKDataSetReader.h>
@@ -403,7 +404,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
         auto pds2 = allPDs2[idx];
         AddVectorFields(pds2, fieldName, vecX);
 
-        vtkm::filter::Pathline pathline;
+        vtkm::filter::Pathline2 pathline;
         pathline.SetPreviousTime(0);
         pathline.SetNextTime(1000);
         pathline.SetNextDataSet(pds2);
@@ -415,8 +416,8 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
         out = pathline.Execute(pds);
       }
 
-      //std::cout<<"Num IN DS= "<<pds.GetNumberOfPartitions()<<std::endl;
-      //out.PrintSummary(std::cout);
+      std::cout << "Num IN DS= " << pds.GetNumberOfPartitions() << std::endl;
+      out.PrintSummary(std::cout);
 
       for (vtkm::Id i = 0; i < num; i++)
       {

From c40356bc8ac3f02ca2b0e550451a91fe32dafa66 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 29 Jun 2022 10:02:42 -0400
Subject: [PATCH 007/104] Add pathparticle2 filter

---
 vtkm/filter/CMakeLists.txt                    |   2 +
 vtkm/filter/PathParticle2.h                   |  62 ++++++++++
 vtkm/filter/PathParticle2.hxx                 | 110 ++++++++++++++++++
 vtkm/filter/Pathline2.hxx                     |   2 +-
 .../testing/UnitTestStreamlineFilter.cxx      |   6 +-
 5 files changed, 179 insertions(+), 3 deletions(-)
 create mode 100644 vtkm/filter/PathParticle2.h
 create mode 100644 vtkm/filter/PathParticle2.hxx

diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index 14d24bb46..abeb07f3d 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -109,6 +109,7 @@ set(extra_headers
   Pathline.h
   Pathline2.h
   PathParticle.h
+  PathParticle2.h
   Streamline.h
   Streamline2.h
   StreamSurface.h
@@ -127,6 +128,7 @@ set(extra_header_template_sources
   Pathline.hxx
   Pathline2.hxx
   PathParticle.hxx
+  PathParticle2.hxx
   Streamline.hxx
   Streamline2.hxx
   StreamSurface.hxx
diff --git a/vtkm/filter/PathParticle2.h b/vtkm/filter/PathParticle2.h
new file mode 100644
index 000000000..c9d8020de
--- /dev/null
+++ b/vtkm/filter/PathParticle2.h
@@ -0,0 +1,62 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_PathParticle2_h
+#define vtk_m_filter_PathParticle2_h
+
+#include <vtkm/Particle.h>
+#include <vtkm/filter/FilterParticleAdvection.h>
+#include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+
+namespace vtkm
+{
+namespace filter
+{
+/// \brief Advect particles in a vector field.
+
+/// Takes as input a vector field and seed locations and generates the
+/// end points for each seed through the vector field.
+
+class PathParticle2
+  : public vtkm::filter::FilterTemporalParticleAdvection<PathParticle2, vtkm::Particle>
+{
+public:
+  VTKM_CONT PathParticle2();
+
+  template <typename DerivedPolicy>
+  vtkm::cont::PartitionedDataSet PrepareForExecution(
+    const vtkm::cont::PartitionedDataSet& input,
+    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
+
+  vtkm::cont::UnknownArrayHandle SeedArray;
+};
+
+class PathParticle3 : public vtkm::filter::NewFilterField
+{
+public:
+  //  VTKM_CONT PathParticle3() {}
+
+protected:
+  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
+  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
+    const vtkm::cont::PartitionedDataSet& inData) override;
+
+  vtkm::cont::UnknownArrayHandle SeedArray;
+};
+
+}
+} // namespace vtkm::filter
+
+#ifndef vtk_m_filter_PathParticle2_hxx
+#include <vtkm/filter/PathParticle2.hxx>
+#endif
+
+#endif // vtk_m_filter_PathParticle2_h
diff --git a/vtkm/filter/PathParticle2.hxx b/vtkm/filter/PathParticle2.hxx
new file mode 100644
index 000000000..7bb200aa6
--- /dev/null
+++ b/vtkm/filter/PathParticle2.hxx
@@ -0,0 +1,110 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+#ifndef vtk_m_filter_PathParticle2_hxx
+#define vtk_m_filter_PathParticle2_hxx
+
+#include <vtkm/cont/ErrorFilterExecution.h>
+#include <vtkm/filter/PathParticle2.h>
+#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
+
+#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+
+namespace vtkm
+{
+namespace filter
+{
+
+//-----------------------------------------------------------------------------
+inline VTKM_CONT PathParticle2::PathParticle2()
+  : vtkm::filter::FilterTemporalParticleAdvection<PathParticle2, vtkm::Particle>()
+{
+  this->ResultType = vtkm::filter::particleadvection::PARTICLE_ADVECT_TYPE;
+}
+
+//-----------------------------------------------------------------------------
+template <typename DerivedPolicy>
+inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle2::PrepareForExecution(
+  const vtkm::cont::PartitionedDataSet& input,
+  const vtkm::filter::PolicyBase<DerivedPolicy>&)
+{
+  //  using AlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionAlgorithm;
+  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
+  using DSIType = vtkm::filter::particleadvection::DSI;
+
+  this->ValidateOptions();
+  //Make sure everything matches up ok.
+  this->VecFieldType = vtkm::filter::particleadvection::VELOCITY_FIELD_TYPE;
+
+  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
+  std::string activeField = this->GetActiveFieldName();
+
+  std::vector<DSIType*> dsi;
+  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
+  {
+    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
+    auto ds = input.GetPartition(i);
+    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
+      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
+
+    dsi.push_back(new DSIType(
+      ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
+  }
+
+  this->SeedArray = this->Seeds;
+  vtkm::filter::particleadvection::PAV pav(
+    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
+
+#if 0
+  //std::vector<DSIType> ddsi;
+  /*
+  vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
+    boundsMap, ddsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  */
+
+  vtkm::cont::PartitionedDataSet output;
+  return output;
+
+  /*
+  //using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
+  //std::vector<DSIType> dsi;
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
+
+  if (this->GetUseThreadedAlgorithm())
+    return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
+      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  else
+    return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
+      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
+  */
+#endif
+}
+
+VTKM_CONT vtkm::cont::DataSet PathParticle3::DoExecute(const vtkm::cont::DataSet& inData)
+{
+  std::cout << "Meow DS" << std::endl;
+  auto result = this->DoExecutePartitions(inData);
+  return result.GetPartition(0);
+}
+
+VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle3::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& inData)
+{
+  std::cout << "Meow pDS" << std::endl;
+  return inData;
+}
+
+}
+} // namespace vtkm::filter
+#endif
diff --git a/vtkm/filter/Pathline2.hxx b/vtkm/filter/Pathline2.hxx
index 61c418f80..70a38b18e 100644
--- a/vtkm/filter/Pathline2.hxx
+++ b/vtkm/filter/Pathline2.hxx
@@ -29,7 +29,7 @@ namespace filter
 inline VTKM_CONT Pathline2::Pathline2()
   : vtkm::filter::FilterTemporalParticleAdvection<Pathline2, vtkm::Particle>()
 {
-  this->ResultType = vtkm::filter::particleadvection::PARTICLE_ADVECT_TYPE;
+  this->ResultType = vtkm::filter::particleadvection::STREAMLINE_TYPE;
 }
 
 //-----------------------------------------------------------------------------
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index 05bb71a00..03b51df01 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -13,6 +13,7 @@
 #include <vtkm/filter/ParticleAdvection.h>
 #include <vtkm/filter/ParticleAdvection2.h>
 #include <vtkm/filter/PathParticle.h>
+#include <vtkm/filter/PathParticle2.h>
 #include <vtkm/filter/Pathline.h>
 #include <vtkm/filter/Pathline2.h>
 #include <vtkm/filter/Streamline.h>
@@ -472,7 +473,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
         auto pds2 = allPDs2[idx];
         AddVectorFields(pds2, fieldName, vecX);
 
-        vtkm::filter::PathParticle pathParticle;
+        vtkm::filter::PathParticle2 pathParticle;
         pathParticle.SetPreviousTime(0);
         pathParticle.SetNextTime(1000);
         pathParticle.SetNextDataSet(pds2);
@@ -610,7 +611,8 @@ void TestStreamlineFilters()
                                      FilterType::PATHLINE,
                                      FilterType::PATH_PARTICLE };
 
-  fTypes = { FilterType::PARTICLE_ADVECTION, FilterType::STREAMLINE };
+  //fTypes = {FilterType::PARTICLE_ADVECTION,FilterType::STREAMLINE};
+  //fTypes = {FilterType::PATH_PARTICLE};
   for (int n = 1; n < 3; n++)
   {
     for (auto useGhost : flags)

From db4d8a181e97a07d47560d57939328001bcbd5b7 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 30 Jun 2022 09:54:43 -0400
Subject: [PATCH 008/104] Expand support for DSI

---
 vtkm/filter/ParticleAdvection2.hxx            |  35 +--
 vtkm/filter/PathParticle2.h                   |   9 +
 vtkm/filter/PathParticle2.hxx                 |  45 ++--
 vtkm/filter/Pathline2.h                       |   9 +
 vtkm/filter/Pathline2.hxx                     |  45 ++--
 vtkm/filter/Streamline2.hxx                   |  30 +--
 vtkm/filter/particleadvection/ABA.h           |   6 +-
 vtkm/filter/particleadvection/DSI.h           | 121 ++++++++--
 vtkm/filter/particleadvection/DSI.hxx         | 212 ++++++++++++++++--
 vtkm/filter/particleadvection/PAV.h           |  18 +-
 .../testing/UnitTestStreamlineFilter.cxx      |  39 ++--
 11 files changed, 384 insertions(+), 185 deletions(-)

diff --git a/vtkm/filter/ParticleAdvection2.hxx b/vtkm/filter/ParticleAdvection2.hxx
index e5600343e..35e1db782 100644
--- a/vtkm/filter/ParticleAdvection2.hxx
+++ b/vtkm/filter/ParticleAdvection2.hxx
@@ -38,8 +38,9 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForEx
   const vtkm::cont::PartitionedDataSet& input,
   const vtkm::filter::PolicyBase<DerivedPolicy>&)
 {
-  //  using AlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionAlgorithm;
-  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
+  //  return input;
+
+#if 1
   using DSIType = vtkm::filter::particleadvection::DSI;
 
   this->ValidateOptions();
@@ -62,35 +63,9 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForEx
   }
 
   this->SeedArray = this->Seeds;
-  vtkm::filter::particleadvection::PAV pav(
-    boundsMap,
-    dsi,
-    this->UseThreadedAlgorithm,
-    vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE);
+  vtkm::filter::particleadvection::PAV<DSIType> pav(
+    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
-
-#if 0
-  //std::vector<DSIType> ddsi;
-  /*
-  vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
-    boundsMap, ddsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  */
-
-  vtkm::cont::PartitionedDataSet output;
-  return output;
-
-  /*
-  //using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
-  //std::vector<DSIType> dsi;
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
-
-  if (this->GetUseThreadedAlgorithm())
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  else
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  */
 #endif
 }
 
diff --git a/vtkm/filter/PathParticle2.h b/vtkm/filter/PathParticle2.h
index c9d8020de..c9056ee78 100644
--- a/vtkm/filter/PathParticle2.h
+++ b/vtkm/filter/PathParticle2.h
@@ -37,6 +37,15 @@ public:
     const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
 
   vtkm::cont::UnknownArrayHandle SeedArray;
+
+  void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
+  void SetNextTime(vtkm::FloatDefault t2) { this->Time2 = t2; }
+  void SetNextDataSet(const vtkm::cont::DataSet& ds) { this->DataSet2 = { ds }; }
+  void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->DataSet2 = pds; }
+
+  vtkm::cont::PartitionedDataSet DataSet2;
+  vtkm::FloatDefault Time1;
+  vtkm::FloatDefault Time2;
 };
 
 class PathParticle3 : public vtkm::filter::NewFilterField
diff --git a/vtkm/filter/PathParticle2.hxx b/vtkm/filter/PathParticle2.hxx
index 7bb200aa6..20cee1f1f 100644
--- a/vtkm/filter/PathParticle2.hxx
+++ b/vtkm/filter/PathParticle2.hxx
@@ -38,8 +38,6 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle2::PrepareForExecuti
   const vtkm::cont::PartitionedDataSet& input,
   const vtkm::filter::PolicyBase<DerivedPolicy>&)
 {
-  //  using AlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionAlgorithm;
-  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
   using DSIType = vtkm::filter::particleadvection::DSI;
 
   this->ValidateOptions();
@@ -53,42 +51,27 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle2::PrepareForExecuti
   for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
   {
     vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-    auto ds = input.GetPartition(i);
-    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
+    auto ds1 = input.GetPartition(i);
+    auto ds2 = this->DataSet2.GetPartition(i);
+    if ((!ds1.HasPointField(activeField) && !ds1.HasCellField(activeField)) ||
+        (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
       throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-    dsi.push_back(new DSIType(
-      ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
+    dsi.push_back(new DSIType(ds1,
+                              ds2,
+                              this->Time1,
+                              this->Time2,
+                              blockId,
+                              activeField,
+                              this->SolverType,
+                              this->VecFieldType,
+                              this->ResultType));
   }
 
   this->SeedArray = this->Seeds;
-  vtkm::filter::particleadvection::PAV pav(
+  vtkm::filter::particleadvection::PAV<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
-
-#if 0
-  //std::vector<DSIType> ddsi;
-  /*
-  vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
-    boundsMap, ddsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  */
-
-  vtkm::cont::PartitionedDataSet output;
-  return output;
-
-  /*
-  //using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
-  //std::vector<DSIType> dsi;
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
-
-  if (this->GetUseThreadedAlgorithm())
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  else
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  */
-#endif
 }
 
 VTKM_CONT vtkm::cont::DataSet PathParticle3::DoExecute(const vtkm::cont::DataSet& inData)
diff --git a/vtkm/filter/Pathline2.h b/vtkm/filter/Pathline2.h
index 3aff0f46b..35f49799d 100644
--- a/vtkm/filter/Pathline2.h
+++ b/vtkm/filter/Pathline2.h
@@ -36,6 +36,15 @@ public:
     const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
 
   vtkm::cont::UnknownArrayHandle SeedArray;
+
+  void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
+  void SetNextTime(vtkm::FloatDefault t2) { this->Time2 = t2; }
+  void SetNextDataSet(const vtkm::cont::DataSet& ds) { this->DataSet2 = { ds }; }
+  void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->DataSet2 = pds; }
+
+  vtkm::cont::PartitionedDataSet DataSet2;
+  vtkm::FloatDefault Time1;
+  vtkm::FloatDefault Time2;
 };
 
 class Pathline3 : public vtkm::filter::NewFilterField
diff --git a/vtkm/filter/Pathline2.hxx b/vtkm/filter/Pathline2.hxx
index 70a38b18e..5fde0be99 100644
--- a/vtkm/filter/Pathline2.hxx
+++ b/vtkm/filter/Pathline2.hxx
@@ -38,8 +38,6 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Pathline2::PrepareForExecution(
   const vtkm::cont::PartitionedDataSet& input,
   const vtkm::filter::PolicyBase<DerivedPolicy>&)
 {
-  //  using AlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionAlgorithm;
-  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
   using DSIType = vtkm::filter::particleadvection::DSI;
 
   this->ValidateOptions();
@@ -53,42 +51,27 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Pathline2::PrepareForExecution(
   for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
   {
     vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-    auto ds = input.GetPartition(i);
-    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
+    auto ds1 = input.GetPartition(i);
+    auto ds2 = this->DataSet2.GetPartition(i);
+    if ((!ds1.HasPointField(activeField) && !ds1.HasCellField(activeField)) ||
+        (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
       throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-    dsi.push_back(new DSIType(
-      ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
+    dsi.push_back(new DSIType(ds1,
+                              ds2,
+                              this->Time1,
+                              this->Time2,
+                              blockId,
+                              activeField,
+                              this->SolverType,
+                              this->VecFieldType,
+                              this->ResultType));
   }
 
   this->SeedArray = this->Seeds;
-  vtkm::filter::particleadvection::PAV pav(
+  vtkm::filter::particleadvection::PAV<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
-
-#if 0
-  //std::vector<DSIType> ddsi;
-  /*
-  vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
-    boundsMap, ddsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  */
-
-  vtkm::cont::PartitionedDataSet output;
-  return output;
-
-  /*
-  //using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
-  //std::vector<DSIType> dsi;
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
-
-  if (this->GetUseThreadedAlgorithm())
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  else
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  */
-#endif
 }
 
 VTKM_CONT vtkm::cont::DataSet Pathline3::DoExecute(const vtkm::cont::DataSet& inData)
diff --git a/vtkm/filter/Streamline2.hxx b/vtkm/filter/Streamline2.hxx
index 001b20e7b..ec560ee57 100644
--- a/vtkm/filter/Streamline2.hxx
+++ b/vtkm/filter/Streamline2.hxx
@@ -38,8 +38,9 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Streamline2::PrepareForExecution
   const vtkm::cont::PartitionedDataSet& input,
   const vtkm::filter::PolicyBase<DerivedPolicy>&)
 {
-  //  using AlgorithmType = vtkm::filter::particleadvection::StreamlineAlgorithm;
-  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::StreamlineThreadedAlgorithm;
+  //  return input;
+
+#if 1
   using DSIType = vtkm::filter::particleadvection::DSI;
 
   this->ValidateOptions();
@@ -62,32 +63,9 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Streamline2::PrepareForExecution
   }
 
   this->SeedArray = this->Seeds;
-  vtkm::filter::particleadvection::PAV pav(
+  vtkm::filter::particleadvection::PAV<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
-
-#if 0
-  //std::vector<DSIType> ddsi;
-  /*
-  vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
-    boundsMap, ddsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  */
-
-  vtkm::cont::PartitionedDataSet output;
-  return output;
-
-  /*
-  //using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
-  //std::vector<DSIType> dsi;
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
-
-  if (this->GetUseThreadedAlgorithm())
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  else
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  */
 #endif
 }
 
diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/ABA.h
index 839b98a13..de96df0d1 100644
--- a/vtkm/filter/particleadvection/ABA.h
+++ b/vtkm/filter/particleadvection/ABA.h
@@ -24,11 +24,11 @@ namespace filter
 namespace particleadvection
 {
 
-template <template <typename> class ResultType, typename ParticleType>
+template <typename DSIType, template <typename> class ResultType, typename ParticleType>
 class ABA
 {
 public:
-  ABA(const vtkm::filter::particleadvection::BoundsMap& bm, std::vector<DSI*>& blocks)
+  ABA(const vtkm::filter::particleadvection::BoundsMap& bm, std::vector<DSIType*>& blocks)
     : Blocks(blocks)
     , BoundsMap(bm)
     , NumRanks(this->Comm.size())
@@ -393,7 +393,7 @@ public:
 
   //Member data
   std::vector<ParticleType> Active;
-  std::vector<DSI*> Blocks;
+  std::vector<DSIType*> Blocks;
   vtkm::filter::particleadvection::BoundsMap BoundsMap;
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
   std::vector<ParticleType> Inactive;
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index 8fdf1c137..32180e7bd 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -54,18 +54,47 @@ public:
       vtkm::filter::particleadvection::IntegrationSolverType solverType,
       vtkm::filter::particleadvection::VectorFieldType vecFieldType,
       vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
-    : Rank(this->Comm.rank())
+    : Data(ds)
+    , FieldName(fieldNm)
+    , Id(id)
+    , SolverType(solverType)
+    , Rank(this->Comm.rank())
+    , ResType(resultType)
+    , VecFieldType(vecFieldType)
   {
-    this->SolverType = solverType;
-    this->VecFieldType = vecFieldType;
-    this->ResType = resultType;
-    this->DataSet = ds;
-    this->Id = id;
-    this->FieldName = fieldNm;
-
     //check that things are valid.
   }
 
+  DSI(const vtkm::cont::DataSet& ds1,
+      const vtkm::cont::DataSet& ds2,
+      vtkm::FloatDefault t1,
+      vtkm::FloatDefault t2,
+      vtkm::Id id,
+      const std::string& fieldNm,
+      vtkm::filter::particleadvection::IntegrationSolverType solverType,
+      vtkm::filter::particleadvection::VectorFieldType vecFieldType,
+      vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
+    : FieldName(fieldNm)
+    , Id(id)
+    , SolverType(solverType)
+    , Rank(this->Comm.rank())
+    , ResType(resultType)
+    , VecFieldType(vecFieldType)
+  {
+    std::cout << "****** Create Unsteady DSI." << std::endl;
+    this->Data = UnsteadyStateDataType(ds1, ds2, t1, t2);
+  }
+
+  VTKM_CONT bool IsSteadyState() const
+  {
+    return this->Data.GetIndex() == this->Data.GetIndexOf<SteadyStateDataType>();
+  }
+  VTKM_CONT bool IsUnsteadyState() const
+  {
+    return this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>();
+  }
+
+
   VTKM_CONT vtkm::Id GetID() const { return this->Id; }
   VTKM_CONT void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
 
@@ -86,12 +115,33 @@ public:
                               DSIStuff<ParticleType>& stuff);
 
   template <typename ArrayType>
-  VTKM_CONT void GetVelocityField(
+  VTKM_CONT void GetSteadyStateVelocityField(
     vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
   {
-    auto assoc = this->DataSet.GetField(this->FieldName).GetAssociation();
+    VTKM_ASSERT(this->Data.GetIndex() == this->Data.GetIndexOf<SteadyStateDataType>());
+    const auto& data = this->Data.Get<SteadyStateDataType>();
+    this->GetVelocityField(data, velocityField);
+  }
+
+  template <typename ArrayType>
+  VTKM_CONT void GetUnsteadyStateVelocityField(
+    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField1,
+    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField2) const
+  {
+    VTKM_ASSERT(this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>());
+    const auto& data = this->Data.Get<UnsteadyStateDataType>();
+    this->GetVelocityField(data.DataSet1, velocityField1);
+    this->GetVelocityField(data.DataSet2, velocityField2);
+  }
+
+  template <typename ArrayType>
+  VTKM_CONT void GetVelocityField(
+    const vtkm::cont::DataSet& ds,
+    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
+  {
+    auto assoc = ds.GetField(this->FieldName).GetAssociation();
     ArrayType arr;
-    vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(), arr);
+    vtkm::cont::ArrayCopyShallowIfPossible(ds.GetField(this->FieldName).GetData(), arr);
 
     velocityField = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr, assoc);
   }
@@ -101,14 +151,14 @@ public:
     vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& elecMagField) const
   {
     std::cout << "FIX ME: need fieldname2" << std::endl;
+    /*
     ArrayType arr1, arr2;
     vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(), arr1);
-    vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(),
-                                           arr2); //fieldname 2
+    vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(), arr2);       //fieldname 2
     auto assoc = this->DataSet.GetField(this->FieldName).GetAssociation();
 
-    elecMagField =
-      vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>(arr1, arr2, assoc);
+    elecMagField = vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>(arr1, arr2, assoc);
+    */
   }
 
   //template <typename ParticleType>
@@ -118,12 +168,8 @@ public:
   VTKM_CONT void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
                                    DSIStuff<ParticleType>& stuff) const;
 
-  template <typename ParticleType, template <typename> class ResultType>
-  VTKM_CONT vtkm::cont::DataSet ResultToDataSet() const;
-
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
   vtkm::Id Rank;
-  vtkm::cont::DataSet DataSet;
   vtkm::Id Id;
   std::string FieldName;
   vtkm::filter::particleadvection::IntegrationSolverType SolverType;
@@ -132,15 +178,48 @@ public:
     vtkm::filter::particleadvection::UNKNOWN_TYPE;
   bool CopySeedArray = false;
 
+  /*
+  struct SteadyStateDataType
+  {
+    SteadyStateDataType(const vtkm::cont::DataSet& ds) : DataSet(ds) {}
+    vtkm::cont::DataSet DataSet;
+  };
+  */
 
-  using ResultType =
+  using SteadyStateDataType = vtkm::cont::DataSet;
+  struct UnsteadyStateDataType
+  {
+    UnsteadyStateDataType(const vtkm::cont::DataSet& ds1,
+                          const vtkm::cont::DataSet& ds2,
+                          vtkm::FloatDefault t1,
+                          vtkm::FloatDefault t2)
+      : DataSet1(ds1)
+      , DataSet2(ds2)
+      , Time1(t1)
+      , Time2(t2)
+    {
+    }
+
+    vtkm::cont::DataSet DataSet1;
+    vtkm::cont::DataSet DataSet2;
+    vtkm::FloatDefault Time1;
+    vtkm::FloatDefault Time2;
+  };
+
+  using DSType = vtkm::cont::internal::Variant<SteadyStateDataType, UnsteadyStateDataType>;
+
+  vtkm::cont::internal::Variant<SteadyStateDataType, UnsteadyStateDataType> Data;
+
+
+  using RType =
     vtkm::cont::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
                                   vtkm::worklet::ParticleAdvectionResult<vtkm::ChargedParticle>,
                                   vtkm::worklet::StreamlineResult<vtkm::Particle>,
                                   vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
-  std::vector<ResultType> Results;
+  std::vector<RType> Results;
 };
 
+
 }
 }
 }
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index c86295968..e4dd6ab43 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -17,6 +17,88 @@ namespace filter
 {
 namespace particleadvection
 {
+
+namespace internal
+{
+template <typename GridEvalType,
+          typename WorkletType,
+          template <typename>
+          class ResultType,
+          typename ParticleType,
+          template <typename>
+          class IntType>
+class AdvectHelper;
+
+using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+using TempGridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
+
+
+//Steady state
+template <typename WorkletType,
+          template <typename>
+          class ResultType,
+          typename ParticleType,
+          template <typename>
+          class IntType>
+class AdvectHelper<GridEvType, WorkletType, ResultType, ParticleType, IntType>
+{
+public:
+  static void Advect(const FieldType& velField,
+                     const vtkm::cont::DataSet& ds,
+                     //const vtkm::filter::particleadvection::DSI::SteadyStateDataType& data,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     ResultType<ParticleType>& result)
+
+  {
+    std::cout << "ADVECT HELPER!!!!!!!" << std::endl;
+    using StepperType = vtkm::worklet::particleadvection::Stepper<IntType<GridEvType>, GridEvType>;
+
+    GridEvType eval(ds, velField);
+    StepperType stepper(eval, stepSize);
+
+    WorkletType worklet;
+    result = worklet.Run(stepper, seedArray, maxSteps);
+  }
+};
+
+
+//unSteady state
+template <typename WorkletType,
+          template <typename>
+          class ResultType,
+          typename ParticleType,
+          template <typename>
+          class IntType>
+class AdvectHelper<TempGridEvType, WorkletType, ResultType, ParticleType, IntType>
+{
+public:
+  static void Advect(const FieldType& velField1,
+                     const FieldType& velField2,
+                     const vtkm::filter::particleadvection::DSI::UnsteadyStateDataType& data,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     ResultType<ParticleType>& result)
+
+  {
+    std::cout << "TEMP ADVECT HELPER!!!!!!!" << std::endl;
+    using StepperType =
+      vtkm::worklet::particleadvection::Stepper<IntType<TempGridEvType>, TempGridEvType>;
+
+    TempGridEvType eval(data.DataSet1, data.Time1, velField1, data.DataSet2, data.Time2, velField2);
+    StepperType stepper(eval, stepSize);
+
+    WorkletType worklet;
+    result = worklet.Run(stepper, seedArray, maxSteps);
+  }
+};
+
+}
+
 #if 0
 namespace internal
 {
@@ -79,13 +161,13 @@ DSI::Meow(const char* func, const int& lineNum) const
 
   std::cout << " ******************************";
   std::cout << func << " " << lineNum << " ";
-  using RType = vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>;
+  using ResType = vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>;
 
   //const auto& R0 = this->Results[0]->Get<RType>();
   //const auto& P0 = R0.Particles.ReadPortal().Get(0);
   //RType* r = static_cast<RType*>(this->Results[0]);
   //const auto& P0 = r->Particles.ReadPortal().Get(0);
-  const auto& P0 = this->Results[0].Get<RType>().Particles.ReadPortal().Get(0);
+  const auto& P0 = this->Results[0].Get<ResType>().Particles.ReadPortal().Get(0);
   std::cout << "   PT0=  " << P0.Pos << std::endl;
 
   //std::cout<<"   PT0=  "<<P0.Pos<<std::endl;
@@ -111,12 +193,12 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
 
   if (this->ResType == PARTICLE_ADVECT_TYPE)
   {
-    using RType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
 
     std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
     allParticles.reserve(nResults);
     for (const auto& vres : this->Results)
-      allParticles.push_back(vres.Get<RType>().Particles);
+      allParticles.push_back(vres.Get<ResType>().Particles);
 
     vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
     vtkm::cont::ParticleArrayCopy(allParticles, pts);
@@ -140,12 +222,12 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
   }
   else if (this->ResType == STREAMLINE_TYPE)
   {
-    using RType = vtkm::worklet::StreamlineResult<ParticleType>;
+    using ResType = vtkm::worklet::StreamlineResult<ParticleType>;
 
     //Easy case with one result.
     if (nResults == 1)
     {
-      const auto& res = this->Results[0].Get<RType>();
+      const auto& res = this->Results[0].Get<ResType>();
       ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", res.Positions));
       ds.SetCellSet(res.PolyLines);
     }
@@ -155,7 +237,7 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
       vtkm::Id totalNumCells = 0, totalNumPts = 0;
       for (std::size_t i = 0; i < nResults; i++)
       {
-        const auto& res = this->Results[i].Get<RType>();
+        const auto& res = this->Results[i].Get<ResType>();
         if (i == 0)
           posOffsets[i] = 0;
         else
@@ -170,7 +252,7 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
       appendPts.Allocate(totalNumPts);
       for (std::size_t i = 0; i < nResults; i++)
       {
-        const auto& res = this->Results[i].Get<RType>();
+        const auto& res = this->Results[i].Get<ResType>();
         // copy all values into appendPts starting at offset.
         vtkm::cont::Algorithm::CopySubRange(
           res.Positions, 0, res.Positions.GetNumberOfValues(), appendPts, posOffsets[i]);
@@ -182,7 +264,7 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
       std::size_t off = 0;
       for (std::size_t i = 0; i < nResults; i++)
       {
-        const auto& res = this->Results[i].Get<RType>();
+        const auto& res = this->Results[i].Get<ResType>();
         vtkm::Id nCells = res.PolyLines.GetNumberOfCells();
         for (vtkm::Id j = 0; j < nCells; j++)
           numPtsPerCell[off++] = static_cast<vtkm::Id>(res.PolyLines.GetNumberOfPointsInCell(j));
@@ -382,18 +464,117 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
 
   std::cout << "DSI::Advect() " << v.size() << std::endl;
 
+
+  //Assume all RK4.
+  if (this->VecFieldType == VELOCITY_FIELD_TYPE)
+  {
+    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+    if (this->IsSteadyState())
+    {
+      const auto& data = this->Data.Get<SteadyStateDataType>();
+      using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+      FieldType velField;
+      this->GetSteadyStateVelocityField(velField);
+
+      if (this->ResType == PARTICLE_ADVECT_TYPE)
+      {
+        using AHType = internal::AdvectHelper<GridEvType,
+                                              vtkm::worklet::ParticleAdvection,
+                                              vtkm::worklet::ParticleAdvectionResult,
+                                              ParticleType,
+                                              vtkm::worklet::particleadvection::RK4Integrator>;
+        vtkm::worklet::ParticleAdvectionResult<ParticleType> result;
+        AHType::Advect(velField, data, seedArray, stepSize, maxSteps, result);
+        this->UpdateResult(result, stuff);
+      }
+      else
+      {
+        using AHType = internal::AdvectHelper<GridEvType,
+                                              vtkm::worklet::Streamline,
+                                              vtkm::worklet::StreamlineResult,
+                                              ParticleType,
+                                              vtkm::worklet::particleadvection::RK4Integrator>;
+        vtkm::worklet::StreamlineResult<ParticleType> result;
+        AHType::Advect(velField, data, seedArray, stepSize, maxSteps, result);
+        this->UpdateResult(result, stuff);
+      }
+    }
+    else if (this->IsUnsteadyState())
+    {
+      const auto& data = this->Data.Get<UnsteadyStateDataType>();
+      using GridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
+
+      FieldType velField1, velField2;
+      this->GetUnsteadyStateVelocityField(velField1, velField2);
+
+      if (this->ResType == PARTICLE_ADVECT_TYPE)
+      {
+        using AHType = internal::AdvectHelper<GridEvType,
+                                              vtkm::worklet::ParticleAdvection,
+                                              vtkm::worklet::ParticleAdvectionResult,
+                                              ParticleType,
+                                              vtkm::worklet::particleadvection::RK4Integrator>;
+        vtkm::worklet::ParticleAdvectionResult<ParticleType> result;
+
+        AHType::Advect(velField1, velField2, data, seedArray, stepSize, maxSteps, result);
+        this->UpdateResult(result, stuff);
+      }
+      else
+      {
+        using AHType = internal::AdvectHelper<GridEvType,
+                                              vtkm::worklet::Streamline,
+                                              vtkm::worklet::StreamlineResult,
+                                              ParticleType,
+                                              vtkm::worklet::particleadvection::RK4Integrator>;
+        vtkm::worklet::StreamlineResult<ParticleType> result;
+
+        AHType::Advect(velField1, velField2, data, seedArray, stepSize, maxSteps, result);
+        this->UpdateResult(result, stuff);
+      }
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Data Type in DSI");
+  }
+
+
+#if 0
   if (this->SolverType == IntegrationSolverType::RK4_TYPE)
   {
     if (this->VecFieldType == VELOCITY_FIELD_TYPE) //vtkm::Particle, VelocityField
     {
       using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-      using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-      using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
-      using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
+      //using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+      using GridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
 
       FieldType velField;
       this->GetVelocityField(velField);
 
+      if (this->ResType == PARTICLE_ADVECT_TYPE)
+      {
+        using AHType = internal::AdvectHelper<GridEvType,
+                                              vtkm::worklet::ParticleAdvection,
+                                              vtkm::worklet::ParticleAdvectionResult,
+                                              ParticleType,
+                                              vtkm::worklet::particleadvection::RK4Integrator>;
+        vtkm::worklet::ParticleAdvectionResult<ParticleType> result;
+        //AHType::Advect(velField, this->DataSet, seedArray, stepSize, maxSteps, result);
+        AHType::Advect(velField, velField, this->DataSet, this->DataSet, 0.0, 1.0, seedArray, stepSize, maxSteps, result);
+        this->UpdateResult(result, stuff);
+      }
+      else
+      {
+        using AHType = internal::AdvectHelper<GridEvType,
+                                              vtkm::worklet::Streamline,
+                                              vtkm::worklet::StreamlineResult,
+                                              ParticleType,
+                                              vtkm::worklet::particleadvection::RK4Integrator>;
+        vtkm::worklet::StreamlineResult<ParticleType> result;
+        //AHType::Advect(velField, this->DataSet, seedArray, stepSize, maxSteps, result);
+        AHType::Advect(velField, velField, this->DataSet, this->DataSet, 0.0, 1.0, seedArray, stepSize, maxSteps, result);
+        this->UpdateResult(result, stuff);
+      }
+
+      /*
       GridEvType eval(this->DataSet, velField);
       StepperType stepper(eval, stepSize);
 
@@ -411,6 +592,7 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
         this->UpdateResult(r, stuff);
         //Put results in unknown array??
       }
+      */
     }
     else if (this->VecFieldType == ELECTRO_MAGNETIC_FIELD_TYPE) //vtkm::ChargedParticle
     {
@@ -456,13 +638,15 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
 
       GridEvType eval(this->DataSet, velField);
       StepperType stepper(eval, stepSize);
-      //      vtkm::worklet::ParticleAdvection Worklet;
-      //      result = Worklet.Run(stepper, seedArray, maxSteps);
+//      vtkm::worklet::ParticleAdvection Worklet;
+//      result = Worklet.Run(stepper, seedArray, maxSteps);
       //Put results in unknown array??
     }
   }
+#endif
 }
 
+
 }
 }
 }
diff --git a/vtkm/filter/particleadvection/PAV.h b/vtkm/filter/particleadvection/PAV.h
index 38d16867a..7f1827634 100644
--- a/vtkm/filter/particleadvection/PAV.h
+++ b/vtkm/filter/particleadvection/PAV.h
@@ -22,11 +22,12 @@ namespace filter
 namespace particleadvection
 {
 
+template <typename DSIType>
 class PAV
 {
 public:
   PAV(const vtkm::filter::particleadvection::BoundsMap& bm,
-      const std::vector<DSI*> blocks,
+      const std::vector<DSIType*> blocks,
       const bool& useThreaded,
       const vtkm::filter::particleadvection::ParticleAdvectionResultType& parType)
     : Blocks(blocks)
@@ -63,9 +64,8 @@ private:
       if (this->ResultType ==
           vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
       {
-        using AlgorithmType =
-          vtkm::filter::particleadvection::ABA<vtkm::worklet::ParticleAdvectionResult,
-                                               ParticleType>;
+        using AlgorithmType = vtkm::filter::particleadvection::
+          ABA<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
 
         AlgorithmType algo(this->BoundsMap, this->Blocks);
         algo.Execute(numSteps, stepSize, seeds);
@@ -80,8 +80,8 @@ private:
       }
       else
       {
-        using AlgorithmType =
-          vtkm::filter::particleadvection::ABA<vtkm::worklet::StreamlineResult, ParticleType>;
+        using AlgorithmType = vtkm::filter::particleadvection::
+          ABA<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
 
         AlgorithmType algo(this->BoundsMap, this->Blocks);
         algo.Execute(numSteps, stepSize, seeds);
@@ -91,8 +91,8 @@ private:
     else
     {
       std::cout << "Change me to threaded ABA" << std::endl;
-      using AlgorithmType =
-        vtkm::filter::particleadvection::ABA<vtkm::worklet::ParticleAdvectionResult, ParticleType>;
+      using AlgorithmType = vtkm::filter::particleadvection::
+        ABA<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
 
       AlgorithmType algo(this->BoundsMap, this->Blocks);
       algo.Execute(numSteps, stepSize, seeds);
@@ -101,7 +101,7 @@ private:
   }
 
 
-  std::vector<DSI*> Blocks;
+  std::vector<DSIType*> Blocks;
   vtkm::filter::particleadvection::BoundsMap BoundsMap;
   ParticleAdvectionResultType ResultType;
   bool UseThreadedAlgorithm;
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index 03b51df01..2de35bc12 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -68,7 +68,7 @@ void TestStreamline()
                                      vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
                                      vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
 
-    vtkm::filter::Streamline streamline;
+    vtkm::filter::Streamline2 streamline;
 
     streamline.SetStepSize(0.1f);
     streamline.SetNumberOfSteps(20);
@@ -89,6 +89,12 @@ void TestStreamline()
   }
 }
 
+void DumpDS(const vtkm::cont::DataSet& ds, const std::string& fname)
+{
+  vtkm::io::VTKDataSetWriter wrt(fname);
+  wrt.WriteDataSet(ds);
+}
+
 void TestPathline()
 {
   const vtkm::Id3 dims(5, 5, 5);
@@ -127,7 +133,7 @@ void TestPathline()
       vtkm::Id numExpectedPoints;
       if (fType == 0)
       {
-        vtkm::filter::Pathline filt;
+        vtkm::filter::Pathline2 filt;
         filt.SetActiveField(var);
         filt.SetStepSize(stepSize);
         filt.SetNumberOfSteps(numSteps);
@@ -137,10 +143,15 @@ void TestPathline()
         filt.SetNextDataSet(ds2);
         output = filt.Execute(ds1);
         numExpectedPoints = 33;
+        /*
+        DumpDS(output, "pathline.vtk");
+        DumpDS(ds1, "ds1.vtk");
+        DumpDS(ds2, "ds2.vtk");
+        */
       }
       else
       {
-        vtkm::filter::PathParticle filt;
+        vtkm::filter::PathParticle2 filt;
         filt.SetActiveField(var);
         filt.SetStepSize(stepSize);
         filt.SetNumberOfSteps(numSteps);
@@ -226,7 +237,7 @@ void TestAMRStreamline(bool useSL)
 
     if (useSL)
     {
-      vtkm::filter::Streamline filter;
+      vtkm::filter::Streamline2 filter;
       filter.SetStepSize(0.1f);
       filter.SetNumberOfSteps(100000);
       filter.SetSeeds(seedArray);
@@ -375,18 +386,6 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
                                                vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1) });
     vtkm::Id numSeeds = seedArray.GetNumberOfValues();
 
-    if (idx == 0)
-    {
-      for (int j = 0; j < pds.GetNumberOfPartitions(); j++)
-      {
-        auto ds_j = pds.GetPartition(j);
-        std::string nm = "ds_" + std::to_string(j) + ".vtk";
-        vtkm::io::VTKDataSetWriter wrt(nm);
-        wrt.WriteDataSet(ds_j);
-      }
-    }
-
-
     if (fType == FilterType::STREAMLINE || fType == FilterType::PATHLINE)
     {
       vtkm::cont::PartitionedDataSet out;
@@ -568,7 +567,7 @@ void TestStreamlineFile(const std::string& fname,
   vtkm::cont::DataSet output;
   if (useSL)
   {
-    vtkm::filter::Streamline streamline;
+    vtkm::filter::Streamline2 streamline;
     streamline.SetStepSize(stepSize);
     streamline.SetNumberOfSteps(maxSteps);
     streamline.SetSeeds(seedArray);
@@ -612,7 +611,7 @@ void TestStreamlineFilters()
                                      FilterType::PATH_PARTICLE };
 
   //fTypes = {FilterType::PARTICLE_ADVECTION,FilterType::STREAMLINE};
-  //fTypes = {FilterType::PATH_PARTICLE};
+  //fTypes = {FilterType::PATHLINE};
   for (int n = 1; n < 3; n++)
   {
     for (auto useGhost : flags)
@@ -620,14 +619,14 @@ void TestStreamlineFilters()
         TestPartitionedDataSet(n, useGhost, ft);
   }
 
-  return;
-
   TestStreamline();
   TestPathline();
 
   for (auto useSL : flags)
     TestAMRStreamline(useSL);
 
+  return;
+
   //Fusion test.
   std::vector<vtkm::Vec3f> fusionPts, fusionEndPts;
   fusionPts.push_back(vtkm::Vec3f(0.8f, 0.6f, 0.6f));

From 0771f253718ba4562107606a0003431e7c7497c8 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 1 Jul 2022 08:30:17 -0400
Subject: [PATCH 009/104] Templating work to simplify code (hopefully...)

---
 vtkm/filter/particleadvection/DSI.h   |   6 +-
 vtkm/filter/particleadvection/DSI.hxx | 206 ++++++++++----------------
 2 files changed, 78 insertions(+), 134 deletions(-)

diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index 32180e7bd..a45253a11 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -74,15 +74,15 @@ public:
       vtkm::filter::particleadvection::IntegrationSolverType solverType,
       vtkm::filter::particleadvection::VectorFieldType vecFieldType,
       vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
-    : FieldName(fieldNm)
+    : Data(UnsteadyStateDataType(ds1, ds2, t1, t2))
+    , FieldName(fieldNm)
     , Id(id)
     , SolverType(solverType)
     , Rank(this->Comm.rank())
     , ResType(resultType)
     , VecFieldType(vecFieldType)
   {
-    std::cout << "****** Create Unsteady DSI." << std::endl;
-    this->Data = UnsteadyStateDataType(ds1, ds2, t1, t2);
+    //check that things are valid.
   }
 
   VTKM_CONT bool IsSteadyState() const
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index e4dd6ab43..da315bd84 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -20,46 +20,60 @@ namespace particleadvection
 
 namespace internal
 {
+
+using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+using SteadyStateGridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+using UnSteadyStateGridEvalType =
+  vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
+
 template <typename GridEvalType,
           typename WorkletType,
           template <typename>
           class ResultType,
-          typename ParticleType,
-          template <typename>
-          class IntType>
+          typename ParticleType>
 class AdvectHelper;
 
-using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-using TempGridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
-
 
 //Steady state
-template <typename WorkletType,
-          template <typename>
-          class ResultType,
-          typename ParticleType,
-          template <typename>
-          class IntType>
-class AdvectHelper<GridEvType, WorkletType, ResultType, ParticleType, IntType>
+template <typename WorkletType, template <typename> class ResultType, typename ParticleType>
+class AdvectHelper<SteadyStateGridEvalType, WorkletType, ResultType, ParticleType>
 {
 public:
   static void Advect(const FieldType& velField,
                      const vtkm::cont::DataSet& ds,
-                     //const vtkm::filter::particleadvection::DSI::SteadyStateDataType& data,
                      vtkm::cont::ArrayHandle<ParticleType>& seedArray,
                      vtkm::FloatDefault stepSize,
                      vtkm::Id maxSteps,
+                     const IntegrationSolverType& integratorType,
                      ResultType<ParticleType>& result)
 
   {
-    std::cout << "ADVECT HELPER!!!!!!!" << std::endl;
-    using StepperType = vtkm::worklet::particleadvection::Stepper<IntType<GridEvType>, GridEvType>;
+    using AHType =
+      internal::AdvectHelper<SteadyStateGridEvalType, WorkletType, ResultType, ParticleType>;
 
-    GridEvType eval(ds, velField);
+    if (integratorType == IntegrationSolverType::RK4_TYPE)
+      AHType::template DoAdvect<vtkm::worklet::particleadvection::RK4Integrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    else if (integratorType == IntegrationSolverType::EULER_TYPE)
+      AHType::template DoAdvect<vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  template <template <typename> class IntType>
+  static void DoAdvect(const FieldType& velField,
+                       const vtkm::cont::DataSet& ds,
+                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                       vtkm::FloatDefault stepSize,
+                       vtkm::Id maxSteps,
+                       ResultType<ParticleType>& result)
+  {
+    using StepperType = vtkm::worklet::particleadvection::Stepper<IntType<SteadyStateGridEvalType>,
+                                                                  SteadyStateGridEvalType>;
+    SteadyStateGridEvalType eval(ds, velField);
     StepperType stepper(eval, stepSize);
-
     WorkletType worklet;
     result = worklet.Run(stepper, seedArray, maxSteps);
   }
@@ -67,13 +81,9 @@ public:
 
 
 //unSteady state
-template <typename WorkletType,
-          template <typename>
-          class ResultType,
-          typename ParticleType,
-          template <typename>
-          class IntType>
-class AdvectHelper<TempGridEvType, WorkletType, ResultType, ParticleType, IntType>
+//GridEvalType = TemporalGridEvaluator
+template <typename WorkletType, template <typename> class ResultType, typename ParticleType>
+class AdvectHelper<UnSteadyStateGridEvalType, WorkletType, ResultType, ParticleType>
 {
 public:
   static void Advect(const FieldType& velField1,
@@ -82,16 +92,38 @@ public:
                      vtkm::cont::ArrayHandle<ParticleType>& seedArray,
                      vtkm::FloatDefault stepSize,
                      vtkm::Id maxSteps,
+                     const IntegrationSolverType& integratorType,
                      ResultType<ParticleType>& result)
 
   {
-    std::cout << "TEMP ADVECT HELPER!!!!!!!" << std::endl;
+    using AHType =
+      internal::AdvectHelper<UnSteadyStateGridEvalType, WorkletType, ResultType, ParticleType>;
+
+    if (integratorType == IntegrationSolverType::RK4_TYPE)
+      AHType::template DoAdvect<vtkm::worklet::particleadvection::RK4Integrator>(
+        velField1, velField2, data, seedArray, stepSize, maxSteps, result);
+    else if (integratorType == IntegrationSolverType::EULER_TYPE)
+      AHType::template DoAdvect<vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField1, velField2, data, seedArray, stepSize, maxSteps, result);
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  template <template <typename> class IntType>
+  static void DoAdvect(const FieldType& velField1,
+                       const FieldType& velField2,
+                       const vtkm::filter::particleadvection::DSI::UnsteadyStateDataType& data,
+                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                       vtkm::FloatDefault stepSize,
+                       vtkm::Id maxSteps,
+                       ResultType<ParticleType>& result)
+  {
     using StepperType =
-      vtkm::worklet::particleadvection::Stepper<IntType<TempGridEvType>, TempGridEvType>;
-
-    TempGridEvType eval(data.DataSet1, data.Time1, velField1, data.DataSet2, data.Time2, velField2);
+      vtkm::worklet::particleadvection::Stepper<IntType<UnSteadyStateGridEvalType>,
+                                                UnSteadyStateGridEvalType>;
+    UnSteadyStateGridEvalType eval(
+      data.DataSet1, data.Time1, velField1, data.DataSet2, data.Time2, velField2);
     StepperType stepper(eval, stepSize);
-
     WorkletType worklet;
     result = worklet.Run(stepper, seedArray, maxSteps);
   }
@@ -99,59 +131,7 @@ public:
 
 }
 
-#if 0
-namespace internal
-{
-//Helper class to store the different result types.
-//template <typename ResultType>
-template <template <typename> class ResultType, typename ParticleType>
-class ResultHelper2;
-
-template <typename ParticleType>
-class ResultHelper2<vtkm::worklet::ParticleAdvectionResult, ParticleType>
-{
-  using PAType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
-
-public:
-  static void Store(const PAType& result)
-  {
-  }
-
-  static vtkm::cont::DataSet
-  GetOutput()
-  {
-    vtkm::cont::DataSet ds;
-
-    return ds;
-  }
-};
-
-template <typename ParticleType>
-class ResultHelper2<vtkm::worklet::StreamlineResult, ParticleType>
-{
-  using PAType = vtkm::worklet::StreamlineResult<ParticleType>;
-
-public:
-  static void Store(const PAType& result)
-  {
-  }
-
-  static vtkm::cont::DataSet
-  GetOutput()
-  {
-    vtkm::cont::DataSet ds;
-
-    return ds;
-  }
-};
-
-}
-#endif
-
-//template <typename ParticleType>
-void
-//DSI<ParticleType>::Meow() const
-DSI::Meow(const char* func, const int& lineNum) const
+void DSI::Meow(const char* func, const int& lineNum) const
 {
   if (this->Results.empty())
   {
@@ -298,40 +278,6 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
   return true;
 }
 
-namespace internal
-{
-using ResultVariantType =
-  vtkm::cont::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
-                                vtkm::worklet::ParticleAdvectionResult<vtkm::ChargedParticle>,
-                                vtkm::worklet::StreamlineResult<vtkm::Particle>,
-                                vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
-
-template <template <typename> class ResultType, typename ParticleType>
-class ResultHelper
-{
-public:
-  static void Store(const vtkm::worklet::ParticleAdvectionResult<ParticleType>& res,
-                    std::vector<ResultVariantType>& results)
-  {
-    results.push_back(res);
-  }
-};
-
-
-/*
-template <typename ParticleType>
-class ResultHelper<vtkm::worklet::ParticleAdvectionResult, ParticleType>
-{
-public:
-  static void Store(const vtkm::worklet::ParticleAdvectionResult<ParticleType>>& res,
-                    std::vector<ResultVariantType>& results)
-  {
-    results.push_back(res);
-  }
-};
-  */
-};
-
 template <typename ParticleType, template <typename> class ResultType>
 VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
                                  DSIStuff<ParticleType>& stuff)
@@ -481,10 +427,9 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
         using AHType = internal::AdvectHelper<GridEvType,
                                               vtkm::worklet::ParticleAdvection,
                                               vtkm::worklet::ParticleAdvectionResult,
-                                              ParticleType,
-                                              vtkm::worklet::particleadvection::RK4Integrator>;
+                                              ParticleType>;
         vtkm::worklet::ParticleAdvectionResult<ParticleType> result;
-        AHType::Advect(velField, data, seedArray, stepSize, maxSteps, result);
+        AHType::Advect(velField, data, seedArray, stepSize, maxSteps, this->SolverType, result);
         this->UpdateResult(result, stuff);
       }
       else
@@ -492,10 +437,9 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
         using AHType = internal::AdvectHelper<GridEvType,
                                               vtkm::worklet::Streamline,
                                               vtkm::worklet::StreamlineResult,
-                                              ParticleType,
-                                              vtkm::worklet::particleadvection::RK4Integrator>;
+                                              ParticleType>;
         vtkm::worklet::StreamlineResult<ParticleType> result;
-        AHType::Advect(velField, data, seedArray, stepSize, maxSteps, result);
+        AHType::Advect(velField, data, seedArray, stepSize, maxSteps, this->SolverType, result);
         this->UpdateResult(result, stuff);
       }
     }
@@ -512,11 +456,11 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
         using AHType = internal::AdvectHelper<GridEvType,
                                               vtkm::worklet::ParticleAdvection,
                                               vtkm::worklet::ParticleAdvectionResult,
-                                              ParticleType,
-                                              vtkm::worklet::particleadvection::RK4Integrator>;
+                                              ParticleType>;
         vtkm::worklet::ParticleAdvectionResult<ParticleType> result;
 
-        AHType::Advect(velField1, velField2, data, seedArray, stepSize, maxSteps, result);
+        AHType::Advect(
+          velField1, velField2, data, seedArray, stepSize, maxSteps, this->SolverType, result);
         this->UpdateResult(result, stuff);
       }
       else
@@ -524,11 +468,11 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
         using AHType = internal::AdvectHelper<GridEvType,
                                               vtkm::worklet::Streamline,
                                               vtkm::worklet::StreamlineResult,
-                                              ParticleType,
-                                              vtkm::worklet::particleadvection::RK4Integrator>;
+                                              ParticleType>;
         vtkm::worklet::StreamlineResult<ParticleType> result;
 
-        AHType::Advect(velField1, velField2, data, seedArray, stepSize, maxSteps, result);
+        AHType::Advect(
+          velField1, velField2, data, seedArray, stepSize, maxSteps, this->SolverType, result);
         this->UpdateResult(result, stuff);
       }
     }

From 41c8072894a372cc6f7d1758e236da8a1df82758 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 1 Jul 2022 09:00:54 -0400
Subject: [PATCH 010/104] Kick the dashboards.

---
 vtkm/filter/particleadvection/DSI.hxx | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index da315bd84..efed13a5e 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -408,10 +408,7 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
   auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
   auto seedArray = vtkm::cont::make_ArrayHandle(v, copyFlag);
 
-  std::cout << "DSI::Advect() " << v.size() << std::endl;
-
-
-  //Assume all RK4.
+  //Velocity field advection.
   if (this->VecFieldType == VELOCITY_FIELD_TYPE)
   {
     using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;

From 6e4691acfcebc5c945ffa803753e73c33a7725f7 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 5 Jul 2022 09:54:47 -0400
Subject: [PATCH 011/104] reworking the advect templating.

---
 vtkm/filter/FilterParticleAdvection.h         |   2 +-
 vtkm/filter/FilterParticleAdvection.hxx       |   2 +-
 vtkm/filter/ParticleAdvection2.hxx            |   5 +-
 vtkm/filter/PathParticle2.hxx                 |   5 +-
 vtkm/filter/Pathline2.hxx                     |   4 +-
 vtkm/filter/Streamline2.hxx                   |   4 +-
 vtkm/filter/particleadvection/DSI.h           |   2 +-
 vtkm/filter/particleadvection/DSI.hxx         | 177 +++++++++++++++++-
 .../ParticleAdvectionTypes.h                  |   6 +-
 9 files changed, 185 insertions(+), 22 deletions(-)

diff --git a/vtkm/filter/FilterParticleAdvection.h b/vtkm/filter/FilterParticleAdvection.h
index 126f9ff0a..606175ae1 100644
--- a/vtkm/filter/FilterParticleAdvection.h
+++ b/vtkm/filter/FilterParticleAdvection.h
@@ -91,7 +91,7 @@ protected:
 
   vtkm::Id NumberOfSteps;
   vtkm::filter::particleadvection::ParticleAdvectionResultType ResultType =
-    vtkm::filter::particleadvection::UNKNOWN_TYPE;
+    vtkm::filter::particleadvection::ParticleAdvectionResultType::UNKNOWN_TYPE;
   vtkm::cont::ArrayHandle<ParticleType> Seeds;
   vtkm::filter::particleadvection::IntegrationSolverType SolverType;
   vtkm::FloatDefault StepSize;
diff --git a/vtkm/filter/FilterParticleAdvection.hxx b/vtkm/filter/FilterParticleAdvection.hxx
index 7627e6d79..0cdbf858b 100644
--- a/vtkm/filter/FilterParticleAdvection.hxx
+++ b/vtkm/filter/FilterParticleAdvection.hxx
@@ -22,7 +22,7 @@ template <typename Derived, typename ParticleType>
 inline VTKM_CONT FilterParticleAdvection<Derived, ParticleType>::FilterParticleAdvection()
   : vtkm::filter::FilterDataSetWithField<Derived>()
   , NumberOfSteps(0)
-  , SolverType(vtkm::filter::particleadvection::RK4_TYPE)
+  , SolverType(vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE)
   , StepSize(0)
   , UseThreadedAlgorithm(false)
 {
diff --git a/vtkm/filter/ParticleAdvection2.hxx b/vtkm/filter/ParticleAdvection2.hxx
index 35e1db782..39142c97f 100644
--- a/vtkm/filter/ParticleAdvection2.hxx
+++ b/vtkm/filter/ParticleAdvection2.hxx
@@ -29,7 +29,8 @@ namespace filter
 inline VTKM_CONT ParticleAdvection2::ParticleAdvection2()
   : vtkm::filter::FilterParticleAdvection<ParticleAdvection2, vtkm::Particle>()
 {
-  this->ResultType = vtkm::filter::particleadvection::PARTICLE_ADVECT_TYPE;
+  this->ResultType =
+    vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE;
 }
 
 //-----------------------------------------------------------------------------
@@ -45,7 +46,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForEx
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
-  this->VecFieldType = vtkm::filter::particleadvection::VELOCITY_FIELD_TYPE;
+  this->VecFieldType = vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE;
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   std::string activeField = this->GetActiveFieldName();
diff --git a/vtkm/filter/PathParticle2.hxx b/vtkm/filter/PathParticle2.hxx
index 20cee1f1f..c1ac92223 100644
--- a/vtkm/filter/PathParticle2.hxx
+++ b/vtkm/filter/PathParticle2.hxx
@@ -29,7 +29,8 @@ namespace filter
 inline VTKM_CONT PathParticle2::PathParticle2()
   : vtkm::filter::FilterTemporalParticleAdvection<PathParticle2, vtkm::Particle>()
 {
-  this->ResultType = vtkm::filter::particleadvection::PARTICLE_ADVECT_TYPE;
+  this->ResultType =
+    vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE;
 }
 
 //-----------------------------------------------------------------------------
@@ -42,7 +43,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle2::PrepareForExecuti
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
-  this->VecFieldType = vtkm::filter::particleadvection::VELOCITY_FIELD_TYPE;
+  this->VecFieldType = vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE;
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   std::string activeField = this->GetActiveFieldName();
diff --git a/vtkm/filter/Pathline2.hxx b/vtkm/filter/Pathline2.hxx
index 5fde0be99..8853ff6b7 100644
--- a/vtkm/filter/Pathline2.hxx
+++ b/vtkm/filter/Pathline2.hxx
@@ -29,7 +29,7 @@ namespace filter
 inline VTKM_CONT Pathline2::Pathline2()
   : vtkm::filter::FilterTemporalParticleAdvection<Pathline2, vtkm::Particle>()
 {
-  this->ResultType = vtkm::filter::particleadvection::STREAMLINE_TYPE;
+  this->ResultType = vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE;
 }
 
 //-----------------------------------------------------------------------------
@@ -42,7 +42,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Pathline2::PrepareForExecution(
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
-  this->VecFieldType = vtkm::filter::particleadvection::VELOCITY_FIELD_TYPE;
+  this->VecFieldType = vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE;
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   std::string activeField = this->GetActiveFieldName();
diff --git a/vtkm/filter/Streamline2.hxx b/vtkm/filter/Streamline2.hxx
index ec560ee57..73256a4f0 100644
--- a/vtkm/filter/Streamline2.hxx
+++ b/vtkm/filter/Streamline2.hxx
@@ -29,7 +29,7 @@ namespace filter
 inline VTKM_CONT Streamline2::Streamline2()
   : vtkm::filter::FilterParticleAdvection<Streamline2, vtkm::Particle>()
 {
-  this->ResultType = vtkm::filter::particleadvection::STREAMLINE_TYPE;
+  this->ResultType = vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE;
 }
 
 //-----------------------------------------------------------------------------
@@ -45,7 +45,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Streamline2::PrepareForExecution
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
-  this->VecFieldType = vtkm::filter::particleadvection::VELOCITY_FIELD_TYPE;
+  this->VecFieldType = vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE;
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   std::string activeField = this->GetActiveFieldName();
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index a45253a11..0cb12a342 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -175,7 +175,7 @@ public:
   vtkm::filter::particleadvection::IntegrationSolverType SolverType;
   vtkm::filter::particleadvection::VectorFieldType VecFieldType;
   vtkm::filter::particleadvection::ParticleAdvectionResultType ResType =
-    vtkm::filter::particleadvection::UNKNOWN_TYPE;
+    vtkm::filter::particleadvection::ParticleAdvectionResultType::UNKNOWN_TYPE;
   bool CopySeedArray = false;
 
   /*
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index efed13a5e..4e2f7d6b6 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -171,7 +171,7 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
 
   std::cout << "Check the variant type!" << std::endl;
 
-  if (this->ResType == PARTICLE_ADVECT_TYPE)
+  if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
   {
     using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
 
@@ -200,7 +200,7 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
       ds.SetCellSet(cells);
     }
   }
-  else if (this->ResType == STREAMLINE_TYPE)
+  else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
   {
     using ResType = vtkm::worklet::StreamlineResult<ParticleType>;
 
@@ -287,7 +287,8 @@ VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
   //this->Meow(__PRETTY_FUNCTION__, __LINE__);
 
   //template this for PA and SL
-  if (this->ResType == vtkm::filter::particleadvection::PARTICLE_ADVECT_TYPE)
+  if (this->ResType ==
+      vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
   {
     if (stuff.TermIdx.empty())
       return;
@@ -302,7 +303,8 @@ VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
     ResType termRes(termParticles);
     this->Results.push_back(termRes);
   }
-  else if (this->ResType == vtkm::filter::particleadvection::STREAMLINE_TYPE)
+  else if (this->ResType ==
+           vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
   {
     this->Results.push_back(result);
   }
@@ -402,14 +404,173 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
                            vtkm::Id maxSteps,
                            DSIStuff<ParticleType>& stuff)
 {
+
   //using Association = vtkm::cont::Field::Association;
   using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
 
   auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
   auto seedArray = vtkm::cont::make_ArrayHandle(v, copyFlag);
 
+  //PA or SL result.
+  if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+  {
+    vtkm::worklet::ParticleAdvectionResult<ParticleType> result;
+    vtkm::worklet::ParticleAdvection worklet;
+
+    if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
+    {
+      using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+
+      if (this->IsSteadyState())
+      {
+        using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+
+        FieldType velField;
+        this->GetSteadyStateVelocityField(velField);
+
+        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
+        {
+          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
+
+          GridEvType eval(this->Data.Get<DSI::SteadyStateDataType>(), velField);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
+        {
+          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
+
+          GridEvType eval(this->Data.Get<SteadyStateDataType>(), velField);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+      }
+      else if (this->IsUnsteadyState())
+      {
+        using GridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
+
+        FieldType velField1, velField2;
+        this->GetUnsteadyStateVelocityField(velField1, velField2);
+        const auto d = this->Data.Get<UnsteadyStateDataType>();
+
+        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
+        {
+          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
+
+          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
+        {
+          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
+
+          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+      }
+    }
+    else if (this->VecFieldType == VectorFieldType::ELECTRO_MAGNETIC_FIELD_TYPE)
+    {
+      using FieldType = vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>;
+    }
+
+    this->UpdateResult(result, stuff);
+  }
+  else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
+  {
+    vtkm::worklet::StreamlineResult<ParticleType> result;
+    vtkm::worklet::Streamline worklet;
+
+    if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
+    {
+      using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+
+      if (this->IsSteadyState())
+      {
+        using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+
+        FieldType velField;
+        this->GetSteadyStateVelocityField(velField);
+
+        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
+        {
+          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
+
+          GridEvType eval(this->Data.Get<DSI::SteadyStateDataType>(), velField);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
+        {
+          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
+
+          GridEvType eval(this->Data.Get<SteadyStateDataType>(), velField);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+      }
+      else if (this->IsUnsteadyState())
+      {
+        using GridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
+
+        FieldType velField1, velField2;
+        this->GetUnsteadyStateVelocityField(velField1, velField2);
+        const auto d = this->Data.Get<UnsteadyStateDataType>();
+
+        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
+        {
+          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
+
+          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
+        {
+          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
+
+          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+      }
+    }
+    else if (this->VecFieldType == VectorFieldType::ELECTRO_MAGNETIC_FIELD_TYPE)
+    {
+      using FieldType = vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>;
+    }
+
+    this->UpdateResult(result, stuff);
+  }
+  else
+    throw vtkm::cont::ErrorFilterExecution("Unsupported Data Type in DSI");
+
+#if 0
+  auto result = ahType::Advect(this->VecFieldType,
+                               this->SolverType,
+                               this->IsSteadyState(),
+                               this->ResType);
+
   //Velocity field advection.
-  if (this->VecFieldType == VELOCITY_FIELD_TYPE)
+  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
   {
     using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
     if (this->IsSteadyState())
@@ -419,7 +580,7 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
       FieldType velField;
       this->GetSteadyStateVelocityField(velField);
 
-      if (this->ResType == PARTICLE_ADVECT_TYPE)
+      if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
       {
         using AHType = internal::AdvectHelper<GridEvType,
                                               vtkm::worklet::ParticleAdvection,
@@ -448,7 +609,7 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
       FieldType velField1, velField2;
       this->GetUnsteadyStateVelocityField(velField1, velField2);
 
-      if (this->ResType == PARTICLE_ADVECT_TYPE)
+      if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
       {
         using AHType = internal::AdvectHelper<GridEvType,
                                               vtkm::worklet::ParticleAdvection,
@@ -476,7 +637,7 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
     else
       throw vtkm::cont::ErrorFilterExecution("Unsupported Data Type in DSI");
   }
-
+#endif
 
 #if 0
   if (this->SolverType == IntegrationSolverType::RK4_TYPE)
diff --git a/vtkm/filter/particleadvection/ParticleAdvectionTypes.h b/vtkm/filter/particleadvection/ParticleAdvectionTypes.h
index 7d11ebbfa..e5e8f1428 100644
--- a/vtkm/filter/particleadvection/ParticleAdvectionTypes.h
+++ b/vtkm/filter/particleadvection/ParticleAdvectionTypes.h
@@ -16,19 +16,19 @@ namespace filter
 {
 namespace particleadvection
 {
-enum IntegrationSolverType
+enum class IntegrationSolverType
 {
   RK4_TYPE = 0,
   EULER_TYPE,
 };
 
-enum VectorFieldType
+enum class VectorFieldType
 {
   VELOCITY_FIELD_TYPE = 0,
   ELECTRO_MAGNETIC_FIELD_TYPE,
 };
 
-enum ParticleAdvectionResultType
+enum class ParticleAdvectionResultType
 {
   UNKNOWN_TYPE = -1,
   PARTICLE_ADVECT_TYPE,

From e920e9fa39b00a584e89b0e8d2ecc0a2f840c944 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 5 Jul 2022 13:40:45 -0400
Subject: [PATCH 012/104] Add electro-mag code.

---
 vtkm/filter/particleadvection/DSI.h   |  16 +-
 vtkm/filter/particleadvection/DSI.hxx | 353 ++++----------------------
 2 files changed, 71 insertions(+), 298 deletions(-)

diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index 0cb12a342..2f8f0c64d 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -147,7 +147,7 @@ public:
   }
 
   template <typename ArrayType>
-  VTKM_CONT void GetElectroMagneticField(
+  VTKM_CONT void GetSteadyStateElectroMagneticField(
     vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& elecMagField) const
   {
     std::cout << "FIX ME: need fieldname2" << std::endl;
@@ -161,6 +161,20 @@ public:
     */
   }
 
+  template <typename ArrayType>
+  VTKM_CONT void GetUnsteadyStateElectroMagneticField(
+    vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& emField1,
+    vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& emField2) const
+  {
+    std::cout << "FIX ME: need fieldname2" << std::endl;
+    /*
+    VTKM_ASSERT(this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>());
+    const auto& data = this->Data.Get<UnsteadyStateDataType>();
+    this->GetSteadyStateElectroMagneticField(data.DataSet1, emField1);
+    this->GetSteadyStateElectroMagneticField(data.DataSet2, emField2);
+    */
+  }
+
   //template <typename ParticleType>
   void Meow(const char* func, const int& lineNum) const;
 
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index 4e2f7d6b6..746795f54 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -18,119 +18,6 @@ namespace filter
 namespace particleadvection
 {
 
-namespace internal
-{
-
-using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-using SteadyStateGridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-using UnSteadyStateGridEvalType =
-  vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
-
-template <typename GridEvalType,
-          typename WorkletType,
-          template <typename>
-          class ResultType,
-          typename ParticleType>
-class AdvectHelper;
-
-
-//Steady state
-template <typename WorkletType, template <typename> class ResultType, typename ParticleType>
-class AdvectHelper<SteadyStateGridEvalType, WorkletType, ResultType, ParticleType>
-{
-public:
-  static void Advect(const FieldType& velField,
-                     const vtkm::cont::DataSet& ds,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& integratorType,
-                     ResultType<ParticleType>& result)
-
-  {
-    using AHType =
-      internal::AdvectHelper<SteadyStateGridEvalType, WorkletType, ResultType, ParticleType>;
-
-    if (integratorType == IntegrationSolverType::RK4_TYPE)
-      AHType::template DoAdvect<vtkm::worklet::particleadvection::RK4Integrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    else if (integratorType == IntegrationSolverType::EULER_TYPE)
-      AHType::template DoAdvect<vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  template <template <typename> class IntType>
-  static void DoAdvect(const FieldType& velField,
-                       const vtkm::cont::DataSet& ds,
-                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                       vtkm::FloatDefault stepSize,
-                       vtkm::Id maxSteps,
-                       ResultType<ParticleType>& result)
-  {
-    using StepperType = vtkm::worklet::particleadvection::Stepper<IntType<SteadyStateGridEvalType>,
-                                                                  SteadyStateGridEvalType>;
-    SteadyStateGridEvalType eval(ds, velField);
-    StepperType stepper(eval, stepSize);
-    WorkletType worklet;
-    result = worklet.Run(stepper, seedArray, maxSteps);
-  }
-};
-
-
-//unSteady state
-//GridEvalType = TemporalGridEvaluator
-template <typename WorkletType, template <typename> class ResultType, typename ParticleType>
-class AdvectHelper<UnSteadyStateGridEvalType, WorkletType, ResultType, ParticleType>
-{
-public:
-  static void Advect(const FieldType& velField1,
-                     const FieldType& velField2,
-                     const vtkm::filter::particleadvection::DSI::UnsteadyStateDataType& data,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& integratorType,
-                     ResultType<ParticleType>& result)
-
-  {
-    using AHType =
-      internal::AdvectHelper<UnSteadyStateGridEvalType, WorkletType, ResultType, ParticleType>;
-
-    if (integratorType == IntegrationSolverType::RK4_TYPE)
-      AHType::template DoAdvect<vtkm::worklet::particleadvection::RK4Integrator>(
-        velField1, velField2, data, seedArray, stepSize, maxSteps, result);
-    else if (integratorType == IntegrationSolverType::EULER_TYPE)
-      AHType::template DoAdvect<vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField1, velField2, data, seedArray, stepSize, maxSteps, result);
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  template <template <typename> class IntType>
-  static void DoAdvect(const FieldType& velField1,
-                       const FieldType& velField2,
-                       const vtkm::filter::particleadvection::DSI::UnsteadyStateDataType& data,
-                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                       vtkm::FloatDefault stepSize,
-                       vtkm::Id maxSteps,
-                       ResultType<ParticleType>& result)
-  {
-    using StepperType =
-      vtkm::worklet::particleadvection::Stepper<IntType<UnSteadyStateGridEvalType>,
-                                                UnSteadyStateGridEvalType>;
-    UnSteadyStateGridEvalType eval(
-      data.DataSet1, data.Time1, velField1, data.DataSet2, data.Time2, velField2);
-    StepperType stepper(eval, stepSize);
-    WorkletType worklet;
-    result = worklet.Run(stepper, seedArray, maxSteps);
-  }
-};
-
-}
-
 void DSI::Meow(const char* func, const int& lineNum) const
 {
   if (this->Results.empty())
@@ -482,6 +369,62 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
     else if (this->VecFieldType == VectorFieldType::ELECTRO_MAGNETIC_FIELD_TYPE)
     {
       using FieldType = vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>;
+
+      if (this->IsSteadyState())
+      {
+        using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+
+        FieldType velField;
+        this->GetSteadyStateElectroMagneticField(velField);
+        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
+        {
+          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
+
+          GridEvType eval(this->Data.Get<DSI::SteadyStateDataType>(), velField);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
+        {
+          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
+
+          GridEvType eval(this->Data.Get<SteadyStateDataType>(), velField);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+      }
+      else if (this->IsUnsteadyState())
+      {
+        using GridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
+        FieldType velField1, velField2;
+        this->GetUnsteadyStateElectroMagneticField(velField1, velField2);
+        const auto d = this->Data.Get<UnsteadyStateDataType>();
+
+        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
+        {
+          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
+
+          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
+        {
+          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
+          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
+
+          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
+          StepperType stepper(eval, stepSize);
+
+          result = worklet.Run(stepper, seedArray, maxSteps);
+        }
+      }
     }
 
     this->UpdateResult(result, stuff);
@@ -562,190 +505,6 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
   }
   else
     throw vtkm::cont::ErrorFilterExecution("Unsupported Data Type in DSI");
-
-#if 0
-  auto result = ahType::Advect(this->VecFieldType,
-                               this->SolverType,
-                               this->IsSteadyState(),
-                               this->ResType);
-
-  //Velocity field advection.
-  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
-  {
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-    if (this->IsSteadyState())
-    {
-      const auto& data = this->Data.Get<SteadyStateDataType>();
-      using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-      FieldType velField;
-      this->GetSteadyStateVelocityField(velField);
-
-      if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
-      {
-        using AHType = internal::AdvectHelper<GridEvType,
-                                              vtkm::worklet::ParticleAdvection,
-                                              vtkm::worklet::ParticleAdvectionResult,
-                                              ParticleType>;
-        vtkm::worklet::ParticleAdvectionResult<ParticleType> result;
-        AHType::Advect(velField, data, seedArray, stepSize, maxSteps, this->SolverType, result);
-        this->UpdateResult(result, stuff);
-      }
-      else
-      {
-        using AHType = internal::AdvectHelper<GridEvType,
-                                              vtkm::worklet::Streamline,
-                                              vtkm::worklet::StreamlineResult,
-                                              ParticleType>;
-        vtkm::worklet::StreamlineResult<ParticleType> result;
-        AHType::Advect(velField, data, seedArray, stepSize, maxSteps, this->SolverType, result);
-        this->UpdateResult(result, stuff);
-      }
-    }
-    else if (this->IsUnsteadyState())
-    {
-      const auto& data = this->Data.Get<UnsteadyStateDataType>();
-      using GridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
-
-      FieldType velField1, velField2;
-      this->GetUnsteadyStateVelocityField(velField1, velField2);
-
-      if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
-      {
-        using AHType = internal::AdvectHelper<GridEvType,
-                                              vtkm::worklet::ParticleAdvection,
-                                              vtkm::worklet::ParticleAdvectionResult,
-                                              ParticleType>;
-        vtkm::worklet::ParticleAdvectionResult<ParticleType> result;
-
-        AHType::Advect(
-          velField1, velField2, data, seedArray, stepSize, maxSteps, this->SolverType, result);
-        this->UpdateResult(result, stuff);
-      }
-      else
-      {
-        using AHType = internal::AdvectHelper<GridEvType,
-                                              vtkm::worklet::Streamline,
-                                              vtkm::worklet::StreamlineResult,
-                                              ParticleType>;
-        vtkm::worklet::StreamlineResult<ParticleType> result;
-
-        AHType::Advect(
-          velField1, velField2, data, seedArray, stepSize, maxSteps, this->SolverType, result);
-        this->UpdateResult(result, stuff);
-      }
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Data Type in DSI");
-  }
-#endif
-
-#if 0
-  if (this->SolverType == IntegrationSolverType::RK4_TYPE)
-  {
-    if (this->VecFieldType == VELOCITY_FIELD_TYPE) //vtkm::Particle, VelocityField
-    {
-      using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-      //using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-      using GridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
-
-      FieldType velField;
-      this->GetVelocityField(velField);
-
-      if (this->ResType == PARTICLE_ADVECT_TYPE)
-      {
-        using AHType = internal::AdvectHelper<GridEvType,
-                                              vtkm::worklet::ParticleAdvection,
-                                              vtkm::worklet::ParticleAdvectionResult,
-                                              ParticleType,
-                                              vtkm::worklet::particleadvection::RK4Integrator>;
-        vtkm::worklet::ParticleAdvectionResult<ParticleType> result;
-        //AHType::Advect(velField, this->DataSet, seedArray, stepSize, maxSteps, result);
-        AHType::Advect(velField, velField, this->DataSet, this->DataSet, 0.0, 1.0, seedArray, stepSize, maxSteps, result);
-        this->UpdateResult(result, stuff);
-      }
-      else
-      {
-        using AHType = internal::AdvectHelper<GridEvType,
-                                              vtkm::worklet::Streamline,
-                                              vtkm::worklet::StreamlineResult,
-                                              ParticleType,
-                                              vtkm::worklet::particleadvection::RK4Integrator>;
-        vtkm::worklet::StreamlineResult<ParticleType> result;
-        //AHType::Advect(velField, this->DataSet, seedArray, stepSize, maxSteps, result);
-        AHType::Advect(velField, velField, this->DataSet, this->DataSet, 0.0, 1.0, seedArray, stepSize, maxSteps, result);
-        this->UpdateResult(result, stuff);
-      }
-
-      /*
-      GridEvType eval(this->DataSet, velField);
-      StepperType stepper(eval, stepSize);
-
-      //make this a template
-      if (this->ResType == PARTICLE_ADVECT_TYPE)
-      {
-        vtkm::worklet::ParticleAdvection Worklet;
-        auto result = Worklet.Run(stepper, seedArray, maxSteps);
-        this->UpdateResult(result, stuff);
-      }
-      else
-      {
-        vtkm::worklet::Streamline Worklet;
-        auto r = Worklet.Run(stepper, seedArray, maxSteps);
-        this->UpdateResult(r, stuff);
-        //Put results in unknown array??
-      }
-      */
-    }
-    else if (this->VecFieldType == ELECTRO_MAGNETIC_FIELD_TYPE) //vtkm::ChargedParticle
-    {
-      using FieldType = vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>;
-      using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-      using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
-      using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
-
-      FieldType velField;
-      this->GetElectroMagneticField(velField);
-
-      GridEvType eval(this->DataSet, velField);
-      StepperType stepper(eval, stepSize);
-
-      if (this->ResType == PARTICLE_ADVECT_TYPE)
-      {
-        vtkm::worklet::ParticleAdvection Worklet;
-        auto r = Worklet.Run(stepper, seedArray, maxSteps);
-        this->UpdateResult(r, stuff);
-        ///*result =*/ auto r = Worklet.Run(stepper, seedArray, maxSteps);
-      }
-      else
-      {
-        vtkm::worklet::Streamline Worklet;
-        auto r = Worklet.Run(stepper, seedArray, maxSteps);
-        this->UpdateResult(r, stuff);
-        ///*result =*/ Worklet.Run(stepper, seedArray, maxSteps);
-      }
-    }
-  }
-
-  else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
-  {
-    if (this->VecFieldType == VELOCITY_FIELD_TYPE) //vtkm::Particle, VelocityField
-    {
-      using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-      using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-      using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
-      using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
-
-      FieldType velField;
-      this->GetVelocityField(velField);
-
-      GridEvType eval(this->DataSet, velField);
-      StepperType stepper(eval, stepSize);
-//      vtkm::worklet::ParticleAdvection Worklet;
-//      result = Worklet.Run(stepper, seedArray, maxSteps);
-      //Put results in unknown array??
-    }
-  }
-#endif
 }
 
 

From a61fa7d9b0aa54f180e33b74a678bbb2e8c8853a Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 5 Jul 2022 14:35:43 -0400
Subject: [PATCH 013/104] Fix for MPI filters.

---
 .../testing/UnitTestStreamlineFilterMPI.cxx     | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
index 4af041bff..11f6b6d89 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
@@ -10,8 +10,11 @@
 
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/ParticleAdvection.h>
+#include <vtkm/filter/ParticleAdvection2.h>
 #include <vtkm/filter/Pathline.h>
+#include <vtkm/filter/Pathline2.h>
 #include <vtkm/filter/Streamline.h>
+#include <vtkm/filter/Streamline2.h>
 #include <vtkm/thirdparty/diy/diy.h>
 #include <vtkm/worklet/testing/GenerateTestDataSets.h>
 
@@ -149,13 +152,13 @@ void TestAMRStreamline(FilterType fType, bool useThreaded)
 
       if (fType == STREAMLINE)
       {
-        vtkm::filter::Streamline streamline;
+        vtkm::filter::Streamline2 streamline;
         SetFilter(streamline, stepSize, numSteps, fieldName, seedArray, useThreaded);
         out = streamline.Execute(pds);
       }
       else if (fType == PATHLINE)
       {
-        vtkm::filter::Pathline pathline;
+        vtkm::filter::Pathline2 pathline;
         SetFilter(pathline, stepSize, numSteps, fieldName, seedArray, useThreaded);
         //Create timestep 2
         auto pds2 = vtkm::cont::PartitionedDataSet(pds);
@@ -239,7 +242,7 @@ void TestAMRStreamline(FilterType fType, bool useThreaded)
     }
     else if (fType == PARTICLE_ADVECTION)
     {
-      vtkm::filter::ParticleAdvection filter;
+      vtkm::filter::ParticleAdvection2 filter;
       filter.SetUseThreadedAlgorithm(useThreaded);
       filter.SetStepSize(0.1f);
       filter.SetNumberOfSteps(100000);
@@ -283,6 +286,8 @@ void ValidateOutput(const vtkm::cont::DataSet& out,
                    "Wrong number of coordinate systems in the output dataset");
 
   vtkm::cont::UnknownCellSet dcells = out.GetCellSet();
+  out.PrintSummary(std::cout);
+  std::cout << " nSeeds= " << numSeeds << std::endl;
   VTKM_TEST_ASSERT(dcells.GetNumberOfCells() == numSeeds, "Wrong number of cells");
   auto coords = out.GetCoordinateSystem().GetDataAsMultiplexer();
   auto ptPortal = coords.ReadPortal();
@@ -392,7 +397,7 @@ void TestPartitionedDataSet(vtkm::Id nPerRank, bool useGhost, FilterType fType,
 
     if (fType == STREAMLINE)
     {
-      vtkm::filter::Streamline streamline;
+      vtkm::filter::Streamline2 streamline;
       SetFilter(streamline, stepSize, numSteps, fieldName, seedArray, useThreaded);
       auto out = streamline.Execute(pds);
 
@@ -401,7 +406,7 @@ void TestPartitionedDataSet(vtkm::Id nPerRank, bool useGhost, FilterType fType,
     }
     else if (fType == PARTICLE_ADVECTION)
     {
-      vtkm::filter::ParticleAdvection particleAdvection;
+      vtkm::filter::ParticleAdvection2 particleAdvection;
       SetFilter(particleAdvection, stepSize, numSteps, fieldName, seedArray, useThreaded);
       auto out = particleAdvection.Execute(pds);
 
@@ -419,7 +424,7 @@ void TestPartitionedDataSet(vtkm::Id nPerRank, bool useGhost, FilterType fType,
       auto pds2 = allPDS2[n];
       AddVectorFields(pds2, fieldName, vecX);
 
-      vtkm::filter::Pathline pathline;
+      vtkm::filter::Pathline2 pathline;
       SetFilter(pathline, stepSize, numSteps, fieldName, seedArray, useThreaded);
 
       pathline.SetPreviousTime(time0);

From faa938f1f0b0013a6fef2d90f70fea1f87269374 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 8 Jul 2022 08:17:01 -0400
Subject: [PATCH 014/104] add DSI.hxx to cmake.

---
 vtkm/filter/particleadvection/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/vtkm/filter/particleadvection/CMakeLists.txt b/vtkm/filter/particleadvection/CMakeLists.txt
index d5077bf2b..24f78e9d4 100644
--- a/vtkm/filter/particleadvection/CMakeLists.txt
+++ b/vtkm/filter/particleadvection/CMakeLists.txt
@@ -19,6 +19,7 @@ set(headers
   ParticleAdvectionAlgorithm.h
   ParticleMessenger.h
   DSI.h
+  DSI.hxx
   ABA.h
   PAV.h
   ParticleAdvectionTypes.h

From 3ca058816c1ed211779b60eb9861758aa1200d1a Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 8 Jul 2022 08:48:16 -0400
Subject: [PATCH 015/104] Cleanup compiler warnings.

---
 vtkm/filter/particleadvection/ABA.h   |  2 --
 vtkm/filter/particleadvection/DSI.h   | 44 +++++++++++----------------
 vtkm/filter/particleadvection/DSI.hxx |  5 ---
 vtkm/filter/particleadvection/PAV.h   |  7 -----
 4 files changed, 18 insertions(+), 40 deletions(-)

diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/ABA.h
index de96df0d1..3aaaeaefa 100644
--- a/vtkm/filter/particleadvection/ABA.h
+++ b/vtkm/filter/particleadvection/ABA.h
@@ -36,8 +36,6 @@ public:
   {
   }
 
-  void Meow(const char* func, const int& lineNum) const { this->Blocks[0]->Meow(func, lineNum); }
-
   void Execute(vtkm::Id numSteps,
                vtkm::FloatDefault stepSize,
                const vtkm::cont::ArrayHandle<ParticleType>& seeds)
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index 2f8f0c64d..a896b2a54 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -58,9 +58,9 @@ public:
     , FieldName(fieldNm)
     , Id(id)
     , SolverType(solverType)
-    , Rank(this->Comm.rank())
-    , ResType(resultType)
     , VecFieldType(vecFieldType)
+    , ResType(resultType)
+    , Rank(this->Comm.rank())
   {
     //check that things are valid.
   }
@@ -78,9 +78,9 @@ public:
     , FieldName(fieldNm)
     , Id(id)
     , SolverType(solverType)
-    , Rank(this->Comm.rank())
-    , ResType(resultType)
     , VecFieldType(vecFieldType)
+    , ResType(resultType)
+    , Rank(this->Comm.rank())
   {
     //check that things are valid.
   }
@@ -94,7 +94,6 @@ public:
     return this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>();
   }
 
-
   VTKM_CONT vtkm::Id GetID() const { return this->Id; }
   VTKM_CONT void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
 
@@ -108,8 +107,7 @@ public:
   template <typename ParticleType>
   VTKM_CONT bool GetOutput(vtkm::cont::DataSet& ds) const;
 
-  //protected:
-
+protected:
   template <typename ParticleType, template <typename> class ResultType>
   VTKM_CONT void UpdateResult(const ResultType<ParticleType>& result,
                               DSIStuff<ParticleType>& stuff);
@@ -182,23 +180,6 @@ public:
   VTKM_CONT void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
                                    DSIStuff<ParticleType>& stuff) const;
 
-  vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
-  vtkm::Id Rank;
-  vtkm::Id Id;
-  std::string FieldName;
-  vtkm::filter::particleadvection::IntegrationSolverType SolverType;
-  vtkm::filter::particleadvection::VectorFieldType VecFieldType;
-  vtkm::filter::particleadvection::ParticleAdvectionResultType ResType =
-    vtkm::filter::particleadvection::ParticleAdvectionResultType::UNKNOWN_TYPE;
-  bool CopySeedArray = false;
-
-  /*
-  struct SteadyStateDataType
-  {
-    SteadyStateDataType(const vtkm::cont::DataSet& ds) : DataSet(ds) {}
-    vtkm::cont::DataSet DataSet;
-  };
-  */
 
   using SteadyStateDataType = vtkm::cont::DataSet;
   struct UnsteadyStateDataType
@@ -219,11 +200,22 @@ public:
     vtkm::FloatDefault Time1;
     vtkm::FloatDefault Time2;
   };
-
   using DSType = vtkm::cont::internal::Variant<SteadyStateDataType, UnsteadyStateDataType>;
 
-  vtkm::cont::internal::Variant<SteadyStateDataType, UnsteadyStateDataType> Data;
 
+  //Data members.
+  vtkm::cont::internal::Variant<SteadyStateDataType, UnsteadyStateDataType> Data;
+  std::string FieldName;
+  vtkm::Id Id;
+  vtkm::filter::particleadvection::IntegrationSolverType SolverType;
+  vtkm::filter::particleadvection::VectorFieldType VecFieldType;
+  vtkm::filter::particleadvection::ParticleAdvectionResultType ResType =
+    vtkm::filter::particleadvection::ParticleAdvectionResultType::UNKNOWN_TYPE;
+
+  vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
+  vtkm::Id Rank;
+
+  bool CopySeedArray = false;
 
   using RType =
     vtkm::cont::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index 746795f54..cddfe2dfb 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -55,7 +55,6 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
   if (nResults == 0)
     return false;
 
-
   std::cout << "Check the variant type!" << std::endl;
 
   if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
@@ -171,8 +170,6 @@ VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
 {
   this->ClassifyParticles(result.Particles, stuff);
 
-  //this->Meow(__PRETTY_FUNCTION__, __LINE__);
-
   //template this for PA and SL
   if (this->ResType ==
       vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
@@ -195,8 +192,6 @@ VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
   {
     this->Results.push_back(result);
   }
-
-  //this->Meow(__PRETTY_FUNCTION__, __LINE__);
 }
 
 template <typename ParticleType>
diff --git a/vtkm/filter/particleadvection/PAV.h b/vtkm/filter/particleadvection/PAV.h
index 7f1827634..f61fb5089 100644
--- a/vtkm/filter/particleadvection/PAV.h
+++ b/vtkm/filter/particleadvection/PAV.h
@@ -69,13 +69,6 @@ private:
 
         AlgorithmType algo(this->BoundsMap, this->Blocks);
         algo.Execute(numSteps, stepSize, seeds);
-        algo.Meow(__PRETTY_FUNCTION__, __LINE__);
-
-        //std::cout<<__FILE__<<" "<<__LINE__<<std::endl;
-        //using RType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
-        //auto p0 = this->Blocks[0].Results[0].Get<RType>().Particles.ReadPortal().Get(0);
-        //std::cout<<__FILE__<<" "<<__LINE__<<" pt= "<<p0.Pos<<std::endl;
-
         return algo.GetOutput();
       }
       else

From be813f7e4b46bd331ec85d49c7eb176f97beacfc Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 8 Jul 2022 10:39:17 -0400
Subject: [PATCH 016/104] write the electro-mag code.

---
 vtkm/filter/particleadvection/DSI.h | 112 ++++++++++++++++++++--------
 1 file changed, 79 insertions(+), 33 deletions(-)

diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index a896b2a54..ccc55e4d7 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -47,15 +47,21 @@ struct DSIStuff
 
 class DSI
 {
+  using VelocityFieldNameType = std::string;
+  using ElectroMagneticFieldNameType = std::pair<std::string, std::string>;
+  using FieldNameType =
+    vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType>;
+
+
 public:
   DSI(const vtkm::cont::DataSet& ds,
       vtkm::Id id,
-      const std::string& fieldNm,
+      const FieldNameType& fieldName,
       vtkm::filter::particleadvection::IntegrationSolverType solverType,
       vtkm::filter::particleadvection::VectorFieldType vecFieldType,
       vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
     : Data(ds)
-    , FieldName(fieldNm)
+    , FieldName(fieldName)
     , Id(id)
     , SolverType(solverType)
     , VecFieldType(vecFieldType)
@@ -70,7 +76,8 @@ public:
       vtkm::FloatDefault t1,
       vtkm::FloatDefault t2,
       vtkm::Id id,
-      const std::string& fieldNm,
+      const vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType>&
+        fieldNm,
       vtkm::filter::particleadvection::IntegrationSolverType solverType,
       vtkm::filter::particleadvection::VectorFieldType vecFieldType,
       vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
@@ -116,9 +123,14 @@ protected:
   VTKM_CONT void GetSteadyStateVelocityField(
     vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
   {
-    VTKM_ASSERT(this->Data.GetIndex() == this->Data.GetIndexOf<SteadyStateDataType>());
-    const auto& data = this->Data.Get<SteadyStateDataType>();
-    this->GetVelocityField(data, velocityField);
+    if (this->Data.GetIndex() == this->Data.GetIndexOf<SteadyStateDataType>())
+    {
+      const auto& ds = this->Data.Get<SteadyStateDataType>();
+      this->GetVelocityField(ds, velocityField);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution(
+        "Steady state velocity field vector type not available");
   }
 
   template <typename ArrayType>
@@ -126,10 +138,15 @@ protected:
     vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField1,
     vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField2) const
   {
-    VTKM_ASSERT(this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>());
-    const auto& data = this->Data.Get<UnsteadyStateDataType>();
-    this->GetVelocityField(data.DataSet1, velocityField1);
-    this->GetVelocityField(data.DataSet2, velocityField2);
+    if (this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>())
+    {
+      const auto& data = this->Data.Get<UnsteadyStateDataType>();
+      this->GetVelocityField(data.DataSet1, velocityField1);
+      this->GetVelocityField(data.DataSet2, velocityField2);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution(
+        "Unsteady state velocity field vector type not available");
   }
 
   template <typename ArrayType>
@@ -137,26 +154,55 @@ protected:
     const vtkm::cont::DataSet& ds,
     vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
   {
-    auto assoc = ds.GetField(this->FieldName).GetAssociation();
-    ArrayType arr;
-    vtkm::cont::ArrayCopyShallowIfPossible(ds.GetField(this->FieldName).GetData(), arr);
+    if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<VelocityFieldNameType>())
+    {
+      const auto& fieldNm = this->FieldName.Get<VelocityFieldNameType>();
+      auto assoc = ds.GetField(fieldNm).GetAssociation();
+      ArrayType arr;
+      vtkm::cont::ArrayCopyShallowIfPossible(ds.GetField(fieldNm).GetData(), arr);
 
-    velocityField = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr, assoc);
+      velocityField = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr, assoc);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
+  }
+
+  template <typename ArrayType>
+  VTKM_CONT void GetElectroMagneticField(
+    const vtkm::cont::DataSet& ds,
+    vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& elecMagField) const
+  {
+    if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<ElectroMagneticFieldNameType>())
+    {
+      const auto& fieldNms = this->FieldName.Get<ElectroMagneticFieldNameType>();
+      auto assoc1 = ds.GetField(fieldNms.first).GetAssociation();
+      auto assoc2 = ds.GetField(fieldNms.second).GetAssociation();
+      if (assoc1 != assoc2)
+        throw vtkm::cont::ErrorFilterExecution(
+          "Electro-magnetic vector fields have differing associations");
+
+      ArrayType arr1, arr2;
+      vtkm::cont::ArrayCopyShallowIfPossible(ds.GetField(fieldNms.first).GetData(), arr1);
+      vtkm::cont::ArrayCopyShallowIfPossible(ds.GetField(fieldNms.second).GetData(), arr2);
+
+      elecMagField =
+        vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>(arr1, arr2, assoc1);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
   }
 
   template <typename ArrayType>
   VTKM_CONT void GetSteadyStateElectroMagneticField(
     vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& elecMagField) const
   {
-    std::cout << "FIX ME: need fieldname2" << std::endl;
-    /*
-    ArrayType arr1, arr2;
-    vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(), arr1);
-    vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(this->FieldName).GetData(), arr2);       //fieldname 2
-    auto assoc = this->DataSet.GetField(this->FieldName).GetAssociation();
-
-    elecMagField = vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>(arr1, arr2, assoc);
-    */
+    if (this->Data.GetIndex() == this->Data.GetIndexOf<SteadyStateDataType>())
+    {
+      const auto& ds = this->Data.Get<SteadyStateDataType>();
+      this->GetElectroMagneticField(ds, elecMagField);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Electro-magnetic vector field type not available");
   }
 
   template <typename ArrayType>
@@ -164,13 +210,14 @@ protected:
     vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& emField1,
     vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& emField2) const
   {
-    std::cout << "FIX ME: need fieldname2" << std::endl;
-    /*
-    VTKM_ASSERT(this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>());
-    const auto& data = this->Data.Get<UnsteadyStateDataType>();
-    this->GetSteadyStateElectroMagneticField(data.DataSet1, emField1);
-    this->GetSteadyStateElectroMagneticField(data.DataSet2, emField2);
-    */
+    if (this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>())
+    {
+      this->GetSteadyStateElectroMagneticField(emField1);
+      this->GetSteadyStateElectroMagneticField(emField2);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution(
+        "Unsteady state electro-magnetic field vector type not available");
   }
 
   //template <typename ParticleType>
@@ -200,12 +247,11 @@ protected:
     vtkm::FloatDefault Time1;
     vtkm::FloatDefault Time2;
   };
-  using DSType = vtkm::cont::internal::Variant<SteadyStateDataType, UnsteadyStateDataType>;
-
 
   //Data members.
   vtkm::cont::internal::Variant<SteadyStateDataType, UnsteadyStateDataType> Data;
-  std::string FieldName;
+  vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType> FieldName;
+
   vtkm::Id Id;
   vtkm::filter::particleadvection::IntegrationSolverType SolverType;
   vtkm::filter::particleadvection::VectorFieldType VecFieldType;

From 8b375b4443c19a4865832007e27ef4d329ca3a42 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 14 Jul 2022 12:02:10 -0400
Subject: [PATCH 017/104] Rework the templating..

---
 vtkm/filter/ParticleAdvection2.hxx    |   2 +-
 vtkm/filter/PathParticle2.hxx         |   5 +-
 vtkm/filter/Pathline2.hxx             |   5 +-
 vtkm/filter/Streamline2.hxx           |   2 +-
 vtkm/filter/particleadvection/ABA.h   |  13 +
 vtkm/filter/particleadvection/DSI.h   | 271 ++++++++--
 vtkm/filter/particleadvection/DSI.hxx | 720 ++++++++++++++++++++++----
 7 files changed, 867 insertions(+), 151 deletions(-)

diff --git a/vtkm/filter/ParticleAdvection2.hxx b/vtkm/filter/ParticleAdvection2.hxx
index 39142c97f..583120454 100644
--- a/vtkm/filter/ParticleAdvection2.hxx
+++ b/vtkm/filter/ParticleAdvection2.hxx
@@ -42,7 +42,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForEx
   //  return input;
 
 #if 1
-  using DSIType = vtkm::filter::particleadvection::DSI;
+  using DSIType = vtkm::filter::particleadvection::SteadyStateDSI;
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
diff --git a/vtkm/filter/PathParticle2.hxx b/vtkm/filter/PathParticle2.hxx
index c1ac92223..03886cbdb 100644
--- a/vtkm/filter/PathParticle2.hxx
+++ b/vtkm/filter/PathParticle2.hxx
@@ -39,7 +39,9 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle2::PrepareForExecuti
   const vtkm::cont::PartitionedDataSet& input,
   const vtkm::filter::PolicyBase<DerivedPolicy>&)
 {
-  using DSIType = vtkm::filter::particleadvection::DSI;
+//  return input;
+#if 1
+  using DSIType = vtkm::filter::particleadvection::UnsteadyStateDSI;
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
@@ -73,6 +75,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle2::PrepareForExecuti
   vtkm::filter::particleadvection::PAV<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
+#endif
 }
 
 VTKM_CONT vtkm::cont::DataSet PathParticle3::DoExecute(const vtkm::cont::DataSet& inData)
diff --git a/vtkm/filter/Pathline2.hxx b/vtkm/filter/Pathline2.hxx
index 8853ff6b7..f5e0c7928 100644
--- a/vtkm/filter/Pathline2.hxx
+++ b/vtkm/filter/Pathline2.hxx
@@ -38,7 +38,9 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Pathline2::PrepareForExecution(
   const vtkm::cont::PartitionedDataSet& input,
   const vtkm::filter::PolicyBase<DerivedPolicy>&)
 {
-  using DSIType = vtkm::filter::particleadvection::DSI;
+//  return input;
+#if 1
+  using DSIType = vtkm::filter::particleadvection::UnsteadyStateDSI;
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
@@ -72,6 +74,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Pathline2::PrepareForExecution(
   vtkm::filter::particleadvection::PAV<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
+#endif
 }
 
 VTKM_CONT vtkm::cont::DataSet Pathline3::DoExecute(const vtkm::cont::DataSet& inData)
diff --git a/vtkm/filter/Streamline2.hxx b/vtkm/filter/Streamline2.hxx
index 73256a4f0..94c417a78 100644
--- a/vtkm/filter/Streamline2.hxx
+++ b/vtkm/filter/Streamline2.hxx
@@ -41,7 +41,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Streamline2::PrepareForExecution
   //  return input;
 
 #if 1
-  using DSIType = vtkm::filter::particleadvection::DSI;
+  using DSIType = vtkm::filter::particleadvection::SteadyStateDSI;
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/ABA.h
index 3aaaeaefa..68dfd65d0 100644
--- a/vtkm/filter/particleadvection/ABA.h
+++ b/vtkm/filter/particleadvection/ABA.h
@@ -114,10 +114,23 @@ public:
       {
         //make this a pointer to avoid the copy?
         auto block = this->GetDataSet(blockId);
+
+        /*
         DSIStuff<ParticleType> stuff(this->BoundsMap, this->ParticleBlockIDsMap);
         block->Advect(v, this->StepSize, this->NumberOfSteps, stuff);
         numTerm = this->UpdateResult(stuff);
         std::cout << " Advect: " << v.size() << " NT= " << numTerm << std::endl;
+        */
+
+
+        //DSIStuff<ParticleType> b(v, this->BoundsMap, this->ParticleBlockIDsMap);
+        //DSIStuffType bb = b;
+        DSIStuffType bb = DSIStuff<ParticleType>(v, this->BoundsMap, this->ParticleBlockIDsMap);
+        block->ADVECT(bb, this->StepSize, this->NumberOfSteps);
+
+        //DSIStuff<ParticleType> bbb = bb.Get<DSIStuff<ParticleType>>();
+        numTerm = this->UpdateResult(bb.Get<DSIStuff<ParticleType>>());
+        std::cout << " Advect: " << v.size() << " NT= " << numTerm << std::endl;
       }
 
       vtkm::Id numTermMessages = 0;
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index ccc55e4d7..6121bd48a 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -28,6 +28,32 @@ namespace filter
 namespace particleadvection
 {
 
+template <typename ParticleType>
+class DSIStuff
+{
+public:
+  DSIStuff(const std::vector<ParticleType>& v,
+           const vtkm::filter::particleadvection::BoundsMap& boundsMap,
+           const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& particleBlockIDsMap)
+    : BoundsMap(boundsMap)
+    , ParticleBlockIDsMap(particleBlockIDsMap)
+    , V(v)
+  {
+  }
+
+  std::vector<ParticleType> V, A, I;
+  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> IdMapA, IdMapI;
+  std::vector<vtkm::Id> TermIdx, TermID;
+  const vtkm::filter::particleadvection::BoundsMap BoundsMap;
+  const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
+};
+
+using DSIStuffP = DSIStuff<vtkm::Particle>;
+using DSIStuffCP = DSIStuff<vtkm::ChargedParticle>;
+using DSIStuffType =
+  vtkm::cont::internal::Variant<DSIStuff<vtkm::Particle>, DSIStuff<vtkm::ChargedParticle>>;
+
+/*
 template <typename ParticleType>
 struct DSIStuff
 {
@@ -38,51 +64,52 @@ struct DSIStuff
   {
   }
 
+  DSIStuff(const std::vector<ParticleType>& v,
+           const vtkm::filter::particleadvection::BoundsMap& boundsMap,
+           const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& particleBlockIDsMap)
+    : BoundsMap(boundsMap)
+    , ParticleBlockIDsMap(particleBlockIDsMap)
+    , V(v)
+  {
+  }
+
+  std::vector<ParticleType> V;
   std::vector<ParticleType> A, I;
   std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> IdMapA, IdMapI;
   std::vector<vtkm::Id> TermIdx, TermID;
   const vtkm::filter::particleadvection::BoundsMap BoundsMap;
   const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
 };
+*/
+
 
 class DSI
 {
+protected:
   using VelocityFieldNameType = std::string;
   using ElectroMagneticFieldNameType = std::pair<std::string, std::string>;
   using FieldNameType =
     vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType>;
 
+  using SType =
+    vtkm::cont::internal::Variant<DSIStuff<vtkm::Particle>, DSIStuff<vtkm::ChargedParticle>>;
+  using PType =
+    vtkm::cont::internal::Variant<std::vector<vtkm::Particle>, std::vector<vtkm::ChargedParticle>>;
+  using RType =
+    vtkm::cont::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
+                                  vtkm::worklet::ParticleAdvectionResult<vtkm::ChargedParticle>,
+                                  vtkm::worklet::StreamlineResult<vtkm::Particle>,
+                                  vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
+
+
 
 public:
-  DSI(const vtkm::cont::DataSet& ds,
-      vtkm::Id id,
+  DSI(vtkm::Id id,
       const FieldNameType& fieldName,
       vtkm::filter::particleadvection::IntegrationSolverType solverType,
       vtkm::filter::particleadvection::VectorFieldType vecFieldType,
       vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
-    : Data(ds)
-    , FieldName(fieldName)
-    , Id(id)
-    , SolverType(solverType)
-    , VecFieldType(vecFieldType)
-    , ResType(resultType)
-    , Rank(this->Comm.rank())
-  {
-    //check that things are valid.
-  }
-
-  DSI(const vtkm::cont::DataSet& ds1,
-      const vtkm::cont::DataSet& ds2,
-      vtkm::FloatDefault t1,
-      vtkm::FloatDefault t2,
-      vtkm::Id id,
-      const vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType>&
-        fieldNm,
-      vtkm::filter::particleadvection::IntegrationSolverType solverType,
-      vtkm::filter::particleadvection::VectorFieldType vecFieldType,
-      vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
-    : Data(UnsteadyStateDataType(ds1, ds2, t1, t2))
-    , FieldName(fieldNm)
+    : FieldName(fieldName)
     , Id(id)
     , SolverType(solverType)
     , VecFieldType(vecFieldType)
@@ -92,6 +119,7 @@ public:
     //check that things are valid.
   }
 
+  /*
   VTKM_CONT bool IsSteadyState() const
   {
     return this->Data.GetIndex() == this->Data.GetIndexOf<SteadyStateDataType>();
@@ -100,25 +128,89 @@ public:
   {
     return this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>();
   }
+  */
 
   VTKM_CONT vtkm::Id GetID() const { return this->Id; }
   VTKM_CONT void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
 
 
+  /*
   template <typename ParticleType>
   VTKM_CONT void Advect(std::vector<ParticleType>& v,
                         vtkm::FloatDefault stepSize, //move these to member data(?)
                         vtkm::Id maxSteps,
                         DSIStuff<ParticleType>& stuff);
 
+  template <template <typename> class ResultType, typename ParticleType>
+  VTKM_CONT void
+  BumHole(ResultType<ParticleType>& result)
+  {
+    std::cout<<"bumhole"<<std::endl;
+  }
+  */
+
+  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::Particle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) = 0;
+
+  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::ChargedParticle>& b,
+                                  vtkm::FloatDefault stepSize, //move these to member data(?)
+                                  vtkm::Id maxSteps) = 0;
+
+  VTKM_CONT
+  virtual void ADVECT(DSIStuffType& b,
+                      vtkm::FloatDefault stepSize, //move these to member data(?)
+                      vtkm::Id maxSteps)
+  {
+    if (b.GetIndex() == b.GetIndexOf<DSIStuff<vtkm::Particle>>())
+    {
+      auto& bb = b.Get<DSIStuff<vtkm::Particle>>();
+      this->DoAdvect(bb, stepSize, maxSteps);
+    }
+    else if (b.GetIndex() == b.GetIndexOf<DSIStuff<vtkm::ChargedParticle>>())
+    {
+      auto& bb = b.Get<DSIStuff<vtkm::ChargedParticle>>();
+      this->DoAdvect(bb, stepSize, maxSteps);
+    }
+
+    //b.CastAndCall([&] (auto& concrete) { this->DoAdvect(concrete, stepSize, maxSteps); });
+
+    /*
+    if (b.GetIndex() == b.GetIndexOf<BumP>())
+    {
+      std::cout<<"It's a particle!"<<std::endl;
+      auto bb = b.Get<BumP>();
+    }
+    else if (b.GetIndex() == b.GetIndexOf<BumC>())
+    {
+      std::cout<<"It's a CHARGED particle!"<<std::endl;
+      auto bb = b.Get<BumC>();
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Steady state velocity field vector type not available");
+    */
+  }
+
+  /*
+  VTKM_CONT
+  virtual void DoADVECT(std::vector<PType>& v,
+                        vtkm::FloatDefault stepSize,
+                        vtkm::Id maxSteps,
+                        SType& stuff)
+  {
+  }
+  */
+
   template <typename ParticleType>
   VTKM_CONT bool GetOutput(vtkm::cont::DataSet& ds) const;
 
+
 protected:
   template <typename ParticleType, template <typename> class ResultType>
   VTKM_CONT void UpdateResult(const ResultType<ParticleType>& result,
                               DSIStuff<ParticleType>& stuff);
 
+  /*
   template <typename ArrayType>
   VTKM_CONT void GetSteadyStateVelocityField(
     vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
@@ -129,8 +221,7 @@ protected:
       this->GetVelocityField(ds, velocityField);
     }
     else
-      throw vtkm::cont::ErrorFilterExecution(
-        "Steady state velocity field vector type not available");
+      throw vtkm::cont::ErrorFilterExecution("Steady state velocity field vector type not available");
   }
 
   template <typename ArrayType>
@@ -145,9 +236,9 @@ protected:
       this->GetVelocityField(data.DataSet2, velocityField2);
     }
     else
-      throw vtkm::cont::ErrorFilterExecution(
-        "Unsteady state velocity field vector type not available");
+      throw vtkm::cont::ErrorFilterExecution("Unsteady state velocity field vector type not available");
   }
+  */
 
   template <typename ArrayType>
   VTKM_CONT void GetVelocityField(
@@ -192,6 +283,7 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
   }
 
+  /*
   template <typename ArrayType>
   VTKM_CONT void GetSteadyStateElectroMagneticField(
     vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& elecMagField) const
@@ -216,9 +308,9 @@ protected:
       this->GetSteadyStateElectroMagneticField(emField2);
     }
     else
-      throw vtkm::cont::ErrorFilterExecution(
-        "Unsteady state electro-magnetic field vector type not available");
+      throw vtkm::cont::ErrorFilterExecution("Unsteady state electro-magnetic field vector type not available");
   }
+  */
 
   //template <typename ParticleType>
   void Meow(const char* func, const int& lineNum) const;
@@ -227,7 +319,7 @@ protected:
   VTKM_CONT void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
                                    DSIStuff<ParticleType>& stuff) const;
 
-
+  /*
   using SteadyStateDataType = vtkm::cont::DataSet;
   struct UnsteadyStateDataType
   {
@@ -247,9 +339,10 @@ protected:
     vtkm::FloatDefault Time1;
     vtkm::FloatDefault Time2;
   };
+*/
 
   //Data members.
-  vtkm::cont::internal::Variant<SteadyStateDataType, UnsteadyStateDataType> Data;
+  //  vtkm::cont::internal::Variant<SteadyStateDataType, UnsteadyStateDataType> Data;
   vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType> FieldName;
 
   vtkm::Id Id;
@@ -260,18 +353,116 @@ protected:
 
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
   vtkm::Id Rank;
-
   bool CopySeedArray = false;
-
-  using RType =
-    vtkm::cont::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
-                                  vtkm::worklet::ParticleAdvectionResult<vtkm::ChargedParticle>,
-                                  vtkm::worklet::StreamlineResult<vtkm::Particle>,
-                                  vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
   std::vector<RType> Results;
 };
 
 
+class SteadyStateDSI : public DSI
+{
+public:
+  SteadyStateDSI(const vtkm::cont::DataSet& ds,
+                 vtkm::Id id,
+                 const FieldNameType& fieldName,
+                 vtkm::filter::particleadvection::IntegrationSolverType solverType,
+                 vtkm::filter::particleadvection::VectorFieldType vecFieldType,
+                 vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
+    : DSI(id, fieldName, solverType, vecFieldType, resultType)
+    , DataSet(ds)
+  {
+  }
+
+  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::Particle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) override;
+
+  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::ChargedParticle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) override;
+
+protected:
+  template <typename ArrayType>
+  VTKM_CONT void GetVelocityField(
+    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
+  {
+    if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<VelocityFieldNameType>())
+    {
+      const auto& fieldNm = this->FieldName.Get<VelocityFieldNameType>();
+      auto assoc = this->DataSet.GetField(fieldNm).GetAssociation();
+      ArrayType arr;
+      vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(fieldNm).GetData(), arr);
+
+      velocityField = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr, assoc);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
+  }
+
+
+private:
+  vtkm::cont::DataSet DataSet;
+};
+
+class UnsteadyStateDSI : public DSI
+{
+public:
+  UnsteadyStateDSI(const vtkm::cont::DataSet& ds1,
+                   const vtkm::cont::DataSet& ds2,
+                   vtkm::FloatDefault t1,
+                   vtkm::FloatDefault t2,
+                   vtkm::Id id,
+                   const FieldNameType& fieldName,
+                   vtkm::filter::particleadvection::IntegrationSolverType solverType,
+                   vtkm::filter::particleadvection::VectorFieldType vecFieldType,
+                   vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
+    : DSI(id, fieldName, solverType, vecFieldType, resultType)
+    , DataSet1(ds1)
+    , DataSet2(ds2)
+    , Time1(t1)
+    , Time2(t2)
+  {
+  }
+
+  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::Particle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) override;
+
+  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::ChargedParticle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) override;
+
+protected:
+  template <typename ArrayType>
+  VTKM_CONT void GetVelocityFields(
+    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField1,
+    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField2) const
+  {
+    if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<VelocityFieldNameType>())
+    {
+      const auto& fieldNm = this->FieldName.Get<VelocityFieldNameType>();
+      auto assoc = this->DataSet1.GetField(fieldNm).GetAssociation();
+      if (assoc != this->DataSet2.GetField(fieldNm).GetAssociation())
+        throw vtkm::cont::ErrorFilterExecution(
+          "Unsteady state velocity fields have differnt associations");
+
+      ArrayType arr1, arr2;
+      vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet1.GetField(fieldNm).GetData(), arr1);
+      vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet2.GetField(fieldNm).GetData(), arr2);
+
+      velocityField1 = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr1, assoc);
+      velocityField2 = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr2, assoc);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
+  }
+
+private:
+  vtkm::cont::DataSet DataSet1;
+  vtkm::cont::DataSet DataSet2;
+  vtkm::FloatDefault Time1;
+  vtkm::FloatDefault Time2;
+};
+
 }
 }
 }
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index cddfe2dfb..28cda5e73 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -18,6 +18,67 @@ namespace filter
 namespace particleadvection
 {
 
+#if 0
+namespace internal
+{
+using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+using SteadyStateGridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+using UnSteadyStateGridEvalType =
+  vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
+
+template <typename GridEvalType,
+          typename WorkletType,
+          template <typename> class ResultType,
+          typename ParticleType>
+class AdvectHelper;
+
+ //Steady state
+template <typename WorkletType, template <typename> class ResultType, typename ParticleType>
+class AdvectHelper<SteadyStateGridEvalType, WorkletType, ResultType, ParticleType>
+{
+public:
+  static void Advect(const FieldType& velField,
+                     const vtkm::cont::DataSet& ds,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& integratorType,
+                     ResultType<ParticleType>& result)
+  {
+    using AHType =
+      internal::AdvectHelper<SteadyStateGridEvalType, WorkletType, ResultType, ParticleType>;
+    if (integratorType == IntegrationSolverType::RK4_TYPE)
+      AHType::template DoAdvect<vtkm::worklet::particleadvection::RK4Integrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    else if (integratorType == IntegrationSolverType::EULER_TYPE)
+      AHType::template DoAdvect<vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  template <template <typename> class IntType>
+  static void DoAdvect(const FieldType& velField,
+                       const vtkm::cont::DataSet& ds,
+                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                       vtkm::FloatDefault stepSize,
+                       vtkm::Id maxSteps,
+                       ResultType<ParticleType>& result)
+  {
+    using StepperType = vtkm::worklet::particleadvection::Stepper<IntType<SteadyStateGridEvalType>,
+                                                                  SteadyStateGridEvalType>;
+    SteadyStateGridEvalType eval(ds, velField);
+    StepperType stepper(eval, stepSize);
+    WorkletType worklet;
+    result = worklet.Run(stepper, seedArray, maxSteps);
+  }
+
+
+};
+
+}
+
 void DSI::Meow(const char* func, const int& lineNum) const
 {
   if (this->Results.empty())
@@ -164,120 +225,53 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
   return true;
 }
 
-template <typename ParticleType, template <typename> class ResultType>
-VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
-                                 DSIStuff<ParticleType>& stuff)
+void DSI::DoAdvect(Bum<vtkm::Particle>& b,
+                   vtkm::FloatDefault stepSize,
+                   vtkm::Id maxSteps)
 {
-  this->ClassifyParticles(result.Particles, stuff);
+  using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
 
-  //template this for PA and SL
-  if (this->ResType ==
-      vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
   {
-    if (stuff.TermIdx.empty())
-      return;
+    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+    FieldType velField;
+    this->GetSteadyStateVelocityField(velField);
 
-    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
-    auto indicesAH = vtkm::cont::make_ArrayHandle(stuff.TermIdx, vtkm::CopyFlag::Off);
-    auto termPerm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, result.Particles);
-
-    vtkm::cont::ArrayHandle<ParticleType> termParticles;
-    vtkm::cont::Algorithm::Copy(termPerm, termParticles);
-
-    ResType termRes(termParticles);
-    this->Results.push_back(termRes);
-  }
-  else if (this->ResType ==
-           vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
-  {
-    this->Results.push_back(result);
+    if (this->ResType == ParticleAdectionResultType::PARTICLE_ADVECT_TYPE)
+    {
+      using AHType = internal::AdvectHelper<GridEvType,
+                                            vtkm::worklet::ParticleAdvection,
+                                            vtkm::worklet::ParticleAdvectionResult,
+                                            vtkm::Particle>;
+      AHType::Advect(result);
+    }
+    else if (this->ResType == ParticleAdectionResultType::STREAMLINE_TYPE)
+    {
+    }
   }
+    std::cout<<"***************************************************************        DSI::DoAdvect --------- Particle"<<std::endl;
+    using FieldType = vtkm::worklet::particleadvection::VelocityField<internal::ArrayType>;
+    using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+    using AHType = internal::AdvectHelper<GridEvType,
+                                          vtkm::worklet::ParticleAdvection,
+                                          vtkm::worklet::ParticleAdvectionResult,
+                                          vtkm::Particle>;
+
+    auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
+    auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
+
+    const auto& data = this->Data.Get<vtkm::cont::DataSet>();
+    FieldType velField;
+    this->GetSteadyStateVelocityField(velField);
+    vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
+    AHType::Advect(velField, data, seedArray, stepSize, maxSteps, this->SolverType, result);
+    //this->UpdateResult(result, stuff);
 }
 
-template <typename ParticleType>
-VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
-                                      DSIStuff<ParticleType>& stuff) const
+void DSI::DoAdvect(Bum<vtkm::ChargedParticle>& b,
+                   vtkm::FloatDefault stepSize,
+                   vtkm::Id maxSteps)
 {
-  stuff.A.clear();
-  stuff.I.clear();
-  stuff.TermID.clear();
-  stuff.TermIdx.clear();
-  stuff.IdMapI.clear();
-  stuff.IdMapA.clear();
-
-  auto portal = particles.WritePortal();
-  vtkm::Id n = portal.GetNumberOfValues();
-
-  for (vtkm::Id i = 0; i < n; i++)
-  {
-    auto p = portal.Get(i);
-    std::cout << "****** ClassifyParticles: " << p.Pos << " ID= " << p.ID << std::endl;
-
-    if (p.Status.CheckTerminate())
-    {
-      stuff.TermIdx.push_back(i);
-      stuff.TermID.push_back(p.ID);
-    }
-    else
-    {
-      const auto& it = stuff.ParticleBlockIDsMap.find(p.ID);
-      VTKM_ASSERT(it != stuff.ParticleBlockIDsMap.end());
-      auto currBIDs = it->second;
-      VTKM_ASSERT(!currBIDs.empty());
-
-      std::vector<vtkm::Id> newIDs;
-      if (p.Status.CheckSpatialBounds() && !p.Status.CheckTookAnySteps())
-        newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
-      else
-        newIDs = stuff.BoundsMap.FindBlocks(p.Pos, currBIDs);
-
-      //reset the particle status.
-      p.Status = vtkm::ParticleStatus();
-
-      if (newIDs.empty()) //No blocks, we're done.
-      {
-        p.Status.SetTerminate();
-        stuff.TermIdx.push_back(i);
-        stuff.TermID.push_back(p.ID);
-      }
-      else
-      {
-        //If we have more than blockId, we want to minimize communication
-        //and put any blocks owned by this rank first.
-        if (newIDs.size() > 1)
-        {
-          for (auto idit = newIDs.begin(); idit != newIDs.end(); idit++)
-          {
-            vtkm::Id bid = *idit;
-            if (stuff.BoundsMap.FindRank(bid) == this->Rank)
-            {
-              newIDs.erase(idit);
-              newIDs.insert(newIDs.begin(), bid);
-              break;
-            }
-          }
-        }
-
-        int dstRank = stuff.BoundsMap.FindRank(newIDs[0]);
-        if (dstRank == this->Rank)
-        {
-          stuff.A.push_back(p);
-          stuff.IdMapA[p.ID] = newIDs;
-        }
-        else
-        {
-          stuff.I.push_back(p);
-          stuff.IdMapI[p.ID] = newIDs;
-        }
-      }
-      portal.Set(i, p);
-    }
-  }
-
-  //Make sure we didn't miss anything. Every particle goes into a single bucket.
-  VTKM_ASSERT(static_cast<std::size_t>(n) ==
-              (stuff.A.size() + stuff.I.size() + stuff.TermIdx.size()));
-  VTKM_ASSERT(stuff.TermIdx.size() == stuff.TermID.size());
 }
 
 template <typename ParticleType>
@@ -286,7 +280,6 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
                            vtkm::Id maxSteps,
                            DSIStuff<ParticleType>& stuff)
 {
-
   //using Association = vtkm::cont::Field::Association;
   using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
 
@@ -502,6 +495,519 @@ VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
     throw vtkm::cont::ErrorFilterExecution("Unsupported Data Type in DSI");
 }
 
+#endif
+
+template <typename ParticleType, template <typename> class ResultType>
+VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
+                                 DSIStuff<ParticleType>& stuff)
+{
+  this->ClassifyParticles(result.Particles, stuff);
+  std::cout << "DSI::UpdateResult  TermIdx= " << stuff.TermIdx.size() << std::endl;
+
+  //template this for PA and SL
+  if (this->ResType ==
+      vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+  {
+    if (stuff.TermIdx.empty())
+      return;
+
+    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+    auto indicesAH = vtkm::cont::make_ArrayHandle(stuff.TermIdx, vtkm::CopyFlag::Off);
+    auto termPerm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, result.Particles);
+
+    vtkm::cont::ArrayHandle<ParticleType> termParticles;
+    vtkm::cont::Algorithm::Copy(termPerm, termParticles);
+
+    ResType termRes(termParticles);
+    this->Results.push_back(termRes);
+  }
+  else if (this->ResType ==
+           vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
+  {
+    this->Results.push_back(result);
+  }
+}
+
+template <typename ParticleType>
+VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
+                                      DSIStuff<ParticleType>& stuff) const
+{
+  stuff.A.clear();
+  stuff.I.clear();
+  stuff.TermID.clear();
+  stuff.TermIdx.clear();
+  stuff.IdMapI.clear();
+  stuff.IdMapA.clear();
+
+  auto portal = particles.WritePortal();
+  vtkm::Id n = portal.GetNumberOfValues();
+
+  for (vtkm::Id i = 0; i < n; i++)
+  {
+    auto p = portal.Get(i);
+    std::cout << "****** ClassifyParticles: " << p.Pos << " ID= " << p.ID << std::endl;
+
+    if (p.Status.CheckTerminate())
+    {
+      stuff.TermIdx.push_back(i);
+      stuff.TermID.push_back(p.ID);
+    }
+    else
+    {
+      const auto& it = stuff.ParticleBlockIDsMap.find(p.ID);
+      VTKM_ASSERT(it != stuff.ParticleBlockIDsMap.end());
+      auto currBIDs = it->second;
+      VTKM_ASSERT(!currBIDs.empty());
+
+      std::vector<vtkm::Id> newIDs;
+      if (p.Status.CheckSpatialBounds() && !p.Status.CheckTookAnySteps())
+        newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
+      else
+        newIDs = stuff.BoundsMap.FindBlocks(p.Pos, currBIDs);
+
+      //reset the particle status.
+      p.Status = vtkm::ParticleStatus();
+
+      if (newIDs.empty()) //No blocks, we're done.
+      {
+        p.Status.SetTerminate();
+        stuff.TermIdx.push_back(i);
+        stuff.TermID.push_back(p.ID);
+      }
+      else
+      {
+        //If we have more than blockId, we want to minimize communication
+        //and put any blocks owned by this rank first.
+        if (newIDs.size() > 1)
+        {
+          for (auto idit = newIDs.begin(); idit != newIDs.end(); idit++)
+          {
+            vtkm::Id bid = *idit;
+            if (stuff.BoundsMap.FindRank(bid) == this->Rank)
+            {
+              newIDs.erase(idit);
+              newIDs.insert(newIDs.begin(), bid);
+              break;
+            }
+          }
+        }
+
+        int dstRank = stuff.BoundsMap.FindRank(newIDs[0]);
+        if (dstRank == this->Rank)
+        {
+          stuff.A.push_back(p);
+          stuff.IdMapA[p.ID] = newIDs;
+        }
+        else
+        {
+          stuff.I.push_back(p);
+          stuff.IdMapI[p.ID] = newIDs;
+        }
+      }
+      portal.Set(i, p);
+    }
+  }
+
+  //Make sure we didn't miss anything. Every particle goes into a single bucket.
+  VTKM_ASSERT(static_cast<std::size_t>(n) ==
+              (stuff.A.size() + stuff.I.size() + stuff.TermIdx.size()));
+  VTKM_ASSERT(stuff.TermIdx.size() == stuff.TermID.size());
+}
+
+template <typename ParticleType>
+VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
+{
+  std::size_t nResults = this->Results.size();
+  if (nResults == 0)
+    return false;
+
+  std::cout << "Check the variant type!" << std::endl;
+
+  if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+  {
+    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+
+    std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
+    allParticles.reserve(nResults);
+    for (const auto& vres : this->Results)
+      allParticles.push_back(vres.Get<ResType>().Particles);
+
+    vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
+    vtkm::cont::ParticleArrayCopy(allParticles, pts);
+    std::cout << "DSI::GetOutput() pts= ";
+    vtkm::cont::printSummary_ArrayHandle(pts, std::cout);
+
+    vtkm::Id numPoints = pts.GetNumberOfValues();
+    if (numPoints > 0)
+    {
+      //Create coordinate system and vertex cell set.
+      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", pts));
+
+      vtkm::cont::CellSetSingleType<> cells;
+      vtkm::cont::ArrayHandleIndex conn(numPoints);
+      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
+
+      vtkm::cont::ArrayCopy(conn, connectivity);
+      cells.Fill(numPoints, vtkm::CELL_SHAPE_VERTEX, 1, connectivity);
+      ds.SetCellSet(cells);
+    }
+  }
+  else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
+  {
+    using ResType = vtkm::worklet::StreamlineResult<ParticleType>;
+
+    //Easy case with one result.
+    if (nResults == 1)
+    {
+      const auto& res = this->Results[0].Get<ResType>();
+      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", res.Positions));
+      ds.SetCellSet(res.PolyLines);
+    }
+    else
+    {
+      std::vector<vtkm::Id> posOffsets(nResults, 0);
+      vtkm::Id totalNumCells = 0, totalNumPts = 0;
+      for (std::size_t i = 0; i < nResults; i++)
+      {
+        const auto& res = this->Results[i].Get<ResType>();
+        if (i == 0)
+          posOffsets[i] = 0;
+        else
+          posOffsets[i] = totalNumPts;
+
+        totalNumPts += res.Positions.GetNumberOfValues();
+        totalNumCells += res.PolyLines.GetNumberOfCells();
+      }
+
+      //Append all the points together.
+      vtkm::cont::ArrayHandle<vtkm::Vec3f> appendPts;
+      appendPts.Allocate(totalNumPts);
+      for (std::size_t i = 0; i < nResults; i++)
+      {
+        const auto& res = this->Results[i].Get<ResType>();
+        // copy all values into appendPts starting at offset.
+        vtkm::cont::Algorithm::CopySubRange(
+          res.Positions, 0, res.Positions.GetNumberOfValues(), appendPts, posOffsets[i]);
+      }
+      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", appendPts));
+
+      //Create polylines.
+      std::vector<vtkm::Id> numPtsPerCell(static_cast<std::size_t>(totalNumCells));
+      std::size_t off = 0;
+      for (std::size_t i = 0; i < nResults; i++)
+      {
+        const auto& res = this->Results[i].Get<ResType>();
+        vtkm::Id nCells = res.PolyLines.GetNumberOfCells();
+        for (vtkm::Id j = 0; j < nCells; j++)
+          numPtsPerCell[off++] = static_cast<vtkm::Id>(res.PolyLines.GetNumberOfPointsInCell(j));
+      }
+
+      auto numPointsPerCellArray = vtkm::cont::make_ArrayHandle(numPtsPerCell, vtkm::CopyFlag::Off);
+
+      vtkm::cont::ArrayHandle<vtkm::Id> cellIndex;
+      vtkm::Id connectivityLen =
+        vtkm::cont::Algorithm::ScanExclusive(numPointsPerCellArray, cellIndex);
+      vtkm::cont::ArrayHandleIndex connCount(connectivityLen);
+      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
+      vtkm::cont::ArrayCopy(connCount, connectivity);
+
+      vtkm::cont::ArrayHandle<vtkm::UInt8> cellTypes;
+      auto polyLineShape = vtkm::cont::make_ArrayHandleConstant<vtkm::UInt8>(
+        vtkm::CELL_SHAPE_POLY_LINE, totalNumCells);
+      vtkm::cont::ArrayCopy(polyLineShape, cellTypes);
+      auto offsets = vtkm::cont::ConvertNumComponentsToOffsets(numPointsPerCellArray);
+
+      vtkm::cont::CellSetExplicit<> polyLines;
+      polyLines.Fill(totalNumPts, cellTypes, connectivity, offsets);
+      ds.SetCellSet(polyLines);
+    }
+  }
+  else
+  {
+    throw vtkm::cont::ErrorFilterExecution("Unsupported ParticleAdvectionResultType");
+  }
+
+  return true;
+}
+
+using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+using SteadyStateGridEvalType = vtkm::worklet::particleadvection::GridEvaluator<VelocityFieldType>;
+using UnsteadyStateGridEvalType =
+  vtkm::worklet::particleadvection::TemporalGridEvaluator<VelocityFieldType>;
+
+template <typename GridEvalType, typename ParticleType>
+class AdvectHelper;
+
+template <typename ParticleType>
+class AdvectHelper<SteadyStateGridEvalType, ParticleType>
+{
+public:
+  static void Advect(const VelocityFieldType& velField,
+                     const vtkm::cont::DataSet& ds,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  static void Advect(const VelocityFieldType& velField,
+                     const vtkm::cont::DataSet& ds,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::StreamlineResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  template <typename WorkletType,
+            template <typename>
+            class ResultType,
+            template <typename>
+            class SolverType>
+  static void DoAdvect(const VelocityFieldType& velField,
+                       const vtkm::cont::DataSet& ds,
+                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                       vtkm::FloatDefault stepSize,
+                       vtkm::Id maxSteps,
+                       ResultType<ParticleType>& result)
+  {
+    using StepperType =
+      vtkm::worklet::particleadvection::Stepper<SolverType<SteadyStateGridEvalType>,
+                                                SteadyStateGridEvalType>;
+
+    WorkletType worklet;
+    SteadyStateGridEvalType eval(ds, velField);
+    StepperType stepper(eval, stepSize);
+    result = worklet.Run(stepper, seedArray, maxSteps);
+  }
+};
+
+template <typename ParticleType>
+class AdvectHelper<UnsteadyStateGridEvalType, ParticleType>
+{
+public:
+  static void Advect(const VelocityFieldType& velField1,
+                     const vtkm::cont::DataSet& ds1,
+                     vtkm::FloatDefault t1,
+                     const VelocityFieldType& velField2,
+                     const vtkm::cont::DataSet& ds2,
+                     vtkm::FloatDefault t2,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  static void Advect(const VelocityFieldType& velField1,
+                     const vtkm::cont::DataSet& ds1,
+                     vtkm::FloatDefault t1,
+                     const VelocityFieldType& velField2,
+                     const vtkm::cont::DataSet& ds2,
+                     vtkm::FloatDefault t2,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::StreamlineResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  template <typename WorkletType,
+            template <typename>
+            class ResultType,
+            template <typename>
+            class SolverType>
+  static void DoAdvect(const VelocityFieldType& velField1,
+                       const vtkm::cont::DataSet& ds1,
+                       vtkm::FloatDefault t1,
+                       const VelocityFieldType& velField2,
+                       const vtkm::cont::DataSet& ds2,
+                       vtkm::FloatDefault t2,
+                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                       vtkm::FloatDefault stepSize,
+                       vtkm::Id maxSteps,
+                       ResultType<ParticleType>& result)
+  {
+    using StepperType =
+      vtkm::worklet::particleadvection::Stepper<SolverType<UnsteadyStateGridEvalType>,
+                                                UnsteadyStateGridEvalType>;
+
+    WorkletType worklet;
+    UnsteadyStateGridEvalType eval(ds1, t1, velField1, ds2, t2, velField2);
+    StepperType stepper(eval, stepSize);
+    result = worklet.Run(stepper, seedArray, maxSteps);
+  }
+};
+
+
+
+VTKM_CONT void SteadyStateDSI::DoAdvect(DSIStuff<vtkm::Particle>& b,
+                                        vtkm::FloatDefault stepSize,
+                                        vtkm::Id maxSteps)
+{
+  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
+  auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
+  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
+  {
+    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+    FieldType velField;
+    this->GetVelocityField(velField);
+
+    using AHType = AdvectHelper<SteadyStateGridEvalType, vtkm::Particle>;
+
+    if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+    {
+      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
+      AHType::Advect(
+        velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
+      this->UpdateResult(result, b);
+      std::cout << __LINE__ << " ::DoAdvect: " << b.TermIdx.size() << std::endl;
+    }
+    else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
+    {
+      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
+      AHType::Advect(
+        velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
+      this->UpdateResult(result, b);
+      std::cout << __LINE__ << " ::DoAdvect: " << b.TermIdx.size() << std::endl;
+    }
+  }
+}
+
+VTKM_CONT void SteadyStateDSI::DoAdvect(DSIStuff<vtkm::ChargedParticle>& b,
+                                        vtkm::FloatDefault stepSize,
+                                        vtkm::Id maxSteps)
+{
+}
+
+
+VTKM_CONT void UnsteadyStateDSI::DoAdvect(DSIStuff<vtkm::Particle>& b,
+                                          vtkm::FloatDefault stepSize,
+                                          vtkm::Id maxSteps)
+{
+  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
+  auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
+
+  using AHType = AdvectHelper<UnsteadyStateGridEvalType, vtkm::Particle>;
+
+  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
+  {
+    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+    FieldType velField1, velField2;
+    this->GetVelocityFields(velField1, velField2);
+
+    if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+    {
+      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
+      AHType::Advect(velField1,
+                     this->DataSet1,
+                     this->Time1,
+                     velField2,
+                     this->DataSet2,
+                     this->Time2,
+                     seedArray,
+                     stepSize,
+                     maxSteps,
+                     this->SolverType,
+                     result);
+      this->UpdateResult(result, b);
+    }
+    else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
+    {
+      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
+      AHType::Advect(velField1,
+                     this->DataSet1,
+                     this->Time1,
+                     velField2,
+                     this->DataSet2,
+                     this->Time2,
+                     seedArray,
+                     stepSize,
+                     maxSteps,
+                     this->SolverType,
+                     result);
+      this->UpdateResult(result, b);
+    }
+  }
+}
+
+VTKM_CONT void UnsteadyStateDSI::DoAdvect(DSIStuff<vtkm::ChargedParticle>& b,
+                                          vtkm::FloatDefault stepSize,
+                                          vtkm::Id maxSteps)
+{
+}
+
+
 
 }
 }

From 80b0608ab2af3c54554c164c6c1767d9d40188dd Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 15 Jul 2022 11:36:02 -0400
Subject: [PATCH 018/104] Put steady/unsteady into sep files.

---
 vtkm/filter/ParticleAdvection2.hxx            |   4 +-
 vtkm/filter/PathParticle2.hxx                 |   4 +-
 vtkm/filter/Pathline2.hxx                     |   4 +-
 vtkm/filter/Streamline2.hxx                   |   4 +-
 vtkm/filter/particleadvection/ABA.h           |  45 +-
 vtkm/filter/particleadvection/CMakeLists.txt  |   4 +
 vtkm/filter/particleadvection/DSI.h           | 372 +-------
 vtkm/filter/particleadvection/DSI.hxx         | 827 +-----------------
 .../filter/particleadvection/DSISteadyState.h |  74 ++
 .../particleadvection/DSISteadyState.hxx      | 154 ++++
 .../particleadvection/DSIUnsteadyState.h      |  89 ++
 .../particleadvection/DSIUnsteadyState.hxx    | 182 ++++
 vtkm/worklet/ParticleAdvection.h              |  32 -
 13 files changed, 575 insertions(+), 1220 deletions(-)
 create mode 100644 vtkm/filter/particleadvection/DSISteadyState.h
 create mode 100644 vtkm/filter/particleadvection/DSISteadyState.hxx
 create mode 100644 vtkm/filter/particleadvection/DSIUnsteadyState.h
 create mode 100644 vtkm/filter/particleadvection/DSIUnsteadyState.hxx

diff --git a/vtkm/filter/ParticleAdvection2.hxx b/vtkm/filter/ParticleAdvection2.hxx
index 583120454..eb4903e7c 100644
--- a/vtkm/filter/ParticleAdvection2.hxx
+++ b/vtkm/filter/ParticleAdvection2.hxx
@@ -16,7 +16,7 @@
 #include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
 
-#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/DSISteadyState.h>
 #include <vtkm/filter/particleadvection/PAV.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
@@ -42,7 +42,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForEx
   //  return input;
 
 #if 1
-  using DSIType = vtkm::filter::particleadvection::SteadyStateDSI;
+  using DSIType = vtkm::filter::particleadvection::DSISteadyState;
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
diff --git a/vtkm/filter/PathParticle2.hxx b/vtkm/filter/PathParticle2.hxx
index 03886cbdb..89b67b91e 100644
--- a/vtkm/filter/PathParticle2.hxx
+++ b/vtkm/filter/PathParticle2.hxx
@@ -16,7 +16,7 @@
 #include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
 
-#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
 #include <vtkm/filter/particleadvection/PAV.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
@@ -41,7 +41,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle2::PrepareForExecuti
 {
 //  return input;
 #if 1
-  using DSIType = vtkm::filter::particleadvection::UnsteadyStateDSI;
+  using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
diff --git a/vtkm/filter/Pathline2.hxx b/vtkm/filter/Pathline2.hxx
index f5e0c7928..2bb7e3d7c 100644
--- a/vtkm/filter/Pathline2.hxx
+++ b/vtkm/filter/Pathline2.hxx
@@ -16,7 +16,7 @@
 #include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
 
-#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
 #include <vtkm/filter/particleadvection/PAV.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
@@ -40,7 +40,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Pathline2::PrepareForExecution(
 {
 //  return input;
 #if 1
-  using DSIType = vtkm::filter::particleadvection::UnsteadyStateDSI;
+  using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
diff --git a/vtkm/filter/Streamline2.hxx b/vtkm/filter/Streamline2.hxx
index 94c417a78..ebcbe90c0 100644
--- a/vtkm/filter/Streamline2.hxx
+++ b/vtkm/filter/Streamline2.hxx
@@ -16,7 +16,7 @@
 #include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
 
-#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/DSISteadyState.h>
 #include <vtkm/filter/particleadvection/PAV.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
@@ -41,7 +41,7 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Streamline2::PrepareForExecution
   //  return input;
 
 #if 1
-  using DSIType = vtkm::filter::particleadvection::SteadyStateDSI;
+  using DSIType = vtkm::filter::particleadvection::DSISteadyState;
 
   this->ValidateOptions();
   //Make sure everything matches up ok.
diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/ABA.h
index 68dfd65d0..80f6f4ba6 100644
--- a/vtkm/filter/particleadvection/ABA.h
+++ b/vtkm/filter/particleadvection/ABA.h
@@ -114,22 +114,10 @@ public:
       {
         //make this a pointer to avoid the copy?
         auto block = this->GetDataSet(blockId);
-
-        /*
-        DSIStuff<ParticleType> stuff(this->BoundsMap, this->ParticleBlockIDsMap);
-        block->Advect(v, this->StepSize, this->NumberOfSteps, stuff);
-        numTerm = this->UpdateResult(stuff);
-        std::cout << " Advect: " << v.size() << " NT= " << numTerm << std::endl;
-        */
-
-
-        //DSIStuff<ParticleType> b(v, this->BoundsMap, this->ParticleBlockIDsMap);
-        //DSIStuffType bb = b;
-        DSIStuffType bb = DSIStuff<ParticleType>(v, this->BoundsMap, this->ParticleBlockIDsMap);
-        block->ADVECT(bb, this->StepSize, this->NumberOfSteps);
-
-        //DSIStuff<ParticleType> bbb = bb.Get<DSIStuff<ParticleType>>();
-        numTerm = this->UpdateResult(bb.Get<DSIStuff<ParticleType>>());
+        DSIHelperInfoType bb =
+          DSIHelperInfo<ParticleType>(v, this->BoundsMap, this->ParticleBlockIDsMap);
+        block->Advect(bb, this->StepSize, this->NumberOfSteps);
+        numTerm = this->UpdateResult(bb.Get<DSIHelperInfo<ParticleType>>());
         std::cout << " Advect: " << v.size() << " NT= " << numTerm << std::endl;
       }
 
@@ -347,7 +335,7 @@ public:
   }
   */
 
-  vtkm::Id UpdateResult(const DSIStuff<ParticleType>& stuff)
+  vtkm::Id UpdateResult(const DSIHelperInfo<ParticleType>& stuff)
   {
     this->UpdateActive(stuff.A, stuff.IdMapA);
     this->UpdateInactive(stuff.I, stuff.IdMapI);
@@ -363,29 +351,6 @@ public:
     return numTerm;
   }
 
-  /*
-  vtkm::Id UpdateResult(ResultType<ParticleType>& res, vtkm::Id blockId)
-  {
-    std::cout<<"UpdateResult: blockId= "<<blockId<<std::endl;
-    std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> idsMapI, idsMapA;
-    std::vector<ParticleType> A, I;
-    std::vector<vtkm::Id> termIdx;
-    this->ClassifyParticles(res.Particles, idsMapA, idsMapI, A, I, termIdx);
-
-    //Update active, inactive and terminated
-    this->UpdateActive(A, idsMapA);
-    this->UpdateInactive(I, idsMapI);
-
-    vtkm::Id numTerm = static_cast<vtkm::Id>(termIdx.size());
-    if (numTerm > 0)
-      this->UpdateTerminated(res.Particles, termIdx);
-
-    internal::ResultHelper<ResultType, ParticleType>::Store(this->Results, res, blockId, termIdx);
-
-    return numTerm;
-  }
-  */
-
   virtual bool GetBlockAndWait(const vtkm::Id& numLocalTerm)
   {
     //There are only two cases where blocking would deadlock.
diff --git a/vtkm/filter/particleadvection/CMakeLists.txt b/vtkm/filter/particleadvection/CMakeLists.txt
index 24f78e9d4..475a348d3 100644
--- a/vtkm/filter/particleadvection/CMakeLists.txt
+++ b/vtkm/filter/particleadvection/CMakeLists.txt
@@ -19,7 +19,11 @@ set(headers
   ParticleAdvectionAlgorithm.h
   ParticleMessenger.h
   DSI.h
+  DSISteadyState.h
+  DSIUnsteadyState.h
   DSI.hxx
+  DSISteadyState.hxx
+  DSIUnsteadyState.hxx
   ABA.h
   PAV.h
   ParticleAdvectionTypes.h
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index 6121bd48a..e547b94ea 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_DSI_h
-#define vtk_m_filter_DSI_h
+#ifndef vtk_m_filter_particleadvection_DSI_h
+#define vtk_m_filter_particleadvection_DSI_h
 
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
@@ -29,12 +29,12 @@ namespace particleadvection
 {
 
 template <typename ParticleType>
-class DSIStuff
+class DSIHelperInfo
 {
 public:
-  DSIStuff(const std::vector<ParticleType>& v,
-           const vtkm::filter::particleadvection::BoundsMap& boundsMap,
-           const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& particleBlockIDsMap)
+  DSIHelperInfo(const std::vector<ParticleType>& v,
+                const vtkm::filter::particleadvection::BoundsMap& boundsMap,
+                const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& particleBlockIDsMap)
     : BoundsMap(boundsMap)
     , ParticleBlockIDsMap(particleBlockIDsMap)
     , V(v)
@@ -48,40 +48,8 @@ public:
   const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
 };
 
-using DSIStuffP = DSIStuff<vtkm::Particle>;
-using DSIStuffCP = DSIStuff<vtkm::ChargedParticle>;
-using DSIStuffType =
-  vtkm::cont::internal::Variant<DSIStuff<vtkm::Particle>, DSIStuff<vtkm::ChargedParticle>>;
-
-/*
-template <typename ParticleType>
-struct DSIStuff
-{
-  DSIStuff(const vtkm::filter::particleadvection::BoundsMap& boundsMap,
-           const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& particleBlockIDsMap)
-    : BoundsMap(boundsMap)
-    , ParticleBlockIDsMap(particleBlockIDsMap)
-  {
-  }
-
-  DSIStuff(const std::vector<ParticleType>& v,
-           const vtkm::filter::particleadvection::BoundsMap& boundsMap,
-           const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& particleBlockIDsMap)
-    : BoundsMap(boundsMap)
-    , ParticleBlockIDsMap(particleBlockIDsMap)
-    , V(v)
-  {
-  }
-
-  std::vector<ParticleType> V;
-  std::vector<ParticleType> A, I;
-  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> IdMapA, IdMapI;
-  std::vector<vtkm::Id> TermIdx, TermID;
-  const vtkm::filter::particleadvection::BoundsMap BoundsMap;
-  const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
-};
-*/
-
+using DSIHelperInfoType = vtkm::cont::internal::Variant<DSIHelperInfo<vtkm::Particle>,
+                                                        DSIHelperInfo<vtkm::ChargedParticle>>;
 
 class DSI
 {
@@ -91,18 +59,12 @@ protected:
   using FieldNameType =
     vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType>;
 
-  using SType =
-    vtkm::cont::internal::Variant<DSIStuff<vtkm::Particle>, DSIStuff<vtkm::ChargedParticle>>;
-  using PType =
-    vtkm::cont::internal::Variant<std::vector<vtkm::Particle>, std::vector<vtkm::ChargedParticle>>;
   using RType =
     vtkm::cont::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
                                   vtkm::worklet::ParticleAdvectionResult<vtkm::ChargedParticle>,
                                   vtkm::worklet::StreamlineResult<vtkm::Particle>,
                                   vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
 
-
-
 public:
   DSI(vtkm::Id id,
       const FieldNameType& fieldName,
@@ -119,88 +81,28 @@ public:
     //check that things are valid.
   }
 
-  /*
-  VTKM_CONT bool IsSteadyState() const
-  {
-    return this->Data.GetIndex() == this->Data.GetIndexOf<SteadyStateDataType>();
-  }
-  VTKM_CONT bool IsUnsteadyState() const
-  {
-    return this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>();
-  }
-  */
-
   VTKM_CONT vtkm::Id GetID() const { return this->Id; }
   VTKM_CONT void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
 
-
-  /*
-  template <typename ParticleType>
-  VTKM_CONT void Advect(std::vector<ParticleType>& v,
-                        vtkm::FloatDefault stepSize, //move these to member data(?)
-                        vtkm::Id maxSteps,
-                        DSIStuff<ParticleType>& stuff);
-
-  template <template <typename> class ResultType, typename ParticleType>
-  VTKM_CONT void
-  BumHole(ResultType<ParticleType>& result)
-  {
-    std::cout<<"bumhole"<<std::endl;
-  }
-  */
-
-  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::Particle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) = 0;
-
-  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::ChargedParticle>& b,
-                                  vtkm::FloatDefault stepSize, //move these to member data(?)
-                                  vtkm::Id maxSteps) = 0;
-
   VTKM_CONT
-  virtual void ADVECT(DSIStuffType& b,
+  virtual void Advect(DSIHelperInfoType& b,
                       vtkm::FloatDefault stepSize, //move these to member data(?)
                       vtkm::Id maxSteps)
   {
-    if (b.GetIndex() == b.GetIndexOf<DSIStuff<vtkm::Particle>>())
+    if (b.GetIndex() == b.GetIndexOf<DSIHelperInfo<vtkm::Particle>>())
     {
-      auto& bb = b.Get<DSIStuff<vtkm::Particle>>();
+      auto& bb = b.Get<DSIHelperInfo<vtkm::Particle>>();
       this->DoAdvect(bb, stepSize, maxSteps);
     }
-    else if (b.GetIndex() == b.GetIndexOf<DSIStuff<vtkm::ChargedParticle>>())
+    else if (b.GetIndex() == b.GetIndexOf<DSIHelperInfo<vtkm::ChargedParticle>>())
     {
-      auto& bb = b.Get<DSIStuff<vtkm::ChargedParticle>>();
+      auto& bb = b.Get<DSIHelperInfo<vtkm::ChargedParticle>>();
       this->DoAdvect(bb, stepSize, maxSteps);
     }
 
     //b.CastAndCall([&] (auto& concrete) { this->DoAdvect(concrete, stepSize, maxSteps); });
-
-    /*
-    if (b.GetIndex() == b.GetIndexOf<BumP>())
-    {
-      std::cout<<"It's a particle!"<<std::endl;
-      auto bb = b.Get<BumP>();
-    }
-    else if (b.GetIndex() == b.GetIndexOf<BumC>())
-    {
-      std::cout<<"It's a CHARGED particle!"<<std::endl;
-      auto bb = b.Get<BumC>();
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Steady state velocity field vector type not available");
-    */
   }
 
-  /*
-  VTKM_CONT
-  virtual void DoADVECT(std::vector<PType>& v,
-                        vtkm::FloatDefault stepSize,
-                        vtkm::Id maxSteps,
-                        SType& stuff)
-  {
-  }
-  */
-
   template <typename ParticleType>
   VTKM_CONT bool GetOutput(vtkm::cont::DataSet& ds) const;
 
@@ -208,141 +110,22 @@ public:
 protected:
   template <typename ParticleType, template <typename> class ResultType>
   VTKM_CONT void UpdateResult(const ResultType<ParticleType>& result,
-                              DSIStuff<ParticleType>& stuff);
+                              DSIHelperInfo<ParticleType>& stuff);
 
-  /*
-  template <typename ArrayType>
-  VTKM_CONT void GetSteadyStateVelocityField(
-    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
-  {
-    if (this->Data.GetIndex() == this->Data.GetIndexOf<SteadyStateDataType>())
-    {
-      const auto& ds = this->Data.Get<SteadyStateDataType>();
-      this->GetVelocityField(ds, velocityField);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Steady state velocity field vector type not available");
-  }
+protected:
+  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) = 0;
 
-  template <typename ArrayType>
-  VTKM_CONT void GetUnsteadyStateVelocityField(
-    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField1,
-    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField2) const
-  {
-    if (this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>())
-    {
-      const auto& data = this->Data.Get<UnsteadyStateDataType>();
-      this->GetVelocityField(data.DataSet1, velocityField1);
-      this->GetVelocityField(data.DataSet2, velocityField2);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsteady state velocity field vector type not available");
-  }
-  */
-
-  template <typename ArrayType>
-  VTKM_CONT void GetVelocityField(
-    const vtkm::cont::DataSet& ds,
-    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
-  {
-    if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<VelocityFieldNameType>())
-    {
-      const auto& fieldNm = this->FieldName.Get<VelocityFieldNameType>();
-      auto assoc = ds.GetField(fieldNm).GetAssociation();
-      ArrayType arr;
-      vtkm::cont::ArrayCopyShallowIfPossible(ds.GetField(fieldNm).GetData(), arr);
-
-      velocityField = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr, assoc);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
-  }
-
-  template <typename ArrayType>
-  VTKM_CONT void GetElectroMagneticField(
-    const vtkm::cont::DataSet& ds,
-    vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& elecMagField) const
-  {
-    if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<ElectroMagneticFieldNameType>())
-    {
-      const auto& fieldNms = this->FieldName.Get<ElectroMagneticFieldNameType>();
-      auto assoc1 = ds.GetField(fieldNms.first).GetAssociation();
-      auto assoc2 = ds.GetField(fieldNms.second).GetAssociation();
-      if (assoc1 != assoc2)
-        throw vtkm::cont::ErrorFilterExecution(
-          "Electro-magnetic vector fields have differing associations");
-
-      ArrayType arr1, arr2;
-      vtkm::cont::ArrayCopyShallowIfPossible(ds.GetField(fieldNms.first).GetData(), arr1);
-      vtkm::cont::ArrayCopyShallowIfPossible(ds.GetField(fieldNms.second).GetData(), arr2);
-
-      elecMagField =
-        vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>(arr1, arr2, assoc1);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
-  }
-
-  /*
-  template <typename ArrayType>
-  VTKM_CONT void GetSteadyStateElectroMagneticField(
-    vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& elecMagField) const
-  {
-    if (this->Data.GetIndex() == this->Data.GetIndexOf<SteadyStateDataType>())
-    {
-      const auto& ds = this->Data.Get<SteadyStateDataType>();
-      this->GetElectroMagneticField(ds, elecMagField);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Electro-magnetic vector field type not available");
-  }
-
-  template <typename ArrayType>
-  VTKM_CONT void GetUnsteadyStateElectroMagneticField(
-    vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& emField1,
-    vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>& emField2) const
-  {
-    if (this->Data.GetIndex() == this->Data.GetIndexOf<UnsteadyStateDataType>())
-    {
-      this->GetSteadyStateElectroMagneticField(emField1);
-      this->GetSteadyStateElectroMagneticField(emField2);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsteady state electro-magnetic field vector type not available");
-  }
-  */
-
-  //template <typename ParticleType>
-  void Meow(const char* func, const int& lineNum) const;
+  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) = 0;
 
   template <typename ParticleType>
   VTKM_CONT void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
-                                   DSIStuff<ParticleType>& stuff) const;
-
-  /*
-  using SteadyStateDataType = vtkm::cont::DataSet;
-  struct UnsteadyStateDataType
-  {
-    UnsteadyStateDataType(const vtkm::cont::DataSet& ds1,
-                          const vtkm::cont::DataSet& ds2,
-                          vtkm::FloatDefault t1,
-                          vtkm::FloatDefault t2)
-      : DataSet1(ds1)
-      , DataSet2(ds2)
-      , Time1(t1)
-      , Time2(t2)
-    {
-    }
-
-    vtkm::cont::DataSet DataSet1;
-    vtkm::cont::DataSet DataSet2;
-    vtkm::FloatDefault Time1;
-    vtkm::FloatDefault Time2;
-  };
-*/
+                                   DSIHelperInfo<ParticleType>& stuff) const;
 
   //Data members.
-  //  vtkm::cont::internal::Variant<SteadyStateDataType, UnsteadyStateDataType> Data;
   vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType> FieldName;
 
   vtkm::Id Id;
@@ -358,117 +141,12 @@ protected:
 };
 
 
-class SteadyStateDSI : public DSI
-{
-public:
-  SteadyStateDSI(const vtkm::cont::DataSet& ds,
-                 vtkm::Id id,
-                 const FieldNameType& fieldName,
-                 vtkm::filter::particleadvection::IntegrationSolverType solverType,
-                 vtkm::filter::particleadvection::VectorFieldType vecFieldType,
-                 vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
-    : DSI(id, fieldName, solverType, vecFieldType, resultType)
-    , DataSet(ds)
-  {
-  }
-
-  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::Particle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) override;
-
-  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::ChargedParticle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) override;
-
-protected:
-  template <typename ArrayType>
-  VTKM_CONT void GetVelocityField(
-    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
-  {
-    if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<VelocityFieldNameType>())
-    {
-      const auto& fieldNm = this->FieldName.Get<VelocityFieldNameType>();
-      auto assoc = this->DataSet.GetField(fieldNm).GetAssociation();
-      ArrayType arr;
-      vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(fieldNm).GetData(), arr);
-
-      velocityField = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr, assoc);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
-  }
-
-
-private:
-  vtkm::cont::DataSet DataSet;
-};
-
-class UnsteadyStateDSI : public DSI
-{
-public:
-  UnsteadyStateDSI(const vtkm::cont::DataSet& ds1,
-                   const vtkm::cont::DataSet& ds2,
-                   vtkm::FloatDefault t1,
-                   vtkm::FloatDefault t2,
-                   vtkm::Id id,
-                   const FieldNameType& fieldName,
-                   vtkm::filter::particleadvection::IntegrationSolverType solverType,
-                   vtkm::filter::particleadvection::VectorFieldType vecFieldType,
-                   vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
-    : DSI(id, fieldName, solverType, vecFieldType, resultType)
-    , DataSet1(ds1)
-    , DataSet2(ds2)
-    , Time1(t1)
-    , Time2(t2)
-  {
-  }
-
-  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::Particle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) override;
-
-  VTKM_CONT virtual void DoAdvect(DSIStuff<vtkm::ChargedParticle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) override;
-
-protected:
-  template <typename ArrayType>
-  VTKM_CONT void GetVelocityFields(
-    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField1,
-    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField2) const
-  {
-    if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<VelocityFieldNameType>())
-    {
-      const auto& fieldNm = this->FieldName.Get<VelocityFieldNameType>();
-      auto assoc = this->DataSet1.GetField(fieldNm).GetAssociation();
-      if (assoc != this->DataSet2.GetField(fieldNm).GetAssociation())
-        throw vtkm::cont::ErrorFilterExecution(
-          "Unsteady state velocity fields have differnt associations");
-
-      ArrayType arr1, arr2;
-      vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet1.GetField(fieldNm).GetData(), arr1);
-      vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet2.GetField(fieldNm).GetData(), arr2);
-
-      velocityField1 = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr1, assoc);
-      velocityField2 = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr2, assoc);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
-  }
-
-private:
-  vtkm::cont::DataSet DataSet1;
-  vtkm::cont::DataSet DataSet2;
-  vtkm::FloatDefault Time1;
-  vtkm::FloatDefault Time2;
-};
-
 }
 }
 }
 
-#ifndef vtk_m_filter_particleadvection_DSI_hxx
+//#ifndef vtk_m_filter_particleadvection_DSI_hxx
 #include <vtkm/filter/particleadvection/DSI.hxx>
-#endif
+//#endif
 
-#endif //vtk_m_filter_DSI_h
+#endif //vtk_m_filter_particleadvection_DSI_h
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index 28cda5e73..4d94fb5ee 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_DSI_hxx
-#define vtk_m_filter_DSI_hxx
+#ifndef vtk_m_filter_particleadvection_DSI_hxx
+#define vtk_m_filter_particleadvection_DSI_hxx
 
 namespace vtkm
 {
@@ -18,519 +18,9 @@ namespace filter
 namespace particleadvection
 {
 
-#if 0
-namespace internal
-{
-using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-using SteadyStateGridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-using UnSteadyStateGridEvalType =
-  vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
-
-template <typename GridEvalType,
-          typename WorkletType,
-          template <typename> class ResultType,
-          typename ParticleType>
-class AdvectHelper;
-
- //Steady state
-template <typename WorkletType, template <typename> class ResultType, typename ParticleType>
-class AdvectHelper<SteadyStateGridEvalType, WorkletType, ResultType, ParticleType>
-{
-public:
-  static void Advect(const FieldType& velField,
-                     const vtkm::cont::DataSet& ds,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& integratorType,
-                     ResultType<ParticleType>& result)
-  {
-    using AHType =
-      internal::AdvectHelper<SteadyStateGridEvalType, WorkletType, ResultType, ParticleType>;
-    if (integratorType == IntegrationSolverType::RK4_TYPE)
-      AHType::template DoAdvect<vtkm::worklet::particleadvection::RK4Integrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    else if (integratorType == IntegrationSolverType::EULER_TYPE)
-      AHType::template DoAdvect<vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  template <template <typename> class IntType>
-  static void DoAdvect(const FieldType& velField,
-                       const vtkm::cont::DataSet& ds,
-                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                       vtkm::FloatDefault stepSize,
-                       vtkm::Id maxSteps,
-                       ResultType<ParticleType>& result)
-  {
-    using StepperType = vtkm::worklet::particleadvection::Stepper<IntType<SteadyStateGridEvalType>,
-                                                                  SteadyStateGridEvalType>;
-    SteadyStateGridEvalType eval(ds, velField);
-    StepperType stepper(eval, stepSize);
-    WorkletType worklet;
-    result = worklet.Run(stepper, seedArray, maxSteps);
-  }
-
-
-};
-
-}
-
-void DSI::Meow(const char* func, const int& lineNum) const
-{
-  if (this->Results.empty())
-  {
-    //std::cout<<"   no results!"<<std::endl;
-    return;
-  }
-
-  std::cout << " ******************************";
-  std::cout << func << " " << lineNum << " ";
-  using ResType = vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>;
-
-  //const auto& R0 = this->Results[0]->Get<RType>();
-  //const auto& P0 = R0.Particles.ReadPortal().Get(0);
-  //RType* r = static_cast<RType*>(this->Results[0]);
-  //const auto& P0 = r->Particles.ReadPortal().Get(0);
-  const auto& P0 = this->Results[0].Get<ResType>().Particles.ReadPortal().Get(0);
-  std::cout << "   PT0=  " << P0.Pos << std::endl;
-
-  //std::cout<<"   PT0=  "<<P0.Pos<<std::endl;
-
-  /*
-  auto& R0 = this->Results[0].Get<RType>();
-  auto P0 = R0.Particles.ReadPortal().Get(0);
-  std::cout<<"   PT0=  "<<P0.Pos<<std::endl;
-  auto ppp = R0.Particles;
-  std::cout<<"   ptrs: RP= "<<(void*)&(R0)<<" pPtr= "<<(void*)&ppp<<std::endl;
-  */
-}
-
-template <typename ParticleType>
-VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
-{
-  std::size_t nResults = this->Results.size();
-  if (nResults == 0)
-    return false;
-
-  std::cout << "Check the variant type!" << std::endl;
-
-  if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
-  {
-    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
-
-    std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
-    allParticles.reserve(nResults);
-    for (const auto& vres : this->Results)
-      allParticles.push_back(vres.Get<ResType>().Particles);
-
-    vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
-    vtkm::cont::ParticleArrayCopy(allParticles, pts);
-    std::cout << "DSI::GetOutput() pts= ";
-    vtkm::cont::printSummary_ArrayHandle(pts, std::cout);
-
-    vtkm::Id numPoints = pts.GetNumberOfValues();
-    if (numPoints > 0)
-    {
-      //Create coordinate system and vertex cell set.
-      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", pts));
-
-      vtkm::cont::CellSetSingleType<> cells;
-      vtkm::cont::ArrayHandleIndex conn(numPoints);
-      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
-
-      vtkm::cont::ArrayCopy(conn, connectivity);
-      cells.Fill(numPoints, vtkm::CELL_SHAPE_VERTEX, 1, connectivity);
-      ds.SetCellSet(cells);
-    }
-  }
-  else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
-  {
-    using ResType = vtkm::worklet::StreamlineResult<ParticleType>;
-
-    //Easy case with one result.
-    if (nResults == 1)
-    {
-      const auto& res = this->Results[0].Get<ResType>();
-      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", res.Positions));
-      ds.SetCellSet(res.PolyLines);
-    }
-    else
-    {
-      std::vector<vtkm::Id> posOffsets(nResults, 0);
-      vtkm::Id totalNumCells = 0, totalNumPts = 0;
-      for (std::size_t i = 0; i < nResults; i++)
-      {
-        const auto& res = this->Results[i].Get<ResType>();
-        if (i == 0)
-          posOffsets[i] = 0;
-        else
-          posOffsets[i] = totalNumPts;
-
-        totalNumPts += res.Positions.GetNumberOfValues();
-        totalNumCells += res.PolyLines.GetNumberOfCells();
-      }
-
-      //Append all the points together.
-      vtkm::cont::ArrayHandle<vtkm::Vec3f> appendPts;
-      appendPts.Allocate(totalNumPts);
-      for (std::size_t i = 0; i < nResults; i++)
-      {
-        const auto& res = this->Results[i].Get<ResType>();
-        // copy all values into appendPts starting at offset.
-        vtkm::cont::Algorithm::CopySubRange(
-          res.Positions, 0, res.Positions.GetNumberOfValues(), appendPts, posOffsets[i]);
-      }
-      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", appendPts));
-
-      //Create polylines.
-      std::vector<vtkm::Id> numPtsPerCell(static_cast<std::size_t>(totalNumCells));
-      std::size_t off = 0;
-      for (std::size_t i = 0; i < nResults; i++)
-      {
-        const auto& res = this->Results[i].Get<ResType>();
-        vtkm::Id nCells = res.PolyLines.GetNumberOfCells();
-        for (vtkm::Id j = 0; j < nCells; j++)
-          numPtsPerCell[off++] = static_cast<vtkm::Id>(res.PolyLines.GetNumberOfPointsInCell(j));
-      }
-
-      auto numPointsPerCellArray = vtkm::cont::make_ArrayHandle(numPtsPerCell, vtkm::CopyFlag::Off);
-
-      vtkm::cont::ArrayHandle<vtkm::Id> cellIndex;
-      vtkm::Id connectivityLen =
-        vtkm::cont::Algorithm::ScanExclusive(numPointsPerCellArray, cellIndex);
-      vtkm::cont::ArrayHandleIndex connCount(connectivityLen);
-      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
-      vtkm::cont::ArrayCopy(connCount, connectivity);
-
-      vtkm::cont::ArrayHandle<vtkm::UInt8> cellTypes;
-      auto polyLineShape = vtkm::cont::make_ArrayHandleConstant<vtkm::UInt8>(
-        vtkm::CELL_SHAPE_POLY_LINE, totalNumCells);
-      vtkm::cont::ArrayCopy(polyLineShape, cellTypes);
-      auto offsets = vtkm::cont::ConvertNumComponentsToOffsets(numPointsPerCellArray);
-
-      vtkm::cont::CellSetExplicit<> polyLines;
-      polyLines.Fill(totalNumPts, cellTypes, connectivity, offsets);
-      ds.SetCellSet(polyLines);
-    }
-  }
-  else
-  {
-    throw vtkm::cont::ErrorFilterExecution("Unsupported ParticleAdvectionResultType");
-  }
-
-  return true;
-}
-
-void DSI::DoAdvect(Bum<vtkm::Particle>& b,
-                   vtkm::FloatDefault stepSize,
-                   vtkm::Id maxSteps)
-{
-  using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-
-  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
-  {
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-    FieldType velField;
-    this->GetSteadyStateVelocityField(velField);
-
-    if (this->ResType == ParticleAdectionResultType::PARTICLE_ADVECT_TYPE)
-    {
-      using AHType = internal::AdvectHelper<GridEvType,
-                                            vtkm::worklet::ParticleAdvection,
-                                            vtkm::worklet::ParticleAdvectionResult,
-                                            vtkm::Particle>;
-      AHType::Advect(result);
-    }
-    else if (this->ResType == ParticleAdectionResultType::STREAMLINE_TYPE)
-    {
-    }
-  }
-    std::cout<<"***************************************************************        DSI::DoAdvect --------- Particle"<<std::endl;
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<internal::ArrayType>;
-    using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-    using AHType = internal::AdvectHelper<GridEvType,
-                                          vtkm::worklet::ParticleAdvection,
-                                          vtkm::worklet::ParticleAdvectionResult,
-                                          vtkm::Particle>;
-
-    auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
-    auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
-
-    const auto& data = this->Data.Get<vtkm::cont::DataSet>();
-    FieldType velField;
-    this->GetSteadyStateVelocityField(velField);
-    vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
-    AHType::Advect(velField, data, seedArray, stepSize, maxSteps, this->SolverType, result);
-    //this->UpdateResult(result, stuff);
-}
-
-void DSI::DoAdvect(Bum<vtkm::ChargedParticle>& b,
-                   vtkm::FloatDefault stepSize,
-                   vtkm::Id maxSteps)
-{
-}
-
-template <typename ParticleType>
-VTKM_CONT void DSI::Advect(std::vector<ParticleType>& v,
-                           vtkm::FloatDefault stepSize,
-                           vtkm::Id maxSteps,
-                           DSIStuff<ParticleType>& stuff)
-{
-  //using Association = vtkm::cont::Field::Association;
-  using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-
-  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
-  auto seedArray = vtkm::cont::make_ArrayHandle(v, copyFlag);
-
-  //PA or SL result.
-  if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
-  {
-    vtkm::worklet::ParticleAdvectionResult<ParticleType> result;
-    vtkm::worklet::ParticleAdvection worklet;
-
-    if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
-    {
-      using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-
-      if (this->IsSteadyState())
-      {
-        using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-
-        FieldType velField;
-        this->GetSteadyStateVelocityField(velField);
-
-        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
-        {
-          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
-
-          GridEvType eval(this->Data.Get<DSI::SteadyStateDataType>(), velField);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
-        {
-          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
-
-          GridEvType eval(this->Data.Get<SteadyStateDataType>(), velField);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-      }
-      else if (this->IsUnsteadyState())
-      {
-        using GridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
-
-        FieldType velField1, velField2;
-        this->GetUnsteadyStateVelocityField(velField1, velField2);
-        const auto d = this->Data.Get<UnsteadyStateDataType>();
-
-        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
-        {
-          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
-
-          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
-        {
-          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
-
-          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-      }
-    }
-    else if (this->VecFieldType == VectorFieldType::ELECTRO_MAGNETIC_FIELD_TYPE)
-    {
-      using FieldType = vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>;
-
-      if (this->IsSteadyState())
-      {
-        using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-
-        FieldType velField;
-        this->GetSteadyStateElectroMagneticField(velField);
-        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
-        {
-          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
-
-          GridEvType eval(this->Data.Get<DSI::SteadyStateDataType>(), velField);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
-        {
-          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
-
-          GridEvType eval(this->Data.Get<SteadyStateDataType>(), velField);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-      }
-      else if (this->IsUnsteadyState())
-      {
-        using GridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
-        FieldType velField1, velField2;
-        this->GetUnsteadyStateElectroMagneticField(velField1, velField2);
-        const auto d = this->Data.Get<UnsteadyStateDataType>();
-
-        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
-        {
-          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
-
-          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
-        {
-          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
-
-          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-      }
-    }
-
-    this->UpdateResult(result, stuff);
-  }
-  else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
-  {
-    vtkm::worklet::StreamlineResult<ParticleType> result;
-    vtkm::worklet::Streamline worklet;
-
-    if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
-    {
-      using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-
-      if (this->IsSteadyState())
-      {
-        using GridEvType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-
-        FieldType velField;
-        this->GetSteadyStateVelocityField(velField);
-
-        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
-        {
-          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
-
-          GridEvType eval(this->Data.Get<DSI::SteadyStateDataType>(), velField);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
-        {
-          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
-
-          GridEvType eval(this->Data.Get<SteadyStateDataType>(), velField);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-      }
-      else if (this->IsUnsteadyState())
-      {
-        using GridEvType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
-
-        FieldType velField1, velField2;
-        this->GetUnsteadyStateVelocityField(velField1, velField2);
-        const auto d = this->Data.Get<UnsteadyStateDataType>();
-
-        if (this->SolverType == IntegrationSolverType::RK4_TYPE)
-        {
-          using RK4_Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<RK4_Type, GridEvType>;
-
-          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-        else if (this->SolverType == IntegrationSolverType::EULER_TYPE)
-        {
-          using EulerType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvType>;
-          using StepperType = vtkm::worklet::particleadvection::Stepper<EulerType, GridEvType>;
-
-          GridEvType eval(d.DataSet1, d.Time1, velField1, d.DataSet2, d.Time2, velField2);
-          StepperType stepper(eval, stepSize);
-
-          result = worklet.Run(stepper, seedArray, maxSteps);
-        }
-      }
-    }
-    else if (this->VecFieldType == VectorFieldType::ELECTRO_MAGNETIC_FIELD_TYPE)
-    {
-      using FieldType = vtkm::worklet::particleadvection::ElectroMagneticField<ArrayType>;
-    }
-
-    this->UpdateResult(result, stuff);
-  }
-  else
-    throw vtkm::cont::ErrorFilterExecution("Unsupported Data Type in DSI");
-}
-
-#endif
-
-template <typename ParticleType, template <typename> class ResultType>
-VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
-                                 DSIStuff<ParticleType>& stuff)
-{
-  this->ClassifyParticles(result.Particles, stuff);
-  std::cout << "DSI::UpdateResult  TermIdx= " << stuff.TermIdx.size() << std::endl;
-
-  //template this for PA and SL
-  if (this->ResType ==
-      vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
-  {
-    if (stuff.TermIdx.empty())
-      return;
-
-    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
-    auto indicesAH = vtkm::cont::make_ArrayHandle(stuff.TermIdx, vtkm::CopyFlag::Off);
-    auto termPerm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, result.Particles);
-
-    vtkm::cont::ArrayHandle<ParticleType> termParticles;
-    vtkm::cont::Algorithm::Copy(termPerm, termParticles);
-
-    ResType termRes(termParticles);
-    this->Results.push_back(termRes);
-  }
-  else if (this->ResType ==
-           vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
-  {
-    this->Results.push_back(result);
-  }
-}
-
 template <typename ParticleType>
 VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
-                                      DSIStuff<ParticleType>& stuff) const
+                                      DSIHelperInfo<ParticleType>& stuff) const
 {
   stuff.A.clear();
   stuff.I.clear();
@@ -545,7 +35,6 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
   for (vtkm::Id i = 0; i < n; i++)
   {
     auto p = portal.Get(i);
-    std::cout << "****** ClassifyParticles: " << p.Pos << " ID= " << p.ID << std::endl;
 
     if (p.Status.CheckTerminate())
     {
@@ -614,6 +103,36 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
   VTKM_ASSERT(stuff.TermIdx.size() == stuff.TermID.size());
 }
 
+template <typename ParticleType, template <typename> class ResultType>
+VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
+                                 DSIHelperInfo<ParticleType>& stuff)
+{
+  this->ClassifyParticles(result.Particles, stuff);
+
+  //template this for PA and SL
+  if (this->ResType ==
+      vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+  {
+    if (stuff.TermIdx.empty())
+      return;
+
+    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+    auto indicesAH = vtkm::cont::make_ArrayHandle(stuff.TermIdx, vtkm::CopyFlag::Off);
+    auto termPerm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, result.Particles);
+
+    vtkm::cont::ArrayHandle<ParticleType> termParticles;
+    vtkm::cont::Algorithm::Copy(termPerm, termParticles);
+
+    ResType termRes(termParticles);
+    this->Results.push_back(termRes);
+  }
+  else if (this->ResType ==
+           vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
+  {
+    this->Results.push_back(result);
+  }
+}
+
 template <typename ParticleType>
 VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
 {
@@ -730,287 +249,9 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
   return true;
 }
 
-using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-using SteadyStateGridEvalType = vtkm::worklet::particleadvection::GridEvaluator<VelocityFieldType>;
-using UnsteadyStateGridEvalType =
-  vtkm::worklet::particleadvection::TemporalGridEvaluator<VelocityFieldType>;
-
-template <typename GridEvalType, typename ParticleType>
-class AdvectHelper;
-
-template <typename ParticleType>
-class AdvectHelper<SteadyStateGridEvalType, ParticleType>
-{
-public:
-  static void Advect(const VelocityFieldType& velField,
-                     const vtkm::cont::DataSet& ds,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& solverType,
-                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
-  {
-    if (solverType == IntegrationSolverType::RK4_TYPE)
-    {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    }
-    else if (solverType == IntegrationSolverType::EULER_TYPE)
-    {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  static void Advect(const VelocityFieldType& velField,
-                     const vtkm::cont::DataSet& ds,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& solverType,
-                     vtkm::worklet::StreamlineResult<ParticleType>& result)
-  {
-    if (solverType == IntegrationSolverType::RK4_TYPE)
-    {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    }
-    else if (solverType == IntegrationSolverType::EULER_TYPE)
-    {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  template <typename WorkletType,
-            template <typename>
-            class ResultType,
-            template <typename>
-            class SolverType>
-  static void DoAdvect(const VelocityFieldType& velField,
-                       const vtkm::cont::DataSet& ds,
-                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                       vtkm::FloatDefault stepSize,
-                       vtkm::Id maxSteps,
-                       ResultType<ParticleType>& result)
-  {
-    using StepperType =
-      vtkm::worklet::particleadvection::Stepper<SolverType<SteadyStateGridEvalType>,
-                                                SteadyStateGridEvalType>;
-
-    WorkletType worklet;
-    SteadyStateGridEvalType eval(ds, velField);
-    StepperType stepper(eval, stepSize);
-    result = worklet.Run(stepper, seedArray, maxSteps);
-  }
-};
-
-template <typename ParticleType>
-class AdvectHelper<UnsteadyStateGridEvalType, ParticleType>
-{
-public:
-  static void Advect(const VelocityFieldType& velField1,
-                     const vtkm::cont::DataSet& ds1,
-                     vtkm::FloatDefault t1,
-                     const VelocityFieldType& velField2,
-                     const vtkm::cont::DataSet& ds2,
-                     vtkm::FloatDefault t2,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& solverType,
-                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
-  {
-    if (solverType == IntegrationSolverType::RK4_TYPE)
-    {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
-        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
-    }
-    else if (solverType == IntegrationSolverType::EULER_TYPE)
-    {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  static void Advect(const VelocityFieldType& velField1,
-                     const vtkm::cont::DataSet& ds1,
-                     vtkm::FloatDefault t1,
-                     const VelocityFieldType& velField2,
-                     const vtkm::cont::DataSet& ds2,
-                     vtkm::FloatDefault t2,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& solverType,
-                     vtkm::worklet::StreamlineResult<ParticleType>& result)
-  {
-    if (solverType == IntegrationSolverType::RK4_TYPE)
-    {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
-        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
-    }
-    else if (solverType == IntegrationSolverType::EULER_TYPE)
-    {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  template <typename WorkletType,
-            template <typename>
-            class ResultType,
-            template <typename>
-            class SolverType>
-  static void DoAdvect(const VelocityFieldType& velField1,
-                       const vtkm::cont::DataSet& ds1,
-                       vtkm::FloatDefault t1,
-                       const VelocityFieldType& velField2,
-                       const vtkm::cont::DataSet& ds2,
-                       vtkm::FloatDefault t2,
-                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                       vtkm::FloatDefault stepSize,
-                       vtkm::Id maxSteps,
-                       ResultType<ParticleType>& result)
-  {
-    using StepperType =
-      vtkm::worklet::particleadvection::Stepper<SolverType<UnsteadyStateGridEvalType>,
-                                                UnsteadyStateGridEvalType>;
-
-    WorkletType worklet;
-    UnsteadyStateGridEvalType eval(ds1, t1, velField1, ds2, t2, velField2);
-    StepperType stepper(eval, stepSize);
-    result = worklet.Run(stepper, seedArray, maxSteps);
-  }
-};
-
-
-
-VTKM_CONT void SteadyStateDSI::DoAdvect(DSIStuff<vtkm::Particle>& b,
-                                        vtkm::FloatDefault stepSize,
-                                        vtkm::Id maxSteps)
-{
-  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
-  auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
-  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
-  {
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-    FieldType velField;
-    this->GetVelocityField(velField);
-
-    using AHType = AdvectHelper<SteadyStateGridEvalType, vtkm::Particle>;
-
-    if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
-    {
-      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
-      AHType::Advect(
-        velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
-      this->UpdateResult(result, b);
-      std::cout << __LINE__ << " ::DoAdvect: " << b.TermIdx.size() << std::endl;
-    }
-    else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
-    {
-      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
-      AHType::Advect(
-        velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
-      this->UpdateResult(result, b);
-      std::cout << __LINE__ << " ::DoAdvect: " << b.TermIdx.size() << std::endl;
-    }
-  }
-}
-
-VTKM_CONT void SteadyStateDSI::DoAdvect(DSIStuff<vtkm::ChargedParticle>& b,
-                                        vtkm::FloatDefault stepSize,
-                                        vtkm::Id maxSteps)
-{
-}
-
-
-VTKM_CONT void UnsteadyStateDSI::DoAdvect(DSIStuff<vtkm::Particle>& b,
-                                          vtkm::FloatDefault stepSize,
-                                          vtkm::Id maxSteps)
-{
-  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
-  auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
-
-  using AHType = AdvectHelper<UnsteadyStateGridEvalType, vtkm::Particle>;
-
-  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
-  {
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-    FieldType velField1, velField2;
-    this->GetVelocityFields(velField1, velField2);
-
-    if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
-    {
-      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
-      AHType::Advect(velField1,
-                     this->DataSet1,
-                     this->Time1,
-                     velField2,
-                     this->DataSet2,
-                     this->Time2,
-                     seedArray,
-                     stepSize,
-                     maxSteps,
-                     this->SolverType,
-                     result);
-      this->UpdateResult(result, b);
-    }
-    else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
-    {
-      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
-      AHType::Advect(velField1,
-                     this->DataSet1,
-                     this->Time1,
-                     velField2,
-                     this->DataSet2,
-                     this->Time2,
-                     seedArray,
-                     stepSize,
-                     maxSteps,
-                     this->SolverType,
-                     result);
-      this->UpdateResult(result, b);
-    }
-  }
-}
-
-VTKM_CONT void UnsteadyStateDSI::DoAdvect(DSIStuff<vtkm::ChargedParticle>& b,
-                                          vtkm::FloatDefault stepSize,
-                                          vtkm::Id maxSteps)
-{
-}
-
-
 
 }
 }
 }
 
-#endif //vtk_m_filter_DSI_hxx
+#endif //vtk_m_filter_particleadvection_DSI_hxx
diff --git a/vtkm/filter/particleadvection/DSISteadyState.h b/vtkm/filter/particleadvection/DSISteadyState.h
new file mode 100644
index 000000000..31048b39e
--- /dev/null
+++ b/vtkm/filter/particleadvection/DSISteadyState.h
@@ -0,0 +1,74 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_particleadvection_DSISteadyState_h
+#define vtk_m_filter_particleadvection_DSISteadyState_h
+
+#include <vtkm/filter/particleadvection/DSI.h>
+
+namespace vtkm
+{
+namespace filter
+{
+namespace particleadvection
+{
+
+class DSISteadyState : public vtkm::filter::particleadvection::DSI
+{
+public:
+  DSISteadyState(const vtkm::cont::DataSet& ds,
+                 vtkm::Id id,
+                 const FieldNameType& fieldName,
+                 vtkm::filter::particleadvection::IntegrationSolverType solverType,
+                 vtkm::filter::particleadvection::VectorFieldType vecFieldType,
+                 vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
+    : vtkm::filter::particleadvection::DSI(id, fieldName, solverType, vecFieldType, resultType)
+    , DataSet(ds)
+  {
+  }
+
+  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) override;
+
+  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) override;
+
+protected:
+  template <typename ArrayType>
+  VTKM_CONT void GetVelocityField(
+    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
+  {
+    if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<VelocityFieldNameType>())
+    {
+      const auto& fieldNm = this->FieldName.Get<VelocityFieldNameType>();
+      auto assoc = this->DataSet.GetField(fieldNm).GetAssociation();
+      ArrayType arr;
+      vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(fieldNm).GetData(), arr);
+
+      velocityField = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr, assoc);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
+  }
+
+
+private:
+  vtkm::cont::DataSet DataSet;
+};
+
+}
+}
+}
+
+#include <vtkm/filter/particleadvection/DSISteadyState.hxx>
+
+#endif //vtk_m_filter_particleadvection_DSISteadyState_h
diff --git a/vtkm/filter/particleadvection/DSISteadyState.hxx b/vtkm/filter/particleadvection/DSISteadyState.hxx
new file mode 100644
index 000000000..c82ac32cf
--- /dev/null
+++ b/vtkm/filter/particleadvection/DSISteadyState.hxx
@@ -0,0 +1,154 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_particleadvection_DSISteadyState_hxx
+#define vtk_m_filter_particleadvection_DSISteadyState_hxx
+
+namespace vtkm
+{
+namespace filter
+{
+namespace particleadvection
+{
+
+namespace internal
+{
+using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+using SteadyStateGridEvalType = vtkm::worklet::particleadvection::GridEvaluator<VelocityFieldType>;
+
+template <typename GridEvalType, typename ParticleType>
+class AdvectHelper;
+
+template <typename ParticleType>
+class AdvectHelper<SteadyStateGridEvalType, ParticleType>
+{
+public:
+  static void Advect(const VelocityFieldType& velField,
+                     const vtkm::cont::DataSet& ds,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  static void Advect(const VelocityFieldType& velField,
+                     const vtkm::cont::DataSet& ds,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::StreamlineResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  template <typename WorkletType,
+            template <typename>
+            class ResultType,
+            template <typename>
+            class SolverType>
+  static void DoAdvect(const VelocityFieldType& velField,
+                       const vtkm::cont::DataSet& ds,
+                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                       vtkm::FloatDefault stepSize,
+                       vtkm::Id maxSteps,
+                       ResultType<ParticleType>& result)
+  {
+    using StepperType =
+      vtkm::worklet::particleadvection::Stepper<SolverType<SteadyStateGridEvalType>,
+                                                SteadyStateGridEvalType>;
+
+    WorkletType worklet;
+    SteadyStateGridEvalType eval(ds, velField);
+    StepperType stepper(eval, stepSize);
+    result = worklet.Run(stepper, seedArray, maxSteps);
+  }
+};
+}
+
+VTKM_CONT void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                        vtkm::FloatDefault stepSize,
+                                        vtkm::Id maxSteps)
+{
+  using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+
+  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
+  auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
+
+  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
+  {
+    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+    FieldType velField;
+    this->GetVelocityField(velField);
+
+    using AHType = internal::AdvectHelper<internal::SteadyStateGridEvalType, vtkm::Particle>;
+
+    if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+    {
+      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
+      AHType::Advect(
+        velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
+      this->UpdateResult(result, b);
+    }
+    else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
+    {
+      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
+      AHType::Advect(
+        velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
+      this->UpdateResult(result, b);
+    }
+  }
+}
+
+VTKM_CONT void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
+                                        vtkm::FloatDefault stepSize,
+                                        vtkm::Id maxSteps)
+{
+}
+
+}
+}
+}
+
+#endif //vtk_m_filter_particleadvection_DSISteadyState_hxx
diff --git a/vtkm/filter/particleadvection/DSIUnsteadyState.h b/vtkm/filter/particleadvection/DSIUnsteadyState.h
new file mode 100644
index 000000000..1b19438f6
--- /dev/null
+++ b/vtkm/filter/particleadvection/DSIUnsteadyState.h
@@ -0,0 +1,89 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_particleadvection_DSIUnsteadyState_h
+#define vtk_m_filter_particleadvection_DSIUnsteadyState_h
+
+#include <vtkm/filter/particleadvection/DSI.h>
+
+namespace vtkm
+{
+namespace filter
+{
+namespace particleadvection
+{
+
+class DSIUnsteadyState : public vtkm::filter::particleadvection::DSI
+{
+public:
+  DSIUnsteadyState(const vtkm::cont::DataSet& ds1,
+                   const vtkm::cont::DataSet& ds2,
+                   vtkm::FloatDefault t1,
+                   vtkm::FloatDefault t2,
+                   vtkm::Id id,
+                   const vtkm::filter::particleadvection::DSI::FieldNameType& fieldName,
+                   vtkm::filter::particleadvection::IntegrationSolverType solverType,
+                   vtkm::filter::particleadvection::VectorFieldType vecFieldType,
+                   vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
+    : vtkm::filter::particleadvection::DSI(id, fieldName, solverType, vecFieldType, resultType)
+    , DataSet1(ds1)
+    , DataSet2(ds2)
+    , Time1(t1)
+    , Time2(t2)
+  {
+  }
+
+  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) override;
+
+  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
+                                  vtkm::FloatDefault stepSize,
+                                  vtkm::Id maxSteps) override;
+
+protected:
+  template <typename ArrayType>
+  VTKM_CONT void GetVelocityFields(
+    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField1,
+    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField2) const
+  {
+    if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<VelocityFieldNameType>())
+    {
+      const auto& fieldNm = this->FieldName.Get<VelocityFieldNameType>();
+      auto assoc = this->DataSet1.GetField(fieldNm).GetAssociation();
+      if (assoc != this->DataSet2.GetField(fieldNm).GetAssociation())
+        throw vtkm::cont::ErrorFilterExecution(
+          "Unsteady state velocity fields have differnt associations");
+
+      ArrayType arr1, arr2;
+      vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet1.GetField(fieldNm).GetData(), arr1);
+      vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet2.GetField(fieldNm).GetData(), arr2);
+
+      velocityField1 = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr1, assoc);
+      velocityField2 = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr2, assoc);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
+  }
+
+private:
+  vtkm::cont::DataSet DataSet1;
+  vtkm::cont::DataSet DataSet2;
+  vtkm::FloatDefault Time1;
+  vtkm::FloatDefault Time2;
+};
+
+}
+}
+}
+
+#include <vtkm/filter/particleadvection/DSIUnsteadyState.hxx>
+
+#endif //vtk_m_filter_particleadvection_DSIUnsteadyState_h
diff --git a/vtkm/filter/particleadvection/DSIUnsteadyState.hxx b/vtkm/filter/particleadvection/DSIUnsteadyState.hxx
new file mode 100644
index 000000000..e61244822
--- /dev/null
+++ b/vtkm/filter/particleadvection/DSIUnsteadyState.hxx
@@ -0,0 +1,182 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_particleadvection_DSIUnsteadyState_hxx
+#define vtk_m_filter_particleadvection_DSIUnsteadyState_hxx
+namespace vtkm
+{
+namespace filter
+{
+namespace particleadvection
+{
+
+namespace internal
+{
+using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+using UnsteadyStateGridEvalType =
+  vtkm::worklet::particleadvection::TemporalGridEvaluator<VelocityFieldType>;
+
+template <typename ParticleType>
+class AdvectHelper<UnsteadyStateGridEvalType, ParticleType>
+{
+public:
+  static void Advect(const VelocityFieldType& velField1,
+                     const vtkm::cont::DataSet& ds1,
+                     vtkm::FloatDefault t1,
+                     const VelocityFieldType& velField2,
+                     const vtkm::cont::DataSet& ds2,
+                     vtkm::FloatDefault t2,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  static void Advect(const VelocityFieldType& velField1,
+                     const vtkm::cont::DataSet& ds1,
+                     vtkm::FloatDefault t1,
+                     const VelocityFieldType& velField2,
+                     const vtkm::cont::DataSet& ds2,
+                     vtkm::FloatDefault t2,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::StreamlineResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  template <typename WorkletType,
+            template <typename>
+            class ResultType,
+            template <typename>
+            class SolverType>
+  static void DoAdvect(const VelocityFieldType& velField1,
+                       const vtkm::cont::DataSet& ds1,
+                       vtkm::FloatDefault t1,
+                       const VelocityFieldType& velField2,
+                       const vtkm::cont::DataSet& ds2,
+                       vtkm::FloatDefault t2,
+                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                       vtkm::FloatDefault stepSize,
+                       vtkm::Id maxSteps,
+                       ResultType<ParticleType>& result)
+  {
+    using StepperType =
+      vtkm::worklet::particleadvection::Stepper<SolverType<UnsteadyStateGridEvalType>,
+                                                UnsteadyStateGridEvalType>;
+
+    WorkletType worklet;
+    UnsteadyStateGridEvalType eval(ds1, t1, velField1, ds2, t2, velField2);
+    StepperType stepper(eval, stepSize);
+    result = worklet.Run(stepper, seedArray, maxSteps);
+  }
+};
+
+}
+
+VTKM_CONT void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                          vtkm::FloatDefault stepSize,
+                                          vtkm::Id maxSteps)
+{
+  using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+
+  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
+  auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
+
+  using AHType = internal::AdvectHelper<internal::UnsteadyStateGridEvalType, vtkm::Particle>;
+
+  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
+  {
+    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+    FieldType velField1, velField2;
+    this->GetVelocityFields(velField1, velField2);
+
+    if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+    {
+      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
+      AHType::Advect(velField1,
+                     this->DataSet1,
+                     this->Time1,
+                     velField2,
+                     this->DataSet2,
+                     this->Time2,
+                     seedArray,
+                     stepSize,
+                     maxSteps,
+                     this->SolverType,
+                     result);
+      this->UpdateResult(result, b);
+    }
+    else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
+    {
+      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
+      AHType::Advect(velField1,
+                     this->DataSet1,
+                     this->Time1,
+                     velField2,
+                     this->DataSet2,
+                     this->Time2,
+                     seedArray,
+                     stepSize,
+                     maxSteps,
+                     this->SolverType,
+                     result);
+      this->UpdateResult(result, b);
+    }
+  }
+}
+
+VTKM_CONT void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
+                                          vtkm::FloatDefault stepSize,
+                                          vtkm::Id maxSteps)
+{
+}
+
+}
+}
+}
+
+#endif //vtk_m_filter_particleadvection_DSIUnsteadyState_hxx
diff --git a/vtkm/worklet/ParticleAdvection.h b/vtkm/worklet/ParticleAdvection.h
index 1cd2397aa..4c2896ff2 100644
--- a/vtkm/worklet/ParticleAdvection.h
+++ b/vtkm/worklet/ParticleAdvection.h
@@ -55,45 +55,13 @@ struct ParticleAdvectionResult
   ParticleAdvectionResult()
     : Particles()
   {
-    std::cout << "PAR ctor0  ptr= " << (void*)this << " pPtr= " << (void*)&(this->Particles)
-              << std::endl;
   }
 
   ParticleAdvectionResult(const vtkm::cont::ArrayHandle<ParticleType>& p)
     : Particles(p)
   {
-    std::cout << "PAR ctor1  ptr= " << (void*)this << " pPtr= " << (void*)&(this->Particles)
-              << std::endl;
   }
 
-  /*
-  ParticleAdvectionResult(const vtkm::worklet::ParticleAdvectionResult<ParticleType>& pr)
-    : Particles(pr.Particles)
-  {
-    std::cout<<"PAR ctor2  ptr= "<<(void*)this<<" pPtr= "<<(void*)&(this->Particles)<<std::endl;
-  }
-
-
-  ~ParticleAdvectionResult()
-  {
-    std::cout<<"**** Tossing a PAResult= "<<(void*)this<<" pPtr= "<<(void*)(&this->Particles)<<std::endl;
-  }
-
-  vtkm::worklet::ParticleAdvectionResult<ParticleType>&
-  operator=(const vtkm::worklet::ParticleAdvectionResult<ParticleType>& src)
-  {
-    this->Particles = src.Particles;
-    return *this;
-  }
-
-  vtkm::worklet::ParticleAdvectionResult<ParticleType>&
-  operator=(const vtkm::worklet::ParticleAdvectionResult<ParticleType>&& src)
-  {
-    this->Particles = src.Particles;
-    return *this;
-  }
-  */
-
   vtkm::cont::ArrayHandle<ParticleType> Particles;
 };
 

From 29ca23bfe698ebb6c1d4db3a94b59017fce0ad9f Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 15 Jul 2022 12:44:51 -0400
Subject: [PATCH 019/104] Code cleanup.

---
 vtkm/filter/particleadvection/ABA.h           | 12 ----
 vtkm/filter/particleadvection/DSI.h           | 25 +++++--
 vtkm/filter/particleadvection/DSI.hxx         | 69 ++++++++-----------
 .../particleadvection/DSISteadyState.hxx      | 14 ++--
 .../particleadvection/DSIUnsteadyState.hxx    | 14 ++--
 .../testing/UnitTestStreamlineFilter.cxx      | 10 ---
 6 files changed, 66 insertions(+), 78 deletions(-)

diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/ABA.h
index 80f6f4ba6..f42da9c20 100644
--- a/vtkm/filter/particleadvection/ABA.h
+++ b/vtkm/filter/particleadvection/ABA.h
@@ -57,9 +57,6 @@ public:
         output.AppendPartition(ds);
     }
 
-    //std::cout<<"GetOutput: "<<__FILE__<<" "<<__LINE__<<std::endl;
-    //output.PrintSummary(std::cout);
-
     return output;
   }
 
@@ -71,7 +68,6 @@ public:
 
     vtkm::Id n = seeds.GetNumberOfValues();
     auto portal = seeds.ReadPortal();
-    std::cout << "SetSeeds: n= " << n << std::endl;
 
     std::vector<std::vector<vtkm::Id>> blockIDs;
     std::vector<ParticleType> particles;
@@ -79,9 +75,6 @@ public:
     {
       const ParticleType p = portal.Get(i);
       std::vector<vtkm::Id> ids = this->BoundsMap.FindBlocks(p.Pos);
-      std::cout << "  " << i << " " << p.Pos << " ids= " << ids.size()
-                << " BM= " << this->BoundsMap.GlobalBounds << " "
-                << this->BoundsMap.FindRank(ids[0]) << " " << this->Rank << std::endl;
 
       if (!ids.empty() && this->BoundsMap.FindRank(ids[0]) == this->Rank)
       {
@@ -93,7 +86,6 @@ public:
     this->SetSeedArray(particles, blockIDs);
   }
 
-
   //Advect all the particles.
   virtual void Go()
   {
@@ -103,8 +95,6 @@ public:
     vtkm::Id nLocal = static_cast<vtkm::Id>(this->Active.size() + this->Inactive.size());
     this->ComputeTotalNumParticles(nLocal);
     this->TotalNumTerminatedParticles = 0;
-    std::cout << "Go() nParticles= " << nLocal << std::endl;
-    std::cout << "    BM= " << this->BoundsMap.GlobalBounds << std::endl;
 
     while (this->TotalNumTerminatedParticles < this->TotalNumParticles)
     {
@@ -118,7 +108,6 @@ public:
           DSIHelperInfo<ParticleType>(v, this->BoundsMap, this->ParticleBlockIDsMap);
         block->Advect(bb, this->StepSize, this->NumberOfSteps);
         numTerm = this->UpdateResult(bb.Get<DSIHelperInfo<ParticleType>>());
-        std::cout << " Advect: " << v.size() << " NT= " << numTerm << std::endl;
       }
 
       vtkm::Id numTermMessages = 0;
@@ -172,7 +161,6 @@ public:
     }
 
     this->Active.insert(this->Active.end(), particles.begin(), particles.end());
-    std::cout << " numActive= " << this->Active.size() << " p= " << particles.size() << std::endl;
   }
 
   virtual bool GetActiveParticles(std::vector<ParticleType>& particles, vtkm::Id& blockId)
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index e547b94ea..2853001c7 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -41,11 +41,12 @@ public:
   {
   }
 
-  std::vector<ParticleType> V, A, I;
-  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> IdMapA, IdMapI;
-  std::vector<vtkm::Id> TermIdx, TermID;
   const vtkm::filter::particleadvection::BoundsMap BoundsMap;
   const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
+
+  std::vector<ParticleType> A, I, V;
+  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> IdMapA, IdMapI;
+  std::vector<vtkm::Id> TermIdx, TermID;
 };
 
 using DSIHelperInfoType = vtkm::cont::internal::Variant<DSIHelperInfo<vtkm::Particle>,
@@ -75,7 +76,7 @@ public:
     , Id(id)
     , SolverType(solverType)
     , VecFieldType(vecFieldType)
-    , ResType(resultType)
+    , AdvectionResType(resultType)
     , Rank(this->Comm.rank())
   {
     //check that things are valid.
@@ -110,9 +111,19 @@ public:
 protected:
   template <typename ParticleType, template <typename> class ResultType>
   VTKM_CONT void UpdateResult(const ResultType<ParticleType>& result,
-                              DSIHelperInfo<ParticleType>& stuff);
+                              DSIHelperInfo<ParticleType>& dsiInfo);
 
 protected:
+  VTKM_CONT bool IsParticleAdvectionResult() const
+  {
+    return this->AdvectionResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE;
+  }
+
+  VTKM_CONT bool IsStreamlineResult() const
+  {
+    return this->AdvectionResType == ParticleAdvectionResultType::STREAMLINE_TYPE;
+  }
+
   VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
                                   vtkm::FloatDefault stepSize,
                                   vtkm::Id maxSteps) = 0;
@@ -123,7 +134,7 @@ protected:
 
   template <typename ParticleType>
   VTKM_CONT void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
-                                   DSIHelperInfo<ParticleType>& stuff) const;
+                                   DSIHelperInfo<ParticleType>& dsiInfo) const;
 
   //Data members.
   vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType> FieldName;
@@ -131,7 +142,7 @@ protected:
   vtkm::Id Id;
   vtkm::filter::particleadvection::IntegrationSolverType SolverType;
   vtkm::filter::particleadvection::VectorFieldType VecFieldType;
-  vtkm::filter::particleadvection::ParticleAdvectionResultType ResType =
+  vtkm::filter::particleadvection::ParticleAdvectionResultType AdvectionResType =
     vtkm::filter::particleadvection::ParticleAdvectionResultType::UNKNOWN_TYPE;
 
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index 4d94fb5ee..5234e6d0e 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -20,14 +20,14 @@ namespace particleadvection
 
 template <typename ParticleType>
 VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
-                                      DSIHelperInfo<ParticleType>& stuff) const
+                                      DSIHelperInfo<ParticleType>& dsiInfo) const
 {
-  stuff.A.clear();
-  stuff.I.clear();
-  stuff.TermID.clear();
-  stuff.TermIdx.clear();
-  stuff.IdMapI.clear();
-  stuff.IdMapA.clear();
+  dsiInfo.A.clear();
+  dsiInfo.I.clear();
+  dsiInfo.TermID.clear();
+  dsiInfo.TermIdx.clear();
+  dsiInfo.IdMapI.clear();
+  dsiInfo.IdMapA.clear();
 
   auto portal = particles.WritePortal();
   vtkm::Id n = portal.GetNumberOfValues();
@@ -38,13 +38,13 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
 
     if (p.Status.CheckTerminate())
     {
-      stuff.TermIdx.push_back(i);
-      stuff.TermID.push_back(p.ID);
+      dsiInfo.TermIdx.push_back(i);
+      dsiInfo.TermID.push_back(p.ID);
     }
     else
     {
-      const auto& it = stuff.ParticleBlockIDsMap.find(p.ID);
-      VTKM_ASSERT(it != stuff.ParticleBlockIDsMap.end());
+      const auto& it = dsiInfo.ParticleBlockIDsMap.find(p.ID);
+      VTKM_ASSERT(it != dsiInfo.ParticleBlockIDsMap.end());
       auto currBIDs = it->second;
       VTKM_ASSERT(!currBIDs.empty());
 
@@ -52,7 +52,7 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
       if (p.Status.CheckSpatialBounds() && !p.Status.CheckTookAnySteps())
         newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
       else
-        newIDs = stuff.BoundsMap.FindBlocks(p.Pos, currBIDs);
+        newIDs = dsiInfo.BoundsMap.FindBlocks(p.Pos, currBIDs);
 
       //reset the particle status.
       p.Status = vtkm::ParticleStatus();
@@ -60,8 +60,8 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
       if (newIDs.empty()) //No blocks, we're done.
       {
         p.Status.SetTerminate();
-        stuff.TermIdx.push_back(i);
-        stuff.TermID.push_back(p.ID);
+        dsiInfo.TermIdx.push_back(i);
+        dsiInfo.TermID.push_back(p.ID);
       }
       else
       {
@@ -72,7 +72,7 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
           for (auto idit = newIDs.begin(); idit != newIDs.end(); idit++)
           {
             vtkm::Id bid = *idit;
-            if (stuff.BoundsMap.FindRank(bid) == this->Rank)
+            if (dsiInfo.BoundsMap.FindRank(bid) == this->Rank)
             {
               newIDs.erase(idit);
               newIDs.insert(newIDs.begin(), bid);
@@ -81,16 +81,16 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
           }
         }
 
-        int dstRank = stuff.BoundsMap.FindRank(newIDs[0]);
+        int dstRank = dsiInfo.BoundsMap.FindRank(newIDs[0]);
         if (dstRank == this->Rank)
         {
-          stuff.A.push_back(p);
-          stuff.IdMapA[p.ID] = newIDs;
+          dsiInfo.A.push_back(p);
+          dsiInfo.IdMapA[p.ID] = newIDs;
         }
         else
         {
-          stuff.I.push_back(p);
-          stuff.IdMapI[p.ID] = newIDs;
+          dsiInfo.I.push_back(p);
+          dsiInfo.IdMapI[p.ID] = newIDs;
         }
       }
       portal.Set(i, p);
@@ -99,25 +99,23 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
 
   //Make sure we didn't miss anything. Every particle goes into a single bucket.
   VTKM_ASSERT(static_cast<std::size_t>(n) ==
-              (stuff.A.size() + stuff.I.size() + stuff.TermIdx.size()));
-  VTKM_ASSERT(stuff.TermIdx.size() == stuff.TermID.size());
+              (dsiInfo.A.size() + dsiInfo.I.size() + dsiInfo.TermIdx.size()));
+  VTKM_ASSERT(dsiInfo.TermIdx.size() == dsiInfo.TermID.size());
 }
 
 template <typename ParticleType, template <typename> class ResultType>
 VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
-                                 DSIHelperInfo<ParticleType>& stuff)
+                                 DSIHelperInfo<ParticleType>& dsiInfo)
 {
-  this->ClassifyParticles(result.Particles, stuff);
+  this->ClassifyParticles(result.Particles, dsiInfo);
 
-  //template this for PA and SL
-  if (this->ResType ==
-      vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+  if (this->IsParticleAdvectionResult())
   {
-    if (stuff.TermIdx.empty())
+    if (dsiInfo.TermIdx.empty())
       return;
 
     using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
-    auto indicesAH = vtkm::cont::make_ArrayHandle(stuff.TermIdx, vtkm::CopyFlag::Off);
+    auto indicesAH = vtkm::cont::make_ArrayHandle(dsiInfo.TermIdx, vtkm::CopyFlag::Off);
     auto termPerm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, result.Particles);
 
     vtkm::cont::ArrayHandle<ParticleType> termParticles;
@@ -126,11 +124,8 @@ VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
     ResType termRes(termParticles);
     this->Results.push_back(termRes);
   }
-  else if (this->ResType ==
-           vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
-  {
+  else if (this->IsStreamlineResult())
     this->Results.push_back(result);
-  }
 }
 
 template <typename ParticleType>
@@ -140,9 +135,7 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
   if (nResults == 0)
     return false;
 
-  std::cout << "Check the variant type!" << std::endl;
-
-  if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+  if (this->IsParticleAdvectionResult())
   {
     using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
 
@@ -153,8 +146,6 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
 
     vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
     vtkm::cont::ParticleArrayCopy(allParticles, pts);
-    std::cout << "DSI::GetOutput() pts= ";
-    vtkm::cont::printSummary_ArrayHandle(pts, std::cout);
 
     vtkm::Id numPoints = pts.GetNumberOfValues();
     if (numPoints > 0)
@@ -171,7 +162,7 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
       ds.SetCellSet(cells);
     }
   }
-  else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
+  else if (this->IsStreamlineResult())
   {
     using ResType = vtkm::worklet::StreamlineResult<ParticleType>;
 
diff --git a/vtkm/filter/particleadvection/DSISteadyState.hxx b/vtkm/filter/particleadvection/DSISteadyState.hxx
index c82ac32cf..ce79794fc 100644
--- a/vtkm/filter/particleadvection/DSISteadyState.hxx
+++ b/vtkm/filter/particleadvection/DSISteadyState.hxx
@@ -124,26 +124,30 @@ VTKM_CONT void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
 
     using AHType = internal::AdvectHelper<internal::SteadyStateGridEvalType, vtkm::Particle>;
 
-    if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+    if (this->IsParticleAdvectionResult())
     {
       vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
       AHType::Advect(
         velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
       this->UpdateResult(result, b);
     }
-    else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
+    else if (this->IsStreamlineResult())
     {
       vtkm::worklet::StreamlineResult<vtkm::Particle> result;
       AHType::Advect(
         velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
       this->UpdateResult(result, b);
     }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported result type");
   }
+  else
+    throw vtkm::cont::ErrorFilterExecution("Unsupported vector field type");
 }
 
-VTKM_CONT void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
-                                        vtkm::FloatDefault stepSize,
-                                        vtkm::Id maxSteps)
+VTKM_CONT void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
+                                        vtkm::FloatDefault vtkmNotUsed(stepSize),
+                                        vtkm::Id vtkmNotUsed(maxSteps))
 {
 }
 
diff --git a/vtkm/filter/particleadvection/DSIUnsteadyState.hxx b/vtkm/filter/particleadvection/DSIUnsteadyState.hxx
index e61244822..0fd591dd0 100644
--- a/vtkm/filter/particleadvection/DSIUnsteadyState.hxx
+++ b/vtkm/filter/particleadvection/DSIUnsteadyState.hxx
@@ -134,7 +134,7 @@ VTKM_CONT void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
     FieldType velField1, velField2;
     this->GetVelocityFields(velField1, velField2);
 
-    if (this->ResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+    if (this->IsParticleAdvectionResult())
     {
       vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
       AHType::Advect(velField1,
@@ -150,7 +150,7 @@ VTKM_CONT void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
                      result);
       this->UpdateResult(result, b);
     }
-    else if (this->ResType == ParticleAdvectionResultType::STREAMLINE_TYPE)
+    else if (this->IsStreamlineResult())
     {
       vtkm::worklet::StreamlineResult<vtkm::Particle> result;
       AHType::Advect(velField1,
@@ -166,12 +166,16 @@ VTKM_CONT void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
                      result);
       this->UpdateResult(result, b);
     }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported result type");
   }
+  else
+    throw vtkm::cont::ErrorFilterExecution("Unsupported vector field type");
 }
 
-VTKM_CONT void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
-                                          vtkm::FloatDefault stepSize,
-                                          vtkm::Id maxSteps)
+VTKM_CONT void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
+                                          vtkm::FloatDefault vtkmNotUsed(stepSize),
+                                          vtkm::Id vtkmNotUsed(maxSteps))
 {
 }
 
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index 2de35bc12..61274979c 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -416,9 +416,6 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
         out = pathline.Execute(pds);
       }
 
-      std::cout << "Num IN DS= " << pds.GetNumberOfPartitions() << std::endl;
-      out.PrintSummary(std::cout);
-
       for (vtkm::Id i = 0; i < num; i++)
       {
         auto outputDS = out.GetPartition(i);
@@ -485,11 +482,6 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
       }
 
 
-      std::cout << "*************************************************************" << std::endl;
-      std::cout << "*************************************************************" << std::endl;
-      std::cout << "*************************************************************" << std::endl;
-      std::cout << "DS.NumP()= " << out.GetNumberOfPartitions()
-                << " pds.NumP()= " << pds.GetNumberOfPartitions() << std::endl;
       VTKM_TEST_ASSERT(out.GetNumberOfPartitions() == 1, "Wrong number of partitions in output");
       auto ds = out.GetPartition(0);
       //Validate the result is correct.
@@ -625,8 +617,6 @@ void TestStreamlineFilters()
   for (auto useSL : flags)
     TestAMRStreamline(useSL);
 
-  return;
-
   //Fusion test.
   std::vector<vtkm::Vec3f> fusionPts, fusionEndPts;
   fusionPts.push_back(vtkm::Vec3f(0.8f, 0.6f, 0.6f));

From 7111a8b939e718605e2d03f0c937c4104222028a Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 15 Jul 2022 15:15:14 -0400
Subject: [PATCH 020/104] move pa filters to NewFilter

---
 vtkm/Particle.h                            |   8 ++
 vtkm/filter/NewFilterParticleAdvection.h   | 148 +++++++++++++++++++++
 vtkm/filter/NewFilterParticleAdvection.hxx | 104 +++++++++++++++
 vtkm/filter/ParticleAdvection2.h           |  27 +---
 vtkm/filter/ParticleAdvection2.hxx         |  54 +-------
 vtkm/filter/Pathline2.h                    |  35 +----
 vtkm/filter/Pathline2.hxx                  |  59 +-------
 vtkm/filter/Streamline2.h                  |  26 +---
 vtkm/filter/Streamline2.hxx                |  53 +-------
 9 files changed, 293 insertions(+), 221 deletions(-)
 create mode 100644 vtkm/filter/NewFilterParticleAdvection.h
 create mode 100644 vtkm/filter/NewFilterParticleAdvection.hxx

diff --git a/vtkm/Particle.h b/vtkm/Particle.h
index 32ae7b214..6e545446c 100644
--- a/vtkm/Particle.h
+++ b/vtkm/Particle.h
@@ -228,6 +228,14 @@ public:
     return this->Pos + translation;
   }
 
+  inline VTKM_CONT friend std::ostream& operator<<(std::ostream& out,
+                                                   const vtkm::ChargedParticle& p)
+  {
+    out << "v(" << p.Time << ") = " << p.Pos << ", ID: " << p.ID << ", NumSteps: " << p.NumSteps
+        << ", Status: " << p.Status;
+    return out;
+  }
+
   vtkm::Vec3f Pos;
   vtkm::Id ID = -1;
   vtkm::Id NumSteps = 0;
diff --git a/vtkm/filter/NewFilterParticleAdvection.h b/vtkm/filter/NewFilterParticleAdvection.h
new file mode 100644
index 000000000..a9e41f0c9
--- /dev/null
+++ b/vtkm/filter/NewFilterParticleAdvection.h
@@ -0,0 +1,148 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_NewFilterParticleAdvection_h
+#define vtk_m_filter_NewFilterParticleAdvection_h
+
+#include <vtkm/Particle.h>
+#include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/DSISteadyState.h>
+#include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+
+namespace vtkm
+{
+namespace filter
+{
+/// \brief base class for advecting particles in a vector field.
+
+/// Takes as input a vector field and seed locations and advects the seeds
+/// through the flow field.
+
+class NewFilterParticleAdvection : public vtkm::filter::NewFilterField
+{
+public:
+  using SupportedTypes = vtkm::TypeListFieldVec3;
+
+  VTKM_CONT
+  NewFilterParticleAdvection(vtkm::filter::particleadvection::ParticleAdvectionResultType rType);
+
+  VTKM_CONT
+  void SetStepSize(vtkm::FloatDefault s) { this->StepSize = s; }
+
+  VTKM_CONT
+  void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; }
+
+  template <typename ParticleType>
+  VTKM_CONT void SetSeeds(vtkm::cont::ArrayHandle<ParticleType>& seeds)
+  {
+    this->Seeds = seeds;
+  }
+
+  template <typename ParticleType>
+  VTKM_CONT void SetSeeds(const std::vector<ParticleType>& seeds,
+                          vtkm::CopyFlag copyFlag = vtkm::CopyFlag::On)
+  {
+    this->Seeds = vtkm::cont::make_ArrayHandle(seeds, copyFlag);
+  }
+
+  VTKM_CONT
+  void SetSolverRK4()
+  {
+    this->SolverType = vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE;
+  }
+  VTKM_CONT
+  void SetSolverEuler()
+  {
+    this->SolverType = vtkm::filter::particleadvection::IntegrationSolverType::EULER_TYPE;
+  }
+
+  VTKM_CONT
+  bool GetUseThreadedAlgorithm() { return this->UseThreadedAlgorithm; }
+
+  VTKM_CONT
+  void SetUseThreadedAlgorithm(bool val) { this->UseThreadedAlgorithm = val; }
+
+protected:
+  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override
+  {
+    auto out = this->DoExecutePartitions(inData);
+    if (out.GetNumberOfPartitions() != 1)
+      throw vtkm::cont::ErrorFilterExecution("Wrong number of results");
+
+    return out.GetPartition(0);
+  }
+
+  VTKM_CONT virtual void ValidateOptions() const;
+
+  vtkm::Id NumberOfSteps;
+  vtkm::filter::particleadvection::ParticleAdvectionResultType ResultType =
+    vtkm::filter::particleadvection::ParticleAdvectionResultType::UNKNOWN_TYPE;
+  vtkm::cont::UnknownArrayHandle Seeds;
+  vtkm::filter::particleadvection::IntegrationSolverType SolverType;
+  vtkm::FloatDefault StepSize;
+  bool UseThreadedAlgorithm;
+  vtkm::filter::particleadvection::VectorFieldType VecFieldType;
+
+private:
+};
+
+
+class NewFilterSteadyStateParticleAdvection : public NewFilterParticleAdvection
+{
+public:
+  VTKM_CONT
+  NewFilterSteadyStateParticleAdvection(
+    vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
+    : NewFilterParticleAdvection(rType)
+  {
+  }
+
+protected:
+  VTKM_CONT std::vector<vtkm::filter::particleadvection::DSISteadyState*> CreateDataSetIntegrators(
+    const vtkm::cont::PartitionedDataSet& input,
+    const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
+};
+
+class NewFilterUnsteadyStateParticleAdvection : public NewFilterParticleAdvection
+{
+public:
+  VTKM_CONT
+  NewFilterUnsteadyStateParticleAdvection(
+    vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
+    : NewFilterParticleAdvection(rType)
+  {
+  }
+
+  void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
+  void SetNextTime(vtkm::FloatDefault t2) { this->Time2 = t2; }
+  void SetNextDataSet(const vtkm::cont::DataSet& ds) { this->Input2 = { ds }; }
+  void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->Input2 = pds; }
+
+protected:
+  VTKM_CONT std::vector<vtkm::filter::particleadvection::DSIUnsteadyState*>
+  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
+                           const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
+
+  vtkm::cont::PartitionedDataSet Input2;
+  vtkm::FloatDefault Time1;
+  vtkm::FloatDefault Time2;
+};
+
+}
+} // namespace vtkm::filter
+
+#ifndef vtk_m_filter_NewFilterParticleAdvection_hxx
+#include <vtkm/filter/NewFilterParticleAdvection.hxx>
+#endif
+
+#endif // vtk_m_filter_NewFilterParticleAdvection_h
diff --git a/vtkm/filter/NewFilterParticleAdvection.hxx b/vtkm/filter/NewFilterParticleAdvection.hxx
new file mode 100644
index 000000000..e3abdd032
--- /dev/null
+++ b/vtkm/filter/NewFilterParticleAdvection.hxx
@@ -0,0 +1,104 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+#ifndef vtk_m_filter_NewFilterParticleAdvection_hxx
+#define vtk_m_filter_FilterParticleAdvection_hxx
+
+#include <vtkm/filter/NewFilterParticleAdvection.h>
+
+namespace vtkm
+{
+namespace filter
+{
+
+//-----------------------------------------------------------------------------
+inline VTKM_CONT NewFilterParticleAdvection::NewFilterParticleAdvection(
+  vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
+  : vtkm::filter::NewFilterField()
+  , NumberOfSteps(0)
+  , ResultType(rType)
+  , SolverType(vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE)
+  , StepSize(0)
+  , UseThreadedAlgorithm(false)
+  , VecFieldType(vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE)
+{
+}
+
+void NewFilterParticleAdvection::ValidateOptions() const
+{
+  if (this->GetUseCoordinateSystemAsField())
+    throw vtkm::cont::ErrorFilterExecution("Coordinate system as field not supported");
+  if (this->Seeds.GetNumberOfValues() == 0)
+    throw vtkm::cont::ErrorFilterExecution("No seeds provided.");
+  if (this->NumberOfSteps == 0)
+    throw vtkm::cont::ErrorFilterExecution("Number of steps not specified.");
+  if (this->StepSize == 0)
+    throw vtkm::cont::ErrorFilterExecution("Step size not specified.");
+}
+
+VTKM_CONT std::vector<vtkm::filter::particleadvection::DSISteadyState*>
+NewFilterSteadyStateParticleAdvection::CreateDataSetIntegrators(
+  const vtkm::cont::PartitionedDataSet& input,
+  const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
+{
+  using DSIType = vtkm::filter::particleadvection::DSISteadyState;
+
+  std::string activeField = this->GetActiveFieldName();
+
+  std::vector<DSIType*> dsi;
+  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
+  {
+    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
+    auto ds = input.GetPartition(i);
+    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
+      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
+
+    dsi.push_back(new DSIType(
+      ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
+  }
+
+  return dsi;
+}
+
+VTKM_CONT std::vector<vtkm::filter::particleadvection::DSIUnsteadyState*>
+NewFilterUnsteadyStateParticleAdvection::CreateDataSetIntegrators(
+  const vtkm::cont::PartitionedDataSet& input,
+  const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
+{
+  using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
+
+  std::string activeField = this->GetActiveFieldName();
+
+  std::vector<DSIType*> dsi;
+  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
+  {
+    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
+    auto ds1 = input.GetPartition(i);
+    auto ds2 = this->Input2.GetPartition(i);
+    if ((!ds1.HasPointField(activeField) && !ds1.HasCellField(activeField)) ||
+        (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
+      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
+
+    dsi.push_back(new DSIType(ds1,
+                              ds2,
+                              this->Time1,
+                              this->Time2,
+                              blockId,
+                              activeField,
+                              this->SolverType,
+                              this->VecFieldType,
+                              this->ResultType));
+  }
+
+  return dsi;
+}
+
+}
+} // namespace vtkm::filter
+#endif
diff --git a/vtkm/filter/ParticleAdvection2.h b/vtkm/filter/ParticleAdvection2.h
index 6fad92ed9..8c8ab9aa9 100644
--- a/vtkm/filter/ParticleAdvection2.h
+++ b/vtkm/filter/ParticleAdvection2.h
@@ -12,8 +12,8 @@
 #define vtk_m_filter_ParticleAdvection2_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/FilterParticleAdvection.h>
 #include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/NewFilterParticleAdvection.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
@@ -25,31 +25,18 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class ParticleAdvection2
-  : public vtkm::filter::FilterParticleAdvection<ParticleAdvection2, vtkm::Particle>
+class ParticleAdvection2 : public vtkm::filter::NewFilterSteadyStateParticleAdvection
 {
 public:
-  VTKM_CONT ParticleAdvection2();
-
-  template <typename DerivedPolicy>
-  vtkm::cont::PartitionedDataSet PrepareForExecution(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
-
-  vtkm::cont::UnknownArrayHandle SeedArray;
-};
-
-class ParticleAdvection3 : public vtkm::filter::NewFilterField
-{
-public:
-  //  VTKM_CONT ParticleAdvection3() {}
+  VTKM_CONT ParticleAdvection2()
+    : NewFilterSteadyStateParticleAdvection(
+        vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+  {
+  }
 
 protected:
-  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
-
-  vtkm::cont::UnknownArrayHandle SeedArray;
 };
 
 }
diff --git a/vtkm/filter/ParticleAdvection2.hxx b/vtkm/filter/ParticleAdvection2.hxx
index eb4903e7c..16fba05ef 100644
--- a/vtkm/filter/ParticleAdvection2.hxx
+++ b/vtkm/filter/ParticleAdvection2.hxx
@@ -13,8 +13,6 @@
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/ParticleAdvection2.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
 
 #include <vtkm/filter/particleadvection/DSISteadyState.h>
 #include <vtkm/filter/particleadvection/PAV.h>
@@ -25,63 +23,19 @@ namespace vtkm
 namespace filter
 {
 
-//-----------------------------------------------------------------------------
-inline VTKM_CONT ParticleAdvection2::ParticleAdvection2()
-  : vtkm::filter::FilterParticleAdvection<ParticleAdvection2, vtkm::Particle>()
+VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& input)
 {
-  this->ResultType =
-    vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE;
-}
-
-//-----------------------------------------------------------------------------
-template <typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::PrepareForExecution(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::PolicyBase<DerivedPolicy>&)
-{
-  //  return input;
-
-#if 1
   using DSIType = vtkm::filter::particleadvection::DSISteadyState;
-
   this->ValidateOptions();
-  //Make sure everything matches up ok.
-  this->VecFieldType = vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE;
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
-  std::string activeField = this->GetActiveFieldName();
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  std::vector<DSIType*> dsi;
-  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
-  {
-    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-    auto ds = input.GetPartition(i);
-    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
-      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
-
-    dsi.push_back(new DSIType(
-      ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
-  }
-
-  this->SeedArray = this->Seeds;
   vtkm::filter::particleadvection::PAV<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
-#endif
-}
 
-VTKM_CONT vtkm::cont::DataSet ParticleAdvection3::DoExecute(const vtkm::cont::DataSet& inData)
-{
-  std::cout << "Meow DS" << std::endl;
-  auto result = this->DoExecutePartitions(inData);
-  return result.GetPartition(0);
-}
-
-VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection3::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& inData)
-{
-  std::cout << "Meow pDS" << std::endl;
-  return inData;
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }
diff --git a/vtkm/filter/Pathline2.h b/vtkm/filter/Pathline2.h
index 35f49799d..cd70bcf3c 100644
--- a/vtkm/filter/Pathline2.h
+++ b/vtkm/filter/Pathline2.h
@@ -12,8 +12,8 @@
 #define vtk_m_filter_Pathline2_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/FilterParticleAdvection.h>
 #include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/NewFilterParticleAdvection.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
@@ -25,39 +25,18 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class Pathline2 : public vtkm::filter::FilterTemporalParticleAdvection<Pathline2, vtkm::Particle>
+class Pathline2 : public vtkm::filter::NewFilterUnsteadyStateParticleAdvection
 {
 public:
-  VTKM_CONT Pathline2();
-
-  template <typename DerivedPolicy>
-  vtkm::cont::PartitionedDataSet PrepareForExecution(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
-
-  vtkm::cont::UnknownArrayHandle SeedArray;
-
-  void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
-  void SetNextTime(vtkm::FloatDefault t2) { this->Time2 = t2; }
-  void SetNextDataSet(const vtkm::cont::DataSet& ds) { this->DataSet2 = { ds }; }
-  void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->DataSet2 = pds; }
-
-  vtkm::cont::PartitionedDataSet DataSet2;
-  vtkm::FloatDefault Time1;
-  vtkm::FloatDefault Time2;
-};
-
-class Pathline3 : public vtkm::filter::NewFilterField
-{
-public:
-  //  VTKM_CONT Pathline3() {}
+  VTKM_CONT Pathline2()
+    : NewFilterUnsteadyStateParticleAdvection(
+        vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
+  {
+  }
 
 protected:
-  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
-
-  vtkm::cont::UnknownArrayHandle SeedArray;
 };
 
 }
diff --git a/vtkm/filter/Pathline2.hxx b/vtkm/filter/Pathline2.hxx
index 2bb7e3d7c..106642a18 100644
--- a/vtkm/filter/Pathline2.hxx
+++ b/vtkm/filter/Pathline2.hxx
@@ -25,70 +25,19 @@ namespace vtkm
 namespace filter
 {
 
-//-----------------------------------------------------------------------------
-inline VTKM_CONT Pathline2::Pathline2()
-  : vtkm::filter::FilterTemporalParticleAdvection<Pathline2, vtkm::Particle>()
+VTKM_CONT vtkm::cont::PartitionedDataSet Pathline2::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& input)
 {
-  this->ResultType = vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE;
-}
-
-//-----------------------------------------------------------------------------
-template <typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::PartitionedDataSet Pathline2::PrepareForExecution(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::PolicyBase<DerivedPolicy>&)
-{
-//  return input;
-#if 1
   using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
-
   this->ValidateOptions();
-  //Make sure everything matches up ok.
-  this->VecFieldType = vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE;
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
-  std::string activeField = this->GetActiveFieldName();
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  std::vector<DSIType*> dsi;
-  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
-  {
-    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-    auto ds1 = input.GetPartition(i);
-    auto ds2 = this->DataSet2.GetPartition(i);
-    if ((!ds1.HasPointField(activeField) && !ds1.HasCellField(activeField)) ||
-        (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
-      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
-
-    dsi.push_back(new DSIType(ds1,
-                              ds2,
-                              this->Time1,
-                              this->Time2,
-                              blockId,
-                              activeField,
-                              this->SolverType,
-                              this->VecFieldType,
-                              this->ResultType));
-  }
-
-  this->SeedArray = this->Seeds;
   vtkm::filter::particleadvection::PAV<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
-#endif
-}
 
-VTKM_CONT vtkm::cont::DataSet Pathline3::DoExecute(const vtkm::cont::DataSet& inData)
-{
-  std::cout << "Meow DS" << std::endl;
-  auto result = this->DoExecutePartitions(inData);
-  return result.GetPartition(0);
-}
-
-VTKM_CONT vtkm::cont::PartitionedDataSet Pathline3::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& inData)
-{
-  std::cout << "Meow pDS" << std::endl;
-  return inData;
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }
diff --git a/vtkm/filter/Streamline2.h b/vtkm/filter/Streamline2.h
index f369753bc..59b9cba95 100644
--- a/vtkm/filter/Streamline2.h
+++ b/vtkm/filter/Streamline2.h
@@ -12,8 +12,8 @@
 #define vtk_m_filter_Streamline2_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/FilterParticleAdvection.h>
 #include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/NewFilterParticleAdvection.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
@@ -25,30 +25,18 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class Streamline2 : public vtkm::filter::FilterParticleAdvection<Streamline2, vtkm::Particle>
+class Streamline2 : public vtkm::filter::NewFilterSteadyStateParticleAdvection
 {
 public:
-  VTKM_CONT Streamline2();
-
-  template <typename DerivedPolicy>
-  vtkm::cont::PartitionedDataSet PrepareForExecution(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
-
-  vtkm::cont::UnknownArrayHandle SeedArray;
-};
-
-class Streamline3 : public vtkm::filter::NewFilterField
-{
-public:
-  //  VTKM_CONT Streamline3() {}
+  VTKM_CONT Streamline2()
+    : NewFilterSteadyStateParticleAdvection(
+        vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
+  {
+  }
 
 protected:
-  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
-
-  vtkm::cont::UnknownArrayHandle SeedArray;
 };
 
 }
diff --git a/vtkm/filter/Streamline2.hxx b/vtkm/filter/Streamline2.hxx
index ebcbe90c0..aeff1569b 100644
--- a/vtkm/filter/Streamline2.hxx
+++ b/vtkm/filter/Streamline2.hxx
@@ -13,8 +13,6 @@
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/Streamline2.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
 
 #include <vtkm/filter/particleadvection/DSISteadyState.h>
 #include <vtkm/filter/particleadvection/PAV.h>
@@ -25,62 +23,19 @@ namespace vtkm
 namespace filter
 {
 
-//-----------------------------------------------------------------------------
-inline VTKM_CONT Streamline2::Streamline2()
-  : vtkm::filter::FilterParticleAdvection<Streamline2, vtkm::Particle>()
+VTKM_CONT vtkm::cont::PartitionedDataSet Streamline2::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& input)
 {
-  this->ResultType = vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE;
-}
-
-//-----------------------------------------------------------------------------
-template <typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::PartitionedDataSet Streamline2::PrepareForExecution(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::PolicyBase<DerivedPolicy>&)
-{
-  //  return input;
-
-#if 1
   using DSIType = vtkm::filter::particleadvection::DSISteadyState;
-
   this->ValidateOptions();
-  //Make sure everything matches up ok.
-  this->VecFieldType = vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE;
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
-  std::string activeField = this->GetActiveFieldName();
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  std::vector<DSIType*> dsi;
-  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
-  {
-    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-    auto ds = input.GetPartition(i);
-    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
-      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
-
-    dsi.push_back(new DSIType(
-      ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
-  }
-
-  this->SeedArray = this->Seeds;
   vtkm::filter::particleadvection::PAV<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
-#endif
-}
 
-VTKM_CONT vtkm::cont::DataSet Streamline3::DoExecute(const vtkm::cont::DataSet& inData)
-{
-  std::cout << "Meow DS" << std::endl;
-  auto result = this->DoExecutePartitions(inData);
-  return result.GetPartition(0);
-}
-
-VTKM_CONT vtkm::cont::PartitionedDataSet Streamline3::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& inData)
-{
-  std::cout << "Meow pDS" << std::endl;
-  return inData;
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }

From 17322e9d056f3c4cf4a3c495a1a7a7536af391a7 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 18 Jul 2022 08:38:54 -0400
Subject: [PATCH 021/104] Moving code around.

---
 vtkm/filter/CMakeLists.txt                    |  8 ----
 vtkm/filter/FilterTemporalParticleAdvection.h |  3 +-
 .../FilterTemporalParticleAdvection.hxx       |  2 +-
 vtkm/filter/NewFilterParticleAdvection.h      | 10 ++---
 vtkm/filter/NewFilterParticleAdvection.hxx    |  2 +-
 vtkm/filter/ParticleAdvection.h               | 22 +++++-----
 vtkm/filter/ParticleAdvection.hxx             | 41 ++++++------------
 vtkm/filter/PathParticle.h                    | 32 +++++++-------
 vtkm/filter/PathParticle.hxx                  | 41 ++++++------------
 vtkm/filter/Pathline.h                        | 31 +++++++-------
 vtkm/filter/Pathline.hxx                      | 42 ++++++-------------
 vtkm/filter/Pathline2.hxx                     |  8 ++--
 vtkm/filter/Streamline.h                      | 31 +++++++-------
 vtkm/filter/Streamline.hxx                    | 40 ++++++------------
 vtkm/filter/particleadvection/DSI.h           |  5 ++-
 vtkm/filter/particleadvection/DSI.hxx         |  2 +
 .../filter/particleadvection/DSISteadyState.h | 15 +++----
 .../particleadvection/DSISteadyState.hxx      | 12 +++---
 .../particleadvection/DSIUnsteadyState.h      | 14 ++++---
 .../particleadvection/DSIUnsteadyState.hxx    | 19 ++++++---
 .../testing/UnitTestStreamlineFilter.cxx      | 26 +++++-------
 .../testing/UnitTestStreamlineFilterMPI.cxx   | 14 +++----
 22 files changed, 176 insertions(+), 244 deletions(-)

diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index abeb07f3d..5589c0a7e 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -105,13 +105,9 @@ set(extra_headers
   LagrangianStructures.h
   MIRFilter.h
   ParticleAdvection.h
-  ParticleAdvection2.h
   Pathline.h
-  Pathline2.h
   PathParticle.h
-  PathParticle2.h
   Streamline.h
-  Streamline2.h
   StreamSurface.h
   )
 
@@ -124,13 +120,9 @@ set(extra_header_template_sources
   LagrangianStructures.hxx
   MIRFilter.hxx
   ParticleAdvection.hxx
-  ParticleAdvection2.hxx
   Pathline.hxx
-  Pathline2.hxx
   PathParticle.hxx
-  PathParticle2.hxx
   Streamline.hxx
-  Streamline2.hxx
   StreamSurface.hxx
   )
 
diff --git a/vtkm/filter/FilterTemporalParticleAdvection.h b/vtkm/filter/FilterTemporalParticleAdvection.h
index 988de3e93..c75e0e506 100644
--- a/vtkm/filter/FilterTemporalParticleAdvection.h
+++ b/vtkm/filter/FilterTemporalParticleAdvection.h
@@ -52,7 +52,8 @@ public:
                                                     vtkm::filter::PolicyBase<DerivedPolicy> policy);
 
 protected:
-  VTKM_CONT void ValidateOptions(const vtkm::cont::PartitionedDataSet& input) const;
+  VTKM_CONT virtual void ValidateOptions(
+    const vtkm::cont::PartitionedDataSet& input) const override;
   using vtkm::filter::FilterParticleAdvection<Derived, ParticleType>::ValidateOptions;
 
   VTKM_CONT std::vector<vtkm::filter::particleadvection::TemporalDataSetIntegrator>
diff --git a/vtkm/filter/FilterTemporalParticleAdvection.hxx b/vtkm/filter/FilterTemporalParticleAdvection.hxx
index fa1e5b36c..983d82b3d 100644
--- a/vtkm/filter/FilterTemporalParticleAdvection.hxx
+++ b/vtkm/filter/FilterTemporalParticleAdvection.hxx
@@ -29,7 +29,7 @@ FilterTemporalParticleAdvection<Derived, ParticleType>::FilterTemporalParticleAd
 
 template <typename Derived, typename ParticleType>
 void FilterTemporalParticleAdvection<Derived, ParticleType>::ValidateOptions(
-  const vtkm::cont::PartitionedDataSet& input) const
+  const vtkm::cont::PartitionedDataSet& input) const override
 {
   this->vtkm::filter::FilterParticleAdvection<Derived, ParticleType>::ValidateOptions();
 
diff --git a/vtkm/filter/NewFilterParticleAdvection.h b/vtkm/filter/NewFilterParticleAdvection.h
index a9e41f0c9..7013c945d 100644
--- a/vtkm/filter/NewFilterParticleAdvection.h
+++ b/vtkm/filter/NewFilterParticleAdvection.h
@@ -82,7 +82,7 @@ protected:
     return out.GetPartition(0);
   }
 
-  VTKM_CONT virtual void ValidateOptions() const;
+  VTKM_CONT inline void ValidateOptions() const;
 
   vtkm::Id NumberOfSteps;
   vtkm::filter::particleadvection::ParticleAdvectionResultType ResultType =
@@ -108,9 +108,9 @@ public:
   }
 
 protected:
-  VTKM_CONT std::vector<vtkm::filter::particleadvection::DSISteadyState*> CreateDataSetIntegrators(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
+  VTKM_CONT inline std::vector<vtkm::filter::particleadvection::DSISteadyState*>
+  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
+                           const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
 };
 
 class NewFilterUnsteadyStateParticleAdvection : public NewFilterParticleAdvection
@@ -129,7 +129,7 @@ public:
   void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->Input2 = pds; }
 
 protected:
-  VTKM_CONT std::vector<vtkm::filter::particleadvection::DSIUnsteadyState*>
+  VTKM_CONT inline std::vector<vtkm::filter::particleadvection::DSIUnsteadyState*>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
                            const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
 
diff --git a/vtkm/filter/NewFilterParticleAdvection.hxx b/vtkm/filter/NewFilterParticleAdvection.hxx
index e3abdd032..be4e28eeb 100644
--- a/vtkm/filter/NewFilterParticleAdvection.hxx
+++ b/vtkm/filter/NewFilterParticleAdvection.hxx
@@ -8,7 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 #ifndef vtk_m_filter_NewFilterParticleAdvection_hxx
-#define vtk_m_filter_FilterParticleAdvection_hxx
+#define vtk_m_filter_NewFilterParticleAdvection_hxx
 
 #include <vtkm/filter/NewFilterParticleAdvection.h>
 
diff --git a/vtkm/filter/ParticleAdvection.h b/vtkm/filter/ParticleAdvection.h
index e43deb087..562d34254 100644
--- a/vtkm/filter/ParticleAdvection.h
+++ b/vtkm/filter/ParticleAdvection.h
@@ -12,7 +12,9 @@
 #define vtk_m_filter_ParticleAdvection_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/FilterParticleAdvection.h>
+#include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/NewFilterParticleAdvection.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
 {
@@ -23,20 +25,20 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-template <typename ParticleType = vtkm::Particle>
-class ParticleAdvectionBase
-  : public vtkm::filter::FilterParticleAdvection<ParticleAdvectionBase<ParticleType>, ParticleType>
+class ParticleAdvection : public vtkm::filter::NewFilterSteadyStateParticleAdvection
 {
 public:
-  VTKM_CONT ParticleAdvectionBase();
+  VTKM_CONT ParticleAdvection()
+    : NewFilterSteadyStateParticleAdvection(
+        vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+  {
+  }
 
-  template <typename DerivedPolicy>
-  vtkm::cont::PartitionedDataSet PrepareForExecution(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
+protected:
+  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
+    const vtkm::cont::PartitionedDataSet& inData) override;
 };
 
-using ParticleAdvection = ParticleAdvectionBase<vtkm::Particle>;
 }
 } // namespace vtkm::filter
 
diff --git a/vtkm/filter/ParticleAdvection.hxx b/vtkm/filter/ParticleAdvection.hxx
index cafec087a..0e8a3222e 100644
--- a/vtkm/filter/ParticleAdvection.hxx
+++ b/vtkm/filter/ParticleAdvection.hxx
@@ -13,46 +13,29 @@
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/ParticleAdvection.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
+
+#include <vtkm/filter/particleadvection/DSISteadyState.h>
+#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
 {
 namespace filter
 {
 
-//-----------------------------------------------------------------------------
-template <typename ParticleType>
-inline VTKM_CONT ParticleAdvectionBase<ParticleType>::ParticleAdvectionBase()
-  : vtkm::filter::FilterParticleAdvection<ParticleAdvectionBase<ParticleType>, ParticleType>()
+VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& input)
 {
-}
-
-//-----------------------------------------------------------------------------
-template <typename ParticleType>
-template <typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::PartitionedDataSet
-ParticleAdvectionBase<ParticleType>::PrepareForExecution(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::PolicyBase<DerivedPolicy>&)
-{
-  //  using AlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionAlgorithm;
-  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
-  //  using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
-
+  using DSIType = vtkm::filter::particleadvection::DSISteadyState;
   this->ValidateOptions();
-  return input;
-#if 0
+
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  if (this->GetUseThreadedAlgorithm())
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  else
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-#endif
+  vtkm::filter::particleadvection::PAV<DSIType> pav(
+    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
+
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }
diff --git a/vtkm/filter/PathParticle.h b/vtkm/filter/PathParticle.h
index fbf449a55..30e95b250 100644
--- a/vtkm/filter/PathParticle.h
+++ b/vtkm/filter/PathParticle.h
@@ -11,36 +11,34 @@
 #ifndef vtk_m_filter_PathParticle_h
 #define vtk_m_filter_PathParticle_h
 
-#include <vtkm/filter/FilterTemporalParticleAdvection.h>
+#include <vtkm/Particle.h>
+#include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/NewFilterParticleAdvection.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
 {
 namespace filter
 {
-/// \brief Advect particles in a time varying vector field.
+/// \brief Advect particles in a vector field.
 
 /// Takes as input a vector field and seed locations and generates the
-/// paths taken by the seeds through the vector field.
-template <typename ParticleType>
-class PathParticleBase
-  : public vtkm::filter::FilterTemporalParticleAdvection<PathParticleBase<ParticleType>,
-                                                         ParticleType>
+/// end points for each seed through the vector field.
+
+class PathParticle : public vtkm::filter::NewFilterUnsteadyStateParticleAdvection
 {
 public:
-  VTKM_CONT
-  PathParticleBase();
-
-  template <typename DerivedPolicy>
-  vtkm::cont::PartitionedDataSet PrepareForExecution(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
+  VTKM_CONT PathParticle()
+    : NewFilterUnsteadyStateParticleAdvection(
+        vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+  {
+  }
 
 protected:
-private:
+  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
+    const vtkm::cont::PartitionedDataSet& inData) override;
 };
 
-using PathParticle = PathParticleBase<vtkm::Particle>;
-
 }
 } // namespace vtkm::filter
 
diff --git a/vtkm/filter/PathParticle.hxx b/vtkm/filter/PathParticle.hxx
index 960491b05..2bbf3db02 100644
--- a/vtkm/filter/PathParticle.hxx
+++ b/vtkm/filter/PathParticle.hxx
@@ -7,7 +7,6 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-
 #ifndef vtk_m_filter_PathParticle_hxx
 #define vtk_m_filter_PathParticle_hxx
 
@@ -17,44 +16,28 @@
 #include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
 
+#include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
+#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+
 namespace vtkm
 {
 namespace filter
 {
 
-//-----------------------------------------------------------------------------
-template <typename ParticleType>
-inline VTKM_CONT PathParticleBase<ParticleType>::PathParticleBase()
-  : vtkm::filter::FilterTemporalParticleAdvection<PathParticleBase<ParticleType>, ParticleType>()
+VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& input)
 {
-}
-
-//-----------------------------------------------------------------------------
-template <typename ParticleType>
-template <typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticleBase<ParticleType>::PrepareForExecution(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::PolicyBase<DerivedPolicy>&)
-{
-  //  using AlgorithmType = vtkm::filter::particleadvection::PathParticleAlgorithm;
-  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::PathParticleThreadedAlgorithm;
-  //  using TDSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
-
-  return input;
-
-  /*
-  this->ValidateOptions(input);
+  using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
+  this->ValidateOptions();
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  if (this->GetUseThreadedAlgorithm())
-    return vtkm::filter::particleadvection::RunAlgo<TDSIType, ThreadedAlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  else
-    return vtkm::filter::particleadvection::RunAlgo<TDSIType, AlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  */
+  vtkm::filter::particleadvection::PAV<DSIType> pav(
+    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
+
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }
diff --git a/vtkm/filter/Pathline.h b/vtkm/filter/Pathline.h
index 87193eb9c..8d351ccdc 100644
--- a/vtkm/filter/Pathline.h
+++ b/vtkm/filter/Pathline.h
@@ -11,35 +11,34 @@
 #ifndef vtk_m_filter_Pathline_h
 #define vtk_m_filter_Pathline_h
 
-#include <vtkm/filter/FilterTemporalParticleAdvection.h>
+#include <vtkm/Particle.h>
+#include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/NewFilterParticleAdvection.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
 {
 namespace filter
 {
-/// \brief generate pathlines from a time sequence of vector fields.
+/// \brief Advect particles in a vector field.
 
 /// Takes as input a vector field and seed locations and generates the
-/// paths taken by the seeds through the vector field.
-template <typename ParticleType>
-class PathlineBase
-  : public vtkm::filter::FilterTemporalParticleAdvection<PathlineBase<ParticleType>, ParticleType>
+/// end points for each seed through the vector field.
+
+class Pathline : public vtkm::filter::NewFilterUnsteadyStateParticleAdvection
 {
 public:
-  VTKM_CONT
-  PathlineBase();
-
-  template <typename DerivedPolicy>
-  vtkm::cont::PartitionedDataSet PrepareForExecution(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
+  VTKM_CONT Pathline()
+    : NewFilterUnsteadyStateParticleAdvection(
+        vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
+  {
+  }
 
 protected:
-private:
+  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
+    const vtkm::cont::PartitionedDataSet& inData) override;
 };
 
-using Pathline = PathlineBase<vtkm::Particle>;
-
 }
 } // namespace vtkm::filter
 
diff --git a/vtkm/filter/Pathline.hxx b/vtkm/filter/Pathline.hxx
index ec932a5d3..5f4ee0e73 100644
--- a/vtkm/filter/Pathline.hxx
+++ b/vtkm/filter/Pathline.hxx
@@ -7,54 +7,36 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-
 #ifndef vtk_m_filter_Pathline_hxx
 #define vtk_m_filter_Pathline_hxx
 
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/Pathline.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
 
+#include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
+#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+
 namespace vtkm
 {
 namespace filter
 {
 
-//-----------------------------------------------------------------------------
-template <typename ParticleType>
-inline VTKM_CONT PathlineBase<ParticleType>::PathlineBase()
-  : vtkm::filter::FilterTemporalParticleAdvection<PathlineBase<ParticleType>, ParticleType>()
+VTKM_CONT vtkm::cont::PartitionedDataSet Pathline::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& input)
 {
-}
-
-//-----------------------------------------------------------------------------
-template <typename ParticleType>
-template <typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::PartitionedDataSet PathlineBase<ParticleType>::PrepareForExecution(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::PolicyBase<DerivedPolicy>&)
-{
-  /*
-  using AlgorithmType = vtkm::filter::particleadvection::PathlineAlgorithm;
-  using ThreadedAlgorithmType = vtkm::filter::particleadvection::PathlineThreadedAlgorithm;
-  using TDSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
-
-
-  this->ValidateOptions(input);
+  using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
+  this->ValidateOptions();
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  if (this->GetUseThreadedAlgorithm())
-    return vtkm::filter::particleadvection::RunAlgo<TDSIType, ThreadedAlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  else
-    return vtkm::filter::particleadvection::RunAlgo<TDSIType, AlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  */
-  return input;
+  vtkm::filter::particleadvection::PAV<DSIType> pav(
+    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
+
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }
diff --git a/vtkm/filter/Pathline2.hxx b/vtkm/filter/Pathline2.hxx
index 106642a18..36a48222d 100644
--- a/vtkm/filter/Pathline2.hxx
+++ b/vtkm/filter/Pathline2.hxx
@@ -7,11 +7,11 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-#ifndef vtk_m_filter_Pathline2_hxx
-#define vtk_m_filter_Pathline2_hxx
+#ifndef vtk_m_filter_Pathline_hxx
+#define vtk_m_filter_Pathline_hxx
 
 #include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/Pathline2.h>
+#include <vtkm/filter/Pathline.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
 #include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
@@ -25,7 +25,7 @@ namespace vtkm
 namespace filter
 {
 
-VTKM_CONT vtkm::cont::PartitionedDataSet Pathline2::DoExecutePartitions(
+VTKM_CONT vtkm::cont::PartitionedDataSet Pathline::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
   using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
diff --git a/vtkm/filter/Streamline.h b/vtkm/filter/Streamline.h
index d6b7c01ef..5c0729749 100644
--- a/vtkm/filter/Streamline.h
+++ b/vtkm/filter/Streamline.h
@@ -11,33 +11,34 @@
 #ifndef vtk_m_filter_Streamline_h
 #define vtk_m_filter_Streamline_h
 
-#include <vtkm/filter/FilterParticleAdvection.h>
+#include <vtkm/Particle.h>
+#include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/NewFilterParticleAdvection.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
 {
 namespace filter
 {
-/// \brief Generate streamlines from a vector field.
+/// \brief Advect particles in a vector field.
 
 /// Takes as input a vector field and seed locations and generates the
-/// paths taken by the seeds through the vector field.
-template <typename ParticleType = vtkm::Particle>
-class StreamlineBase
-  : public vtkm::filter::FilterParticleAdvection<StreamlineBase<ParticleType>, ParticleType>
+/// end points for each seed through the vector field.
+
+class Streamline : public vtkm::filter::NewFilterSteadyStateParticleAdvection
 {
 public:
-  VTKM_CONT
-  StreamlineBase();
+  VTKM_CONT Streamline()
+    : NewFilterSteadyStateParticleAdvection(
+        vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
+  {
+  }
 
-  template <typename DerivedPolicy>
-  vtkm::cont::PartitionedDataSet PrepareForExecution(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
-
-private:
+protected:
+  VTKM_CONT inline vtkm::cont::PartitionedDataSet DoExecutePartitions(
+    const vtkm::cont::PartitionedDataSet& inData) override;
 };
 
-using Streamline = StreamlineBase<vtkm::Particle>;
 }
 } // namespace vtkm::filter
 
diff --git a/vtkm/filter/Streamline.hxx b/vtkm/filter/Streamline.hxx
index 4c82b541f..7c8286188 100644
--- a/vtkm/filter/Streamline.hxx
+++ b/vtkm/filter/Streamline.hxx
@@ -13,45 +13,29 @@
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/Streamline.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
+
+#include <vtkm/filter/particleadvection/DSISteadyState.h>
+#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
 {
 namespace filter
 {
 
-//-----------------------------------------------------------------------------
-template <typename ParticleType>
-inline VTKM_CONT StreamlineBase<ParticleType>::StreamlineBase()
-  : vtkm::filter::FilterParticleAdvection<StreamlineBase<ParticleType>, ParticleType>()
+VTKM_CONT inline vtkm::cont::PartitionedDataSet Streamline::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& input)
 {
-}
-
-//-----------------------------------------------------------------------------
-template <typename ParticleType>
-template <typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::PartitionedDataSet StreamlineBase<ParticleType>::PrepareForExecution(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::PolicyBase<DerivedPolicy>&)
-{
-  //  using AlgorithmType = vtkm::filter::particleadvection::StreamlineAlgorithm;
-  //  using ThreadedAlgorithmType = vtkm::filter::particleadvection::StreamlineThreadedAlgorithm;
-  //  using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
-
+  using DSIType = vtkm::filter::particleadvection::DSISteadyState;
   this->ValidateOptions();
-  return input;
-#if 0
+
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  if (this->GetUseThreadedAlgorithm())
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-  else
-    return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
-      boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
-#endif
+  vtkm::filter::particleadvection::PAV<DSIType> pav(
+    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
+
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DSI.h
index 2853001c7..12b0edf9b 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DSI.h
@@ -12,6 +12,7 @@
 #define vtk_m_filter_particleadvection_DSI_h
 
 #include <vtkm/cont/DataSet.h>
+#include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 #include <vtkm/worklet/ParticleAdvection.h>
 #include <vtkm/worklet/particleadvection/EulerIntegrator.h>
@@ -156,8 +157,8 @@ protected:
 }
 }
 
-//#ifndef vtk_m_filter_particleadvection_DSI_hxx
+#ifndef vtk_m_filter_particleadvection_DSI_hxx
 #include <vtkm/filter/particleadvection/DSI.hxx>
-//#endif
+#endif
 
 #endif //vtk_m_filter_particleadvection_DSI_h
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DSI.hxx
index 5234e6d0e..25f034512 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DSI.hxx
@@ -11,6 +11,8 @@
 #ifndef vtk_m_filter_particleadvection_DSI_hxx
 #define vtk_m_filter_particleadvection_DSI_hxx
 
+#include <vtkm/cont/ParticleArrayCopy.h>
+
 namespace vtkm
 {
 namespace filter
diff --git a/vtkm/filter/particleadvection/DSISteadyState.h b/vtkm/filter/particleadvection/DSISteadyState.h
index 31048b39e..340198004 100644
--- a/vtkm/filter/particleadvection/DSISteadyState.h
+++ b/vtkm/filter/particleadvection/DSISteadyState.h
@@ -34,13 +34,13 @@ public:
   {
   }
 
-  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) override;
+  VTKM_CONT virtual inline void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                         vtkm::FloatDefault stepSize,
+                                         vtkm::Id maxSteps) override;
 
-  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) override;
+  VTKM_CONT virtual inline void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
+                                         vtkm::FloatDefault stepSize,
+                                         vtkm::Id maxSteps) override;
 
 protected:
   template <typename ArrayType>
@@ -60,7 +60,6 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
   }
 
-
 private:
   vtkm::cont::DataSet DataSet;
 };
@@ -69,6 +68,8 @@ private:
 }
 }
 
+#ifndef vtk_m_filter_particleadvection_DSISteadyState_hxx
 #include <vtkm/filter/particleadvection/DSISteadyState.hxx>
+#endif
 
 #endif //vtk_m_filter_particleadvection_DSISteadyState_h
diff --git a/vtkm/filter/particleadvection/DSISteadyState.hxx b/vtkm/filter/particleadvection/DSISteadyState.hxx
index ce79794fc..01869aa64 100644
--- a/vtkm/filter/particleadvection/DSISteadyState.hxx
+++ b/vtkm/filter/particleadvection/DSISteadyState.hxx
@@ -107,9 +107,9 @@ public:
 };
 }
 
-VTKM_CONT void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                        vtkm::FloatDefault stepSize,
-                                        vtkm::Id maxSteps)
+VTKM_CONT inline void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                               vtkm::FloatDefault stepSize,
+                                               vtkm::Id maxSteps)
 {
   using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
 
@@ -145,9 +145,9 @@ VTKM_CONT void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
     throw vtkm::cont::ErrorFilterExecution("Unsupported vector field type");
 }
 
-VTKM_CONT void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
-                                        vtkm::FloatDefault vtkmNotUsed(stepSize),
-                                        vtkm::Id vtkmNotUsed(maxSteps))
+VTKM_CONT inline void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
+                                               vtkm::FloatDefault vtkmNotUsed(stepSize),
+                                               vtkm::Id vtkmNotUsed(maxSteps))
 {
 }
 
diff --git a/vtkm/filter/particleadvection/DSIUnsteadyState.h b/vtkm/filter/particleadvection/DSIUnsteadyState.h
index 1b19438f6..75fd57a67 100644
--- a/vtkm/filter/particleadvection/DSIUnsteadyState.h
+++ b/vtkm/filter/particleadvection/DSIUnsteadyState.h
@@ -40,13 +40,13 @@ public:
   {
   }
 
-  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) override;
+  VTKM_CONT virtual inline void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                         vtkm::FloatDefault stepSize,
+                                         vtkm::Id maxSteps) override;
 
-  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) override;
+  VTKM_CONT virtual inline void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
+                                         vtkm::FloatDefault stepSize,
+                                         vtkm::Id maxSteps) override;
 
 protected:
   template <typename ArrayType>
@@ -84,6 +84,8 @@ private:
 }
 }
 
+#ifndef vtk_m_filter_particleadvection_DSIUnsteadyState_hxx
 #include <vtkm/filter/particleadvection/DSIUnsteadyState.hxx>
+#endif
 
 #endif //vtk_m_filter_particleadvection_DSIUnsteadyState_h
diff --git a/vtkm/filter/particleadvection/DSIUnsteadyState.hxx b/vtkm/filter/particleadvection/DSIUnsteadyState.hxx
index 0fd591dd0..80a71b0a0 100644
--- a/vtkm/filter/particleadvection/DSIUnsteadyState.hxx
+++ b/vtkm/filter/particleadvection/DSIUnsteadyState.hxx
@@ -10,6 +10,9 @@
 
 #ifndef vtk_m_filter_particleadvection_DSIUnsteadyState_hxx
 #define vtk_m_filter_particleadvection_DSIUnsteadyState_hxx
+
+#include <vtkm/worklet/particleadvection/TemporalGridEvaluators.h>
+
 namespace vtkm
 {
 namespace filter
@@ -24,6 +27,9 @@ using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayT
 using UnsteadyStateGridEvalType =
   vtkm::worklet::particleadvection::TemporalGridEvaluator<VelocityFieldType>;
 
+template <typename GridEvalType, typename ParticleType>
+class AdvectHelper;
+
 template <typename ParticleType>
 class AdvectHelper<UnsteadyStateGridEvalType, ParticleType>
 {
@@ -117,9 +123,9 @@ public:
 
 }
 
-VTKM_CONT void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                          vtkm::FloatDefault stepSize,
-                                          vtkm::Id maxSteps)
+VTKM_CONT inline void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                                 vtkm::FloatDefault stepSize,
+                                                 vtkm::Id maxSteps)
 {
   using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
 
@@ -173,9 +179,10 @@ VTKM_CONT void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
     throw vtkm::cont::ErrorFilterExecution("Unsupported vector field type");
 }
 
-VTKM_CONT void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
-                                          vtkm::FloatDefault vtkmNotUsed(stepSize),
-                                          vtkm::Id vtkmNotUsed(maxSteps))
+VTKM_CONT inline void DSIUnsteadyState::DoAdvect(
+  DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
+  vtkm::FloatDefault vtkmNotUsed(stepSize),
+  vtkm::Id vtkmNotUsed(maxSteps))
 {
 }
 
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index 61274979c..a182061e4 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -11,13 +11,9 @@
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/ParticleAdvection.h>
-#include <vtkm/filter/ParticleAdvection2.h>
 #include <vtkm/filter/PathParticle.h>
-#include <vtkm/filter/PathParticle2.h>
 #include <vtkm/filter/Pathline.h>
-#include <vtkm/filter/Pathline2.h>
 #include <vtkm/filter/Streamline.h>
-#include <vtkm/filter/Streamline2.h>
 #include <vtkm/io/VTKDataSetReader.h>
 #include <vtkm/io/VTKDataSetWriter.h>
 #include <vtkm/worklet/testing/GenerateTestDataSets.h>
@@ -68,7 +64,7 @@ void TestStreamline()
                                      vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
                                      vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
 
-    vtkm::filter::Streamline2 streamline;
+    vtkm::filter::Streamline streamline;
 
     streamline.SetStepSize(0.1f);
     streamline.SetNumberOfSteps(20);
@@ -133,7 +129,7 @@ void TestPathline()
       vtkm::Id numExpectedPoints;
       if (fType == 0)
       {
-        vtkm::filter::Pathline2 filt;
+        vtkm::filter::Pathline filt;
         filt.SetActiveField(var);
         filt.SetStepSize(stepSize);
         filt.SetNumberOfSteps(numSteps);
@@ -151,7 +147,7 @@ void TestPathline()
       }
       else
       {
-        vtkm::filter::PathParticle2 filt;
+        vtkm::filter::PathParticle filt;
         filt.SetActiveField(var);
         filt.SetStepSize(stepSize);
         filt.SetNumberOfSteps(numSteps);
@@ -237,7 +233,7 @@ void TestAMRStreamline(bool useSL)
 
     if (useSL)
     {
-      vtkm::filter::Streamline2 filter;
+      vtkm::filter::Streamline filter;
       filter.SetStepSize(0.1f);
       filter.SetNumberOfSteps(100000);
       filter.SetSeeds(seedArray);
@@ -309,7 +305,7 @@ void TestAMRStreamline(bool useSL)
     }
     else
     {
-      vtkm::filter::ParticleAdvection2 filter;
+      vtkm::filter::ParticleAdvection filter;
       filter.SetStepSize(0.1f);
       filter.SetNumberOfSteps(100000);
       filter.SetSeeds(seedArray);
@@ -391,7 +387,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
       vtkm::cont::PartitionedDataSet out;
       if (fType == FilterType::STREAMLINE)
       {
-        vtkm::filter::Streamline2 streamline;
+        vtkm::filter::Streamline streamline;
         streamline.SetStepSize(0.1f);
         streamline.SetNumberOfSteps(100000);
         streamline.SetSeeds(seedArray);
@@ -404,7 +400,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
         auto pds2 = allPDs2[idx];
         AddVectorFields(pds2, fieldName, vecX);
 
-        vtkm::filter::Pathline2 pathline;
+        vtkm::filter::Pathline pathline;
         pathline.SetPreviousTime(0);
         pathline.SetNextTime(1000);
         pathline.SetNextDataSet(pds2);
@@ -455,7 +451,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
       vtkm::cont::PartitionedDataSet out;
       if (fType == FilterType::PARTICLE_ADVECTION)
       {
-        vtkm::filter::ParticleAdvection2 particleAdvection;
+        vtkm::filter::ParticleAdvection particleAdvection;
 
         particleAdvection.SetStepSize(0.1f);
         particleAdvection.SetNumberOfSteps(100000);
@@ -469,7 +465,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
         auto pds2 = allPDs2[idx];
         AddVectorFields(pds2, fieldName, vecX);
 
-        vtkm::filter::PathParticle2 pathParticle;
+        vtkm::filter::PathParticle pathParticle;
         pathParticle.SetPreviousTime(0);
         pathParticle.SetNextTime(1000);
         pathParticle.SetNextDataSet(pds2);
@@ -559,7 +555,7 @@ void TestStreamlineFile(const std::string& fname,
   vtkm::cont::DataSet output;
   if (useSL)
   {
-    vtkm::filter::Streamline2 streamline;
+    vtkm::filter::Streamline streamline;
     streamline.SetStepSize(stepSize);
     streamline.SetNumberOfSteps(maxSteps);
     streamline.SetSeeds(seedArray);
@@ -568,7 +564,7 @@ void TestStreamlineFile(const std::string& fname,
   }
   else
   {
-    vtkm::filter::ParticleAdvection2 particleAdvection;
+    vtkm::filter::ParticleAdvection particleAdvection;
     particleAdvection.SetStepSize(stepSize);
     particleAdvection.SetNumberOfSteps(maxSteps);
     particleAdvection.SetSeeds(seedArray);
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
index 11f6b6d89..cfe2eeabf 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
@@ -12,9 +12,7 @@
 #include <vtkm/filter/ParticleAdvection.h>
 #include <vtkm/filter/ParticleAdvection2.h>
 #include <vtkm/filter/Pathline.h>
-#include <vtkm/filter/Pathline2.h>
 #include <vtkm/filter/Streamline.h>
-#include <vtkm/filter/Streamline2.h>
 #include <vtkm/thirdparty/diy/diy.h>
 #include <vtkm/worklet/testing/GenerateTestDataSets.h>
 
@@ -152,13 +150,13 @@ void TestAMRStreamline(FilterType fType, bool useThreaded)
 
       if (fType == STREAMLINE)
       {
-        vtkm::filter::Streamline2 streamline;
+        vtkm::filter::Streamline streamline;
         SetFilter(streamline, stepSize, numSteps, fieldName, seedArray, useThreaded);
         out = streamline.Execute(pds);
       }
       else if (fType == PATHLINE)
       {
-        vtkm::filter::Pathline2 pathline;
+        vtkm::filter::Pathline pathline;
         SetFilter(pathline, stepSize, numSteps, fieldName, seedArray, useThreaded);
         //Create timestep 2
         auto pds2 = vtkm::cont::PartitionedDataSet(pds);
@@ -242,7 +240,7 @@ void TestAMRStreamline(FilterType fType, bool useThreaded)
     }
     else if (fType == PARTICLE_ADVECTION)
     {
-      vtkm::filter::ParticleAdvection2 filter;
+      vtkm::filter::ParticleAdvection filter;
       filter.SetUseThreadedAlgorithm(useThreaded);
       filter.SetStepSize(0.1f);
       filter.SetNumberOfSteps(100000);
@@ -397,7 +395,7 @@ void TestPartitionedDataSet(vtkm::Id nPerRank, bool useGhost, FilterType fType,
 
     if (fType == STREAMLINE)
     {
-      vtkm::filter::Streamline2 streamline;
+      vtkm::filter::Streamline streamline;
       SetFilter(streamline, stepSize, numSteps, fieldName, seedArray, useThreaded);
       auto out = streamline.Execute(pds);
 
@@ -406,7 +404,7 @@ void TestPartitionedDataSet(vtkm::Id nPerRank, bool useGhost, FilterType fType,
     }
     else if (fType == PARTICLE_ADVECTION)
     {
-      vtkm::filter::ParticleAdvection2 particleAdvection;
+      vtkm::filter::ParticleAdvection particleAdvection;
       SetFilter(particleAdvection, stepSize, numSteps, fieldName, seedArray, useThreaded);
       auto out = particleAdvection.Execute(pds);
 
@@ -424,7 +422,7 @@ void TestPartitionedDataSet(vtkm::Id nPerRank, bool useGhost, FilterType fType,
       auto pds2 = allPDS2[n];
       AddVectorFields(pds2, fieldName, vecX);
 
-      vtkm::filter::Pathline2 pathline;
+      vtkm::filter::Pathline pathline;
       SetFilter(pathline, stepSize, numSteps, fieldName, seedArray, useThreaded);
 
       pathline.SetPreviousTime(time0);

From 83eb6f498c360af50ca2f4a4e5e1f254724818c8 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 18 Jul 2022 09:09:11 -0400
Subject: [PATCH 022/104] Update buffer calc

---
 vtkm/filter/particleadvection/ParticleMessenger.cxx | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/vtkm/filter/particleadvection/ParticleMessenger.cxx b/vtkm/filter/particleadvection/ParticleMessenger.cxx
index b26963c20..6a7a0fe12 100644
--- a/vtkm/filter/particleadvection/ParticleMessenger.cxx
+++ b/vtkm/filter/particleadvection/ParticleMessenger.cxx
@@ -49,19 +49,14 @@ template <typename ParticleType>
 std::size_t ParticleMessenger<ParticleType>::CalcParticleBufferSize(std::size_t nParticles,
                                                                     std::size_t nBlockIds)
 {
-  constexpr std::size_t pSize = sizeof(vtkm::Vec3f) // Pos
-    + sizeof(vtkm::Id)                              // ID
-    + sizeof(vtkm::Id)                              // NumSteps
-    + sizeof(vtkm::UInt8)                           // Status
-    + sizeof(vtkm::FloatDefault);                   // Time
+  std::size_t pSize = sizeof(ParticleType);
 
 #ifndef NDEBUG
   vtkmdiy::MemoryBuffer buff;
   ParticleType p;
   vtkmdiy::save(buff, p);
 
-  //If this assert fires, ParticleType changed
-  //and pSize should be updated.
+  //Make sure the buffer size is correct.
   VTKM_ASSERT(pSize == buff.size());
 #endif
 

From 134f9691ecb0266b2884d2bc70698931eb2ea728 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 18 Jul 2022 09:46:38 -0400
Subject: [PATCH 023/104] Move filter types into diff files.

---
 vtkm/filter/CMakeLists.txt                 |   3 +
 vtkm/filter/NewFilterParticleAdvection.h   |  73 +++++----------
 vtkm/filter/NewFilterParticleAdvection.hxx | 104 ---------------------
 vtkm/filter/ParticleAdvection.h            |   7 +-
 vtkm/filter/PathParticle.h                 |   7 +-
 vtkm/filter/Pathline.h                     |   7 +-
 vtkm/filter/Streamline.h                   |   7 +-
 7 files changed, 40 insertions(+), 168 deletions(-)
 delete mode 100644 vtkm/filter/NewFilterParticleAdvection.hxx

diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index 5589c0a7e..07a04ff7b 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -135,6 +135,9 @@ set(core_headers
   FieldSelection.h
   NewFilter.h
   NewFilterField.h
+  NewFilterParticleAdvection.h
+  NewFilterParticleAdvectionSteadyState.h
+  NewFilterParticleAdvectionUnsteadyState.h
   MapFieldMergeAverage.h
   MapFieldPermutation.h
   TaskQueue.h
diff --git a/vtkm/filter/NewFilterParticleAdvection.h b/vtkm/filter/NewFilterParticleAdvection.h
index 7013c945d..5e5d9ae9a 100644
--- a/vtkm/filter/NewFilterParticleAdvection.h
+++ b/vtkm/filter/NewFilterParticleAdvection.h
@@ -34,7 +34,16 @@ public:
   using SupportedTypes = vtkm::TypeListFieldVec3;
 
   VTKM_CONT
-  NewFilterParticleAdvection(vtkm::filter::particleadvection::ParticleAdvectionResultType rType);
+  NewFilterParticleAdvection(vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
+    : vtkm::filter::NewFilterField()
+    , NumberOfSteps(0)
+    , ResultType(rType)
+    , SolverType(vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE)
+    , StepSize(0)
+    , UseThreadedAlgorithm(false)
+    , VecFieldType(vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE)
+  {
+  }
 
   VTKM_CONT
   void SetStepSize(vtkm::FloatDefault s) { this->StepSize = s; }
@@ -82,7 +91,21 @@ protected:
     return out.GetPartition(0);
   }
 
-  VTKM_CONT inline void ValidateOptions() const;
+  VTKM_CONT virtual void ValidateOptions() const
+  {
+    if (this->GetUseCoordinateSystemAsField())
+      throw vtkm::cont::ErrorFilterExecution("Coordinate system as field not supported");
+    if (this->Seeds.GetNumberOfValues() == 0)
+      throw vtkm::cont::ErrorFilterExecution("No seeds provided.");
+    if (this->NumberOfSteps == 0)
+      throw vtkm::cont::ErrorFilterExecution("Number of steps not specified.");
+    if (this->StepSize == 0)
+      throw vtkm::cont::ErrorFilterExecution("Step size not specified.");
+    if (this->NumberOfSteps < 0)
+      throw vtkm::cont::ErrorFilterExecution("NumberOfSteps cannot be negative");
+    if (this->StepSize < 0)
+      throw vtkm::cont::ErrorFilterExecution("StepSize cannot be negative");
+  }
 
   vtkm::Id NumberOfSteps;
   vtkm::filter::particleadvection::ParticleAdvectionResultType ResultType =
@@ -96,53 +119,7 @@ protected:
 private:
 };
 
-
-class NewFilterSteadyStateParticleAdvection : public NewFilterParticleAdvection
-{
-public:
-  VTKM_CONT
-  NewFilterSteadyStateParticleAdvection(
-    vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
-    : NewFilterParticleAdvection(rType)
-  {
-  }
-
-protected:
-  VTKM_CONT inline std::vector<vtkm::filter::particleadvection::DSISteadyState*>
-  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
-                           const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
-};
-
-class NewFilterUnsteadyStateParticleAdvection : public NewFilterParticleAdvection
-{
-public:
-  VTKM_CONT
-  NewFilterUnsteadyStateParticleAdvection(
-    vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
-    : NewFilterParticleAdvection(rType)
-  {
-  }
-
-  void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
-  void SetNextTime(vtkm::FloatDefault t2) { this->Time2 = t2; }
-  void SetNextDataSet(const vtkm::cont::DataSet& ds) { this->Input2 = { ds }; }
-  void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->Input2 = pds; }
-
-protected:
-  VTKM_CONT inline std::vector<vtkm::filter::particleadvection::DSIUnsteadyState*>
-  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
-                           const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
-
-  vtkm::cont::PartitionedDataSet Input2;
-  vtkm::FloatDefault Time1;
-  vtkm::FloatDefault Time2;
-};
-
 }
 } // namespace vtkm::filter
 
-#ifndef vtk_m_filter_NewFilterParticleAdvection_hxx
-#include <vtkm/filter/NewFilterParticleAdvection.hxx>
-#endif
-
 #endif // vtk_m_filter_NewFilterParticleAdvection_h
diff --git a/vtkm/filter/NewFilterParticleAdvection.hxx b/vtkm/filter/NewFilterParticleAdvection.hxx
deleted file mode 100644
index be4e28eeb..000000000
--- a/vtkm/filter/NewFilterParticleAdvection.hxx
+++ /dev/null
@@ -1,104 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-#ifndef vtk_m_filter_NewFilterParticleAdvection_hxx
-#define vtk_m_filter_NewFilterParticleAdvection_hxx
-
-#include <vtkm/filter/NewFilterParticleAdvection.h>
-
-namespace vtkm
-{
-namespace filter
-{
-
-//-----------------------------------------------------------------------------
-inline VTKM_CONT NewFilterParticleAdvection::NewFilterParticleAdvection(
-  vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
-  : vtkm::filter::NewFilterField()
-  , NumberOfSteps(0)
-  , ResultType(rType)
-  , SolverType(vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE)
-  , StepSize(0)
-  , UseThreadedAlgorithm(false)
-  , VecFieldType(vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE)
-{
-}
-
-void NewFilterParticleAdvection::ValidateOptions() const
-{
-  if (this->GetUseCoordinateSystemAsField())
-    throw vtkm::cont::ErrorFilterExecution("Coordinate system as field not supported");
-  if (this->Seeds.GetNumberOfValues() == 0)
-    throw vtkm::cont::ErrorFilterExecution("No seeds provided.");
-  if (this->NumberOfSteps == 0)
-    throw vtkm::cont::ErrorFilterExecution("Number of steps not specified.");
-  if (this->StepSize == 0)
-    throw vtkm::cont::ErrorFilterExecution("Step size not specified.");
-}
-
-VTKM_CONT std::vector<vtkm::filter::particleadvection::DSISteadyState*>
-NewFilterSteadyStateParticleAdvection::CreateDataSetIntegrators(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
-{
-  using DSIType = vtkm::filter::particleadvection::DSISteadyState;
-
-  std::string activeField = this->GetActiveFieldName();
-
-  std::vector<DSIType*> dsi;
-  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
-  {
-    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-    auto ds = input.GetPartition(i);
-    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
-      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
-
-    dsi.push_back(new DSIType(
-      ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
-  }
-
-  return dsi;
-}
-
-VTKM_CONT std::vector<vtkm::filter::particleadvection::DSIUnsteadyState*>
-NewFilterUnsteadyStateParticleAdvection::CreateDataSetIntegrators(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
-{
-  using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
-
-  std::string activeField = this->GetActiveFieldName();
-
-  std::vector<DSIType*> dsi;
-  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
-  {
-    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-    auto ds1 = input.GetPartition(i);
-    auto ds2 = this->Input2.GetPartition(i);
-    if ((!ds1.HasPointField(activeField) && !ds1.HasCellField(activeField)) ||
-        (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
-      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
-
-    dsi.push_back(new DSIType(ds1,
-                              ds2,
-                              this->Time1,
-                              this->Time2,
-                              blockId,
-                              activeField,
-                              this->SolverType,
-                              this->VecFieldType,
-                              this->ResultType));
-  }
-
-  return dsi;
-}
-
-}
-} // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/ParticleAdvection.h b/vtkm/filter/ParticleAdvection.h
index 562d34254..e4270dfd9 100644
--- a/vtkm/filter/ParticleAdvection.h
+++ b/vtkm/filter/ParticleAdvection.h
@@ -12,8 +12,7 @@
 #define vtk_m_filter_ParticleAdvection_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterField.h>
-#include <vtkm/filter/NewFilterParticleAdvection.h>
+#include <vtkm/filter/NewFilterParticleAdvectionSteadyState.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
@@ -25,11 +24,11 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class ParticleAdvection : public vtkm::filter::NewFilterSteadyStateParticleAdvection
+class ParticleAdvection : public vtkm::filter::NewFilterParticleAdvectionSteadyState
 {
 public:
   VTKM_CONT ParticleAdvection()
-    : NewFilterSteadyStateParticleAdvection(
+    : NewFilterParticleAdvectionSteadyState(
         vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
   {
   }
diff --git a/vtkm/filter/PathParticle.h b/vtkm/filter/PathParticle.h
index 30e95b250..721e34d8b 100644
--- a/vtkm/filter/PathParticle.h
+++ b/vtkm/filter/PathParticle.h
@@ -12,8 +12,7 @@
 #define vtk_m_filter_PathParticle_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterField.h>
-#include <vtkm/filter/NewFilterParticleAdvection.h>
+#include <vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
@@ -25,11 +24,11 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class PathParticle : public vtkm::filter::NewFilterUnsteadyStateParticleAdvection
+class PathParticle : public vtkm::filter::NewFilterParticleAdvectionUnsteadyState
 {
 public:
   VTKM_CONT PathParticle()
-    : NewFilterUnsteadyStateParticleAdvection(
+    : NewFilterParticleAdvectionUnsteadyState(
         vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
   {
   }
diff --git a/vtkm/filter/Pathline.h b/vtkm/filter/Pathline.h
index 8d351ccdc..6cc141b82 100644
--- a/vtkm/filter/Pathline.h
+++ b/vtkm/filter/Pathline.h
@@ -12,8 +12,7 @@
 #define vtk_m_filter_Pathline_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterField.h>
-#include <vtkm/filter/NewFilterParticleAdvection.h>
+#include <vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
@@ -25,11 +24,11 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class Pathline : public vtkm::filter::NewFilterUnsteadyStateParticleAdvection
+class Pathline : public vtkm::filter::NewFilterParticleAdvectionUnsteadyState
 {
 public:
   VTKM_CONT Pathline()
-    : NewFilterUnsteadyStateParticleAdvection(
+    : NewFilterParticleAdvectionUnsteadyState(
         vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
   {
   }
diff --git a/vtkm/filter/Streamline.h b/vtkm/filter/Streamline.h
index 5c0729749..91396e8d5 100644
--- a/vtkm/filter/Streamline.h
+++ b/vtkm/filter/Streamline.h
@@ -12,8 +12,7 @@
 #define vtk_m_filter_Streamline_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterField.h>
-#include <vtkm/filter/NewFilterParticleAdvection.h>
+#include <vtkm/filter/NewFilterParticleAdvectionSteadyState.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
@@ -25,11 +24,11 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class Streamline : public vtkm::filter::NewFilterSteadyStateParticleAdvection
+class Streamline : public vtkm::filter::NewFilterParticleAdvectionSteadyState
 {
 public:
   VTKM_CONT Streamline()
-    : NewFilterSteadyStateParticleAdvection(
+    : NewFilterParticleAdvectionSteadyState(
         vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
   {
   }

From 5281b377b0290bd90bb6a6a086050a82f44bd862 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 18 Jul 2022 09:47:17 -0400
Subject: [PATCH 024/104] Add new base classes.

---
 .../NewFilterParticleAdvectionSteadyState.h   | 63 ++++++++++++++
 .../NewFilterParticleAdvectionUnsteadyState.h | 84 +++++++++++++++++++
 2 files changed, 147 insertions(+)
 create mode 100644 vtkm/filter/NewFilterParticleAdvectionSteadyState.h
 create mode 100644 vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h

diff --git a/vtkm/filter/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
new file mode 100644
index 000000000..31d7b66ac
--- /dev/null
+++ b/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
@@ -0,0 +1,63 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_NewFilterParticleAdvectionSteadyState_h
+#define vtk_m_filter_NewFilterParticleAdvectionSteadyState_h
+
+#include <vtkm/filter/NewFilterParticleAdvection.h>
+
+namespace vtkm
+{
+namespace filter
+{
+class NewFilterParticleAdvectionSteadyState : public NewFilterParticleAdvection
+{
+public:
+  VTKM_CONT
+  NewFilterParticleAdvectionSteadyState(
+    vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
+    : NewFilterParticleAdvection(rType)
+  {
+  }
+
+protected:
+  VTKM_CONT virtual void ValidateOptions() const override
+  {
+    this->NewFilterParticleAdvection::ValidateOptions();
+  }
+
+  VTKM_CONT std::vector<vtkm::filter::particleadvection::DSISteadyState*> CreateDataSetIntegrators(
+    const vtkm::cont::PartitionedDataSet& input,
+    const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
+  {
+    using DSIType = vtkm::filter::particleadvection::DSISteadyState;
+
+    std::string activeField = this->GetActiveFieldName();
+
+    std::vector<DSIType*> dsi;
+    for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
+    {
+      vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
+      auto ds = input.GetPartition(i);
+      if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
+        throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
+
+      dsi.push_back(new DSIType(
+        ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
+    }
+
+    return dsi;
+  }
+};
+
+}
+} // namespace vtkm::filter
+
+#endif // vtk_m_filter_NewFilterParticleAdvectionSteadyState_h
diff --git a/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h
new file mode 100644
index 000000000..21bb4bf61
--- /dev/null
+++ b/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h
@@ -0,0 +1,84 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_NewFilterParticleAdvectionUnsteadyState_h
+#define vtk_m_filter_NewFilterParticleAdvectionUnsteadyState_h
+
+#include <vtkm/filter/NewFilterParticleAdvection.h>
+
+namespace vtkm
+{
+namespace filter
+{
+
+class NewFilterParticleAdvectionUnsteadyState : public NewFilterParticleAdvection
+{
+public:
+  VTKM_CONT
+  NewFilterParticleAdvectionUnsteadyState(
+    vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
+    : NewFilterParticleAdvection(rType)
+  {
+  }
+
+  void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
+  void SetNextTime(vtkm::FloatDefault t2) { this->Time2 = t2; }
+  void SetNextDataSet(const vtkm::cont::DataSet& ds) { this->Input2 = { ds }; }
+  void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->Input2 = pds; }
+
+protected:
+  VTKM_CONT virtual void ValidateOptions() const override
+  {
+    this->NewFilterParticleAdvection::ValidateOptions();
+    if (this->Time1 >= this->Time2)
+      throw vtkm::cont::ErrorFilterExecution("PreviousTime must be less than NextTime");
+  }
+
+  VTKM_CONT std::vector<vtkm::filter::particleadvection::DSIUnsteadyState*>
+  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
+                           const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
+  {
+    using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
+
+    std::string activeField = this->GetActiveFieldName();
+
+    std::vector<DSIType*> dsi;
+    for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
+    {
+      vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
+      auto ds1 = input.GetPartition(i);
+      auto ds2 = this->Input2.GetPartition(i);
+      if ((!ds1.HasPointField(activeField) && !ds1.HasCellField(activeField)) ||
+          (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
+        throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
+
+      dsi.push_back(new DSIType(ds1,
+                                ds2,
+                                this->Time1,
+                                this->Time2,
+                                blockId,
+                                activeField,
+                                this->SolverType,
+                                this->VecFieldType,
+                                this->ResultType));
+    }
+
+    return dsi;
+  }
+
+  vtkm::cont::PartitionedDataSet Input2;
+  vtkm::FloatDefault Time1;
+  vtkm::FloatDefault Time2;
+};
+
+}
+} // namespace vtkm::filter
+
+#endif // vtk_m_filter_NewFilterParticleAdvectionUnsteadyState_h

From 2bfd0ce5927169f005d89874d52b84f96513cdfa Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 18 Jul 2022 13:42:34 -0400
Subject: [PATCH 025/104] Use ScatterPermutation to skip invalid cells.

---
 .../testing/UnitTestTubeFilter.cxx            | 23 +++++++++-
 .../filter/geometry_refinement/worklet/Tube.h | 46 +++++++++++++++----
 2 files changed, 59 insertions(+), 10 deletions(-)

diff --git a/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx b/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
index b864b9182..cf32fd9d6 100644
--- a/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
+++ b/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
@@ -43,6 +43,18 @@ void TestTubeFilters()
   appendPts(dsb, VecType(2, 1, 0), ids);
   dsb.AddCell(vtkm::CELL_SHAPE_POLY_LINE, ids);
 
+  //add some degenerate polylines.
+  //polyline with 1 point.
+  ids.clear();
+  appendPts(dsb, VecType(0, 0, 0), ids);
+  dsb.AddCell(vtkm::CELL_SHAPE_POLY_LINE, ids);
+
+  //polyline with coincident points.
+  ids.clear();
+  appendPts(dsb, VecType(0, 0, 0), ids);
+  appendPts(dsb, VecType(0, 0, 0), ids);
+  dsb.AddCell(vtkm::CELL_SHAPE_POLY_LINE, ids);
+
   vtkm::cont::DataSet ds = dsb.Create();
   std::vector<vtkm::FloatDefault> ptVar, cellVar;
 
@@ -53,7 +65,6 @@ void TestTubeFilters()
   cellVar.push_back(100);
   cellVar.push_back(101);
 
-
   //Polyline 2.
   ptVar.push_back(10);
   ptVar.push_back(11);
@@ -61,6 +72,16 @@ void TestTubeFilters()
   cellVar.push_back(110);
   cellVar.push_back(111);
 
+  //Add some degenerate polylines.
+  //Polyline 3 (only 1 point)
+  ptVar.push_back(-1);
+  cellVar.push_back(-1);
+  //Polyline 4 (2 coincident points)
+  ptVar.push_back(-1);
+  ptVar.push_back(-1);
+  cellVar.push_back(-1);
+  cellVar.push_back(-1);
+
   ds.AddPointField("pointVar", ptVar);
   ds.AddCellField("cellVar", cellVar);
 
diff --git a/vtkm/filter/geometry_refinement/worklet/Tube.h b/vtkm/filter/geometry_refinement/worklet/Tube.h
index eaa41f3c4..cc4c0c377 100644
--- a/vtkm/filter/geometry_refinement/worklet/Tube.h
+++ b/vtkm/filter/geometry_refinement/worklet/Tube.h
@@ -18,6 +18,7 @@
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/UnknownCellSet.h>
 #include <vtkm/worklet/DispatcherMapTopology.h>
+#include <vtkm/worklet/ScatterPermutation.h>
 #include <vtkm/worklet/WorkletMapField.h>
 #include <vtkm/worklet/WorkletMapTopology.h>
 
@@ -47,7 +48,8 @@ public:
                                   FieldOut ptsPerPolyline,
                                   FieldOut ptsPerTube,
                                   FieldOut numTubeConnIds,
-                                  FieldOut linesPerPolyline);
+                                  FieldOut linesPerPolyline,
+                                  FieldOut validCell);
     using ExecutionSignature = void(CellShape shapeType,
                                     PointCount numPoints,
                                     PointIndices ptIndices,
@@ -56,7 +58,8 @@ public:
                                     _4 ptsPerPolyline,
                                     _5 ptsPerTube,
                                     _6 numTubeConnIds,
-                                    _7 linesPerPolyline);
+                                    _7 linesPerPolyline,
+                                    _8 validCell);
     using InputDomain = _1;
 
     template <typename CellShapeTag, typename PointIndexType, typename InPointsType>
@@ -68,11 +71,14 @@ public:
                               vtkm::Id& ptsPerPolyline,
                               vtkm::Id& ptsPerTube,
                               vtkm::Id& numTubeConnIds,
-                              vtkm::Id& linesPerPolyline) const
+                              vtkm::Id& linesPerPolyline,
+                              vtkm::Id& validCell) const
     {
       // We only support polylines that contain 2 or more points.
       vtkm::IdComponent numNonCoincidentPoints = 1;
       vtkm::Vec3f p = inPts.Get(ptIndices[0]);
+
+      validCell = 0;
       for (int i = 1; i < numPoints; ++i)
       {
         vtkm::Vec3f pNext = inPts.Get(ptIndices[i]);
@@ -80,6 +86,7 @@ public:
         {
           numNonCoincidentPoints++;
           p = pNext;
+          validCell = 1;
         }
       }
 
@@ -101,6 +108,7 @@ public:
       }
       else
       {
+        validCell = 0;
         ptsPerPolyline = 0;
         nonIncidentPtsPerPolyline = 0;
         ptsPerTube = 0;
@@ -138,7 +146,12 @@ public:
                                     _3 polylineOffset,
                                     _4 outNormals);
     using InputDomain = _1;
-
+    using ScatterType = vtkm::worklet::ScatterPermutation<>;
+    VTKM_CONT
+    static ScatterType MakeScatter(const vtkm::cont::ArrayHandle<vtkm::Id>& validIds)
+    {
+      return ScatterType(validIds);
+    }
 
     template <typename InPointsType, typename PointIndexType>
     VTKM_EXEC vtkm::IdComponent FindValidSegment(const InPointsType& inPts,
@@ -151,7 +164,7 @@ public:
       while (end < numPoints)
       {
         auto pe = inPts.Get(ptIndices[end]);
-        if (vtkm::Magnitude(pe - ps) > 0)
+        if (vtkm::Magnitude(pe - ps) > vtkm::Epsilon<vtkm::FloatDefault>())
           return end - 1;
         end++;
       }
@@ -309,6 +322,12 @@ public:
                                     _7 outPts,
                                     _8 outPointSrcIdx);
     using InputDomain = _1;
+    using ScatterType = vtkm::worklet::ScatterPermutation<>;
+    VTKM_CONT
+    static ScatterType MakeScatter(const vtkm::cont::ArrayHandle<vtkm::Id>& validIds)
+    {
+      return ScatterType(validIds);
+    }
 
     template <typename CellShapeTag,
               typename PointIndexType,
@@ -603,7 +622,8 @@ public:
     }
 
     //Count number of polyline pts, tube pts and tube cells
-    vtkm::cont::ArrayHandle<vtkm::Id> ptsPerPolyline, ptsPerTube, numTubeConnIds, segPerPolyline;
+    vtkm::cont::ArrayHandle<vtkm::Id> ptsPerPolyline, ptsPerTube, numTubeConnIds, segPerPolyline,
+      validCell;
     vtkm::cont::ArrayHandle<vtkm::IdComponent> nonIncidentPtsPerPolyline;
     CountSegments countSegs(this->Capping, this->NumSides);
     vtkm::worklet::DispatcherMapTopology<CountSegments> countInvoker(countSegs);
@@ -613,7 +633,8 @@ public:
                         ptsPerPolyline,
                         ptsPerTube,
                         numTubeConnIds,
-                        segPerPolyline);
+                        segPerPolyline,
+                        validCell);
 
     vtkm::Id totalPolylinePts = vtkm::cont::Algorithm::Reduce(ptsPerPolyline, vtkm::Id(0));
     if (totalPolylinePts == 0)
@@ -633,17 +654,24 @@ public:
     vtkm::cont::Algorithm::ScanExclusive(numTubeConnIds, tubeConnOffsets);
     vtkm::cont::Algorithm::ScanExclusive(segPerPolyline, segOffset);
 
+    //Skip any cells marked invalid.
+    vtkm::cont::ArrayHandle<vtkm::Id> validIds;
+    vtkm::cont::Algorithm::CopyIf(
+      vtkm::cont::ArrayHandleIndex(cellset.GetNumberOfCells()), validCell, validIds);
+
     //Generate normals at each point on all polylines
     NormalsType normals;
     normals.Allocate(totalPolylinePts);
-    vtkm::worklet::DispatcherMapTopology<GenerateNormals> genNormalsDisp;
+    vtkm::worklet::DispatcherMapTopology<GenerateNormals> genNormalsDisp(
+      GenerateNormals::MakeScatter(validIds));
     genNormalsDisp.Invoke(cellset, coords, polylinePtOffset, normals);
 
     //Generate the tube points
     newPoints.Allocate(totalTubePts);
     this->OutputPointSourceIndex.Allocate(totalTubePts);
     GeneratePoints genPts(this->Capping, this->NumSides, this->Radius);
-    vtkm::worklet::DispatcherMapTopology<GeneratePoints> genPtsDisp(genPts);
+    vtkm::worklet::DispatcherMapTopology<GeneratePoints> genPtsDisp(
+      genPts, GeneratePoints::MakeScatter(validIds));
     genPtsDisp.Invoke(cellset,
                       coords,
                       normals,

From 3ce72b0e588c542353e0f4b27c1443f3651fde65 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 18 Jul 2022 13:54:41 -0400
Subject: [PATCH 026/104] Remove old files.

---
 vtkm/filter/ParticleAdvection2.h          | 49 ------------
 vtkm/filter/ParticleAdvection2.hxx        | 43 ----------
 vtkm/filter/PathParticle2.h               | 71 -----------------
 vtkm/filter/PathParticle2.hxx             | 97 -----------------------
 vtkm/filter/Pathline2.h                   | 49 ------------
 vtkm/filter/Pathline2.hxx                 | 45 -----------
 vtkm/filter/Streamline2.h                 | 49 ------------
 vtkm/filter/Streamline2.hxx               | 43 ----------
 vtkm/filter/particleadvection/BoundsMap.h |  2 +-
 9 files changed, 1 insertion(+), 447 deletions(-)
 delete mode 100644 vtkm/filter/ParticleAdvection2.h
 delete mode 100644 vtkm/filter/ParticleAdvection2.hxx
 delete mode 100644 vtkm/filter/PathParticle2.h
 delete mode 100644 vtkm/filter/PathParticle2.hxx
 delete mode 100644 vtkm/filter/Pathline2.h
 delete mode 100644 vtkm/filter/Pathline2.hxx
 delete mode 100644 vtkm/filter/Streamline2.h
 delete mode 100644 vtkm/filter/Streamline2.hxx

diff --git a/vtkm/filter/ParticleAdvection2.h b/vtkm/filter/ParticleAdvection2.h
deleted file mode 100644
index 8c8ab9aa9..000000000
--- a/vtkm/filter/ParticleAdvection2.h
+++ /dev/null
@@ -1,49 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_ParticleAdvection2_h
-#define vtk_m_filter_ParticleAdvection2_h
-
-#include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterField.h>
-#include <vtkm/filter/NewFilterParticleAdvection.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-
-namespace vtkm
-{
-namespace filter
-{
-/// \brief Advect particles in a vector field.
-
-/// Takes as input a vector field and seed locations and generates the
-/// end points for each seed through the vector field.
-
-class ParticleAdvection2 : public vtkm::filter::NewFilterSteadyStateParticleAdvection
-{
-public:
-  VTKM_CONT ParticleAdvection2()
-    : NewFilterSteadyStateParticleAdvection(
-        vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
-  {
-  }
-
-protected:
-  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
-    const vtkm::cont::PartitionedDataSet& inData) override;
-};
-
-}
-} // namespace vtkm::filter
-
-#ifndef vtk_m_filter_ParticleAdvection2_hxx
-#include <vtkm/filter/ParticleAdvection2.hxx>
-#endif
-
-#endif // vtk_m_filter_ParticleAdvection2_h
diff --git a/vtkm/filter/ParticleAdvection2.hxx b/vtkm/filter/ParticleAdvection2.hxx
deleted file mode 100644
index 16fba05ef..000000000
--- a/vtkm/filter/ParticleAdvection2.hxx
+++ /dev/null
@@ -1,43 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-#ifndef vtk_m_filter_ParticleAdvection2_hxx
-#define vtk_m_filter_ParticleAdvection2_hxx
-
-#include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/ParticleAdvection2.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-
-#include <vtkm/filter/particleadvection/DSISteadyState.h>
-#include <vtkm/filter/particleadvection/PAV.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-
-namespace vtkm
-{
-namespace filter
-{
-
-VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection2::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& input)
-{
-  using DSIType = vtkm::filter::particleadvection::DSISteadyState;
-  this->ValidateOptions();
-
-  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
-
-  vtkm::filter::particleadvection::PAV<DSIType> pav(
-    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
-}
-
-}
-} // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/PathParticle2.h b/vtkm/filter/PathParticle2.h
deleted file mode 100644
index c9056ee78..000000000
--- a/vtkm/filter/PathParticle2.h
+++ /dev/null
@@ -1,71 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_PathParticle2_h
-#define vtk_m_filter_PathParticle2_h
-
-#include <vtkm/Particle.h>
-#include <vtkm/filter/FilterParticleAdvection.h>
-#include <vtkm/filter/NewFilterField.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-
-namespace vtkm
-{
-namespace filter
-{
-/// \brief Advect particles in a vector field.
-
-/// Takes as input a vector field and seed locations and generates the
-/// end points for each seed through the vector field.
-
-class PathParticle2
-  : public vtkm::filter::FilterTemporalParticleAdvection<PathParticle2, vtkm::Particle>
-{
-public:
-  VTKM_CONT PathParticle2();
-
-  template <typename DerivedPolicy>
-  vtkm::cont::PartitionedDataSet PrepareForExecution(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
-
-  vtkm::cont::UnknownArrayHandle SeedArray;
-
-  void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
-  void SetNextTime(vtkm::FloatDefault t2) { this->Time2 = t2; }
-  void SetNextDataSet(const vtkm::cont::DataSet& ds) { this->DataSet2 = { ds }; }
-  void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->DataSet2 = pds; }
-
-  vtkm::cont::PartitionedDataSet DataSet2;
-  vtkm::FloatDefault Time1;
-  vtkm::FloatDefault Time2;
-};
-
-class PathParticle3 : public vtkm::filter::NewFilterField
-{
-public:
-  //  VTKM_CONT PathParticle3() {}
-
-protected:
-  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
-  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
-    const vtkm::cont::PartitionedDataSet& inData) override;
-
-  vtkm::cont::UnknownArrayHandle SeedArray;
-};
-
-}
-} // namespace vtkm::filter
-
-#ifndef vtk_m_filter_PathParticle2_hxx
-#include <vtkm/filter/PathParticle2.hxx>
-#endif
-
-#endif // vtk_m_filter_PathParticle2_h
diff --git a/vtkm/filter/PathParticle2.hxx b/vtkm/filter/PathParticle2.hxx
deleted file mode 100644
index 89b67b91e..000000000
--- a/vtkm/filter/PathParticle2.hxx
+++ /dev/null
@@ -1,97 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-#ifndef vtk_m_filter_PathParticle2_hxx
-#define vtk_m_filter_PathParticle2_hxx
-
-#include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/PathParticle2.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
-
-#include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
-#include <vtkm/filter/particleadvection/PAV.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-
-namespace vtkm
-{
-namespace filter
-{
-
-//-----------------------------------------------------------------------------
-inline VTKM_CONT PathParticle2::PathParticle2()
-  : vtkm::filter::FilterTemporalParticleAdvection<PathParticle2, vtkm::Particle>()
-{
-  this->ResultType =
-    vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE;
-}
-
-//-----------------------------------------------------------------------------
-template <typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle2::PrepareForExecution(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::PolicyBase<DerivedPolicy>&)
-{
-//  return input;
-#if 1
-  using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
-
-  this->ValidateOptions();
-  //Make sure everything matches up ok.
-  this->VecFieldType = vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE;
-
-  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
-  std::string activeField = this->GetActiveFieldName();
-
-  std::vector<DSIType*> dsi;
-  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
-  {
-    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-    auto ds1 = input.GetPartition(i);
-    auto ds2 = this->DataSet2.GetPartition(i);
-    if ((!ds1.HasPointField(activeField) && !ds1.HasCellField(activeField)) ||
-        (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
-      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
-
-    dsi.push_back(new DSIType(ds1,
-                              ds2,
-                              this->Time1,
-                              this->Time2,
-                              blockId,
-                              activeField,
-                              this->SolverType,
-                              this->VecFieldType,
-                              this->ResultType));
-  }
-
-  this->SeedArray = this->Seeds;
-  vtkm::filter::particleadvection::PAV<DSIType> pav(
-    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->SeedArray);
-#endif
-}
-
-VTKM_CONT vtkm::cont::DataSet PathParticle3::DoExecute(const vtkm::cont::DataSet& inData)
-{
-  std::cout << "Meow DS" << std::endl;
-  auto result = this->DoExecutePartitions(inData);
-  return result.GetPartition(0);
-}
-
-VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle3::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& inData)
-{
-  std::cout << "Meow pDS" << std::endl;
-  return inData;
-}
-
-}
-} // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/Pathline2.h b/vtkm/filter/Pathline2.h
deleted file mode 100644
index cd70bcf3c..000000000
--- a/vtkm/filter/Pathline2.h
+++ /dev/null
@@ -1,49 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_Pathline2_h
-#define vtk_m_filter_Pathline2_h
-
-#include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterField.h>
-#include <vtkm/filter/NewFilterParticleAdvection.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-
-namespace vtkm
-{
-namespace filter
-{
-/// \brief Advect particles in a vector field.
-
-/// Takes as input a vector field and seed locations and generates the
-/// end points for each seed through the vector field.
-
-class Pathline2 : public vtkm::filter::NewFilterUnsteadyStateParticleAdvection
-{
-public:
-  VTKM_CONT Pathline2()
-    : NewFilterUnsteadyStateParticleAdvection(
-        vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
-  {
-  }
-
-protected:
-  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
-    const vtkm::cont::PartitionedDataSet& inData) override;
-};
-
-}
-} // namespace vtkm::filter
-
-#ifndef vtk_m_filter_Pathline2_hxx
-#include <vtkm/filter/Pathline2.hxx>
-#endif
-
-#endif // vtk_m_filter_Pathline2_h
diff --git a/vtkm/filter/Pathline2.hxx b/vtkm/filter/Pathline2.hxx
deleted file mode 100644
index 36a48222d..000000000
--- a/vtkm/filter/Pathline2.hxx
+++ /dev/null
@@ -1,45 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-#ifndef vtk_m_filter_Pathline_hxx
-#define vtk_m_filter_Pathline_hxx
-
-#include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/Pathline.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
-
-#include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
-#include <vtkm/filter/particleadvection/PAV.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-
-namespace vtkm
-{
-namespace filter
-{
-
-VTKM_CONT vtkm::cont::PartitionedDataSet Pathline::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& input)
-{
-  using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
-  this->ValidateOptions();
-
-  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
-
-  vtkm::filter::particleadvection::PAV<DSIType> pav(
-    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
-}
-
-}
-} // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/Streamline2.h b/vtkm/filter/Streamline2.h
deleted file mode 100644
index 59b9cba95..000000000
--- a/vtkm/filter/Streamline2.h
+++ /dev/null
@@ -1,49 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_Streamline2_h
-#define vtk_m_filter_Streamline2_h
-
-#include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterField.h>
-#include <vtkm/filter/NewFilterParticleAdvection.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-
-namespace vtkm
-{
-namespace filter
-{
-/// \brief Advect particles in a vector field.
-
-/// Takes as input a vector field and seed locations and generates the
-/// end points for each seed through the vector field.
-
-class Streamline2 : public vtkm::filter::NewFilterSteadyStateParticleAdvection
-{
-public:
-  VTKM_CONT Streamline2()
-    : NewFilterSteadyStateParticleAdvection(
-        vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
-  {
-  }
-
-protected:
-  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
-    const vtkm::cont::PartitionedDataSet& inData) override;
-};
-
-}
-} // namespace vtkm::filter
-
-#ifndef vtk_m_filter_Streamline2_hxx
-#include <vtkm/filter/Streamline2.hxx>
-#endif
-
-#endif // vtk_m_filter_Streamline2_h
diff --git a/vtkm/filter/Streamline2.hxx b/vtkm/filter/Streamline2.hxx
deleted file mode 100644
index aeff1569b..000000000
--- a/vtkm/filter/Streamline2.hxx
+++ /dev/null
@@ -1,43 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-#ifndef vtk_m_filter_Streamline2_hxx
-#define vtk_m_filter_Streamline2_hxx
-
-#include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/Streamline2.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-
-#include <vtkm/filter/particleadvection/DSISteadyState.h>
-#include <vtkm/filter/particleadvection/PAV.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-
-namespace vtkm
-{
-namespace filter
-{
-
-VTKM_CONT vtkm::cont::PartitionedDataSet Streamline2::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& input)
-{
-  using DSIType = vtkm::filter::particleadvection::DSISteadyState;
-  this->ValidateOptions();
-
-  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
-
-  vtkm::filter::particleadvection::PAV<DSIType> pav(
-    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
-}
-
-}
-} // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/particleadvection/BoundsMap.h b/vtkm/filter/particleadvection/BoundsMap.h
index 4af93e954..705aba99a 100644
--- a/vtkm/filter/particleadvection/BoundsMap.h
+++ b/vtkm/filter/particleadvection/BoundsMap.h
@@ -107,7 +107,7 @@ public:
   vtkm::Id GetTotalNumBlocks() const { return this->TotalNumBlocks; }
   vtkm::Id GetLocalNumBlocks() const { return this->LocalNumBlocks; }
 
-  //private:
+private:
   void Init(const std::vector<vtkm::cont::DataSet>& dataSets)
   {
     vtkm::cont::AssignerPartitionedDataSet assigner(this->LocalNumBlocks);

From deb15bc14c33355b7d5f249c1cc5180617eb037d Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 19 Jul 2022 07:32:00 -0400
Subject: [PATCH 027/104] small edit to kick dashboards.

---
 .../filter/geometry_refinement/testing/UnitTestTubeFilter.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx b/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
index cf32fd9d6..9da451f4b 100644
--- a/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
+++ b/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
@@ -73,10 +73,10 @@ void TestTubeFilters()
   cellVar.push_back(111);
 
   //Add some degenerate polylines.
-  //Polyline 3 (only 1 point)
+  //Polyline 3: (only 1 point)
   ptVar.push_back(-1);
   cellVar.push_back(-1);
-  //Polyline 4 (2 coincident points)
+  //Polyline 4: (2 coincident points)
   ptVar.push_back(-1);
   ptVar.push_back(-1);
   cellVar.push_back(-1);

From 6353da486adbdcd6c8525fba5eea20796a9753df Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 19 Jul 2022 08:20:49 -0400
Subject: [PATCH 028/104] minor edit to kick dashboards.

---
 vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx | 1 -
 1 file changed, 1 deletion(-)

diff --git a/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx b/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
index 9da451f4b..1b038070f 100644
--- a/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
+++ b/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
@@ -114,7 +114,6 @@ void TestTubeFilters()
     VTKM_TEST_ASSERT(portal.Get(i) == ptVals[static_cast<std::size_t>(i)],
                      "Wrong value for point field");
 
-
   //Validate the cell field
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellArr;
   output.GetField("cellVar").GetData().AsArrayHandle(cellArr);

From 8ef3ac71e86d403a371ef3adbd1bf2f0c852b004 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 19 Jul 2022 09:09:38 -0400
Subject: [PATCH 029/104] Add in threaded algo.

---
 vtkm/filter/particleadvection/ABA.h         |  94 ----------
 vtkm/filter/particleadvection/ABAThreaded.h | 192 ++++++++++++++++++++
 vtkm/filter/particleadvection/PAV.h         |  40 ++--
 3 files changed, 219 insertions(+), 107 deletions(-)
 create mode 100644 vtkm/filter/particleadvection/ABAThreaded.h

diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/ABA.h
index f42da9c20..c9970122b 100644
--- a/vtkm/filter/particleadvection/ABA.h
+++ b/vtkm/filter/particleadvection/ABA.h
@@ -230,99 +230,6 @@ public:
       this->ParticleBlockIDsMap[it.first] = it.second;
   }
 
-  /*
-  void UpdateTerminated(const vtkm::cont::ArrayHandle<ParticleType>& particles,
-                        const std::vector<vtkm::Id>& idxTerm)
-  {
-    auto portal = particles.ReadPortal();
-    for (const auto& idx : idxTerm)
-      this->ParticleBlockIDsMap.erase(portal.Get(idx).ID);
-  }
-  */
-
-  /*
-  void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
-                         std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMapA,
-                         std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMapI,
-                         std::vector<ParticleType>& A,
-                         std::vector<ParticleType>& I,
-                         std::vector<vtkm::Id>& termIdx) const
-  {
-    A.clear();
-    I.clear();
-    termIdx.clear();
-    idsMapI.clear();
-    idsMapA.clear();
-
-    auto portal = particles.WritePortal();
-    vtkm::Id n = portal.GetNumberOfValues();
-
-    for (vtkm::Id i = 0; i < n; i++)
-    {
-      auto p = portal.Get(i);
-
-      if (p.Status.CheckTerminate())
-        termIdx.push_back(i);
-      else
-      {
-        const auto& it = this->ParticleBlockIDsMap.find(p.ID);
-        VTKM_ASSERT(it != this->ParticleBlockIDsMap.end());
-        auto currBIDs = it->second;
-        VTKM_ASSERT(!currBIDs.empty());
-
-        std::vector<vtkm::Id> newIDs;
-        if (p.Status.CheckSpatialBounds() && !p.Status.CheckTookAnySteps())
-          newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
-        else
-          newIDs = this->BoundsMap.FindBlocks(p.Pos, currBIDs);
-
-        //reset the particle status.
-        p.Status = vtkm::ParticleStatus();
-
-        if (newIDs.empty()) //No blocks, we're done.
-        {
-          p.Status.SetTerminate();
-          termIdx.push_back(i);
-        }
-        else
-        {
-          //If we have more than blockId, we want to minimize communication
-          //and put any blocks owned by this rank first.
-          if (newIDs.size() > 1)
-          {
-            for (auto idit = newIDs.begin(); idit != newIDs.end(); idit++)
-            {
-              vtkm::Id bid = *idit;
-              if (this->BoundsMap.FindRank(bid) == this->Rank)
-              {
-                newIDs.erase(idit);
-                newIDs.insert(newIDs.begin(), bid);
-                break;
-              }
-            }
-          }
-
-          int dstRank = this->BoundsMap.FindRank(newIDs[0]);
-          if (dstRank == this->Rank)
-          {
-            A.push_back(p);
-            idsMapA[p.ID] = newIDs;
-          }
-          else
-          {
-            I.push_back(p);
-            idsMapI[p.ID] = newIDs;
-          }
-        }
-        portal.Set(i, p);
-      }
-    }
-
-    //Make sure we didn't miss anything. Every particle goes into a single bucket.
-    VTKM_ASSERT(static_cast<std::size_t>(n) == (A.size() + I.size() + termIdx.size()));
-  }
-  */
-
   vtkm::Id UpdateResult(const DSIHelperInfo<ParticleType>& stuff)
   {
     this->UpdateActive(stuff.A, stuff.IdMapA);
@@ -365,7 +272,6 @@ public:
   vtkm::Id NumRanks;
   std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
   vtkm::Id Rank;
-  std::map<vtkm::Id, std::vector<ResultType<ParticleType>>> Results;
   vtkm::FloatDefault StepSize;
   vtkm::Id TotalNumParticles;
   vtkm::Id TotalNumTerminatedParticles;
diff --git a/vtkm/filter/particleadvection/ABAThreaded.h b/vtkm/filter/particleadvection/ABAThreaded.h
new file mode 100644
index 000000000..46126b8b5
--- /dev/null
+++ b/vtkm/filter/particleadvection/ABAThreaded.h
@@ -0,0 +1,192 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_ABAThreaded_h
+#define vtk_m_filter_ABAThreaded_h
+
+#include <vtkm/cont/PartitionedDataSet.h>
+#include <vtkm/filter/particleadvection/ABA.h>
+#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/ParticleMessenger.h>
+
+#include <thread>
+
+namespace vtkm
+{
+namespace filter
+{
+namespace particleadvection
+{
+
+template <typename DSIType, template <typename> class ResultType, typename ParticleType>
+class ABAThreaded : public ABA<DSIType, ResultType, ParticleType>
+{
+public:
+  ABAThreaded(const vtkm::filter::particleadvection::BoundsMap& bm, std::vector<DSIType*>& blocks)
+    : ABA<DSIType, ResultType, ParticleType>(bm, blocks)
+    , Done(false)
+    , WorkerActivate(false)
+  {
+    //For threaded algorithm, the particles go out of scope in the Work method.
+    //When this happens, they are destructed by the time the Manage thread gets them.
+    //Set the copy flag so the std::vector is copied into the ArrayHandle
+    for (auto block : this->Blocks)
+      block->SetCopySeedFlag(true);
+  }
+
+  void Go() override
+  {
+    vtkm::Id nLocal = static_cast<vtkm::Id>(this->Active.size() + this->Inactive.size());
+    this->ComputeTotalNumParticles(nLocal);
+
+    std::vector<std::thread> workerThreads;
+    workerThreads.push_back(std::thread(ABAThreaded::Worker, this));
+    this->Manage();
+
+    //This will only work for 1 thread. For > 1, the Blocks will need a mutex.
+    VTKM_ASSERT(workerThreads.size() == 1);
+    for (auto& t : workerThreads)
+      t.join();
+  }
+
+protected:
+  bool GetActiveParticles(std::vector<ParticleType>& particles, vtkm::Id& blockId) override
+  {
+    std::lock_guard<std::mutex> lock(this->Mutex);
+    bool val = this->ABA<DSIType, ResultType, ParticleType>::GetActiveParticles(particles, blockId);
+    this->WorkerActivate = val;
+    return val;
+  }
+
+  void UpdateActive(const std::vector<ParticleType>& particles,
+                    const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMap) override
+  {
+    if (!particles.empty())
+    {
+      std::lock_guard<std::mutex> lock(this->Mutex);
+      this->ABA<DSIType, ResultType, ParticleType>::UpdateActive(particles, idsMap);
+
+      //Let workers know there is new work
+      this->WorkerActivateCondition.notify_all();
+      this->WorkerActivate = true;
+    }
+  }
+
+  bool CheckDone()
+  {
+    std::lock_guard<std::mutex> lock(this->Mutex);
+    return this->Done;
+  }
+
+  void SetDone()
+  {
+    std::lock_guard<std::mutex> lock(this->Mutex);
+    this->Done = true;
+    this->WorkerActivateCondition.notify_all();
+  }
+
+  static void Worker(ABAThreaded* algo) { algo->Work(); }
+
+  void WorkerWait()
+  {
+    std::unique_lock<std::mutex> lock(this->Mutex);
+    this->WorkerActivateCondition.wait(lock, [this] { return WorkerActivate || Done; });
+  }
+
+  void UpdateWorkerResult(vtkm::Id blockId, DSIHelperInfoType& b)
+  {
+    std::lock_guard<std::mutex> lock(this->Mutex);
+    auto& it = this->WorkerResults[blockId];
+    it.push_back(b);
+  }
+
+  void Work()
+  {
+    while (!this->CheckDone())
+    {
+      std::vector<ParticleType> v;
+      vtkm::Id blockId = -1;
+      if (this->GetActiveParticles(v, blockId))
+      {
+        const auto& block = this->GetDataSet(blockId);
+        DSIHelperInfoType bb =
+          DSIHelperInfo<ParticleType>(v, this->BoundsMap, this->ParticleBlockIDsMap);
+        block->Advect(bb, this->StepSize, this->NumberOfSteps);
+        this->UpdateWorkerResult(blockId, bb);
+      }
+      else
+        this->WorkerWait();
+    }
+  }
+
+  void Manage()
+  {
+    vtkm::filter::particleadvection::ParticleMessenger<ParticleType> messenger(
+      this->Comm, this->BoundsMap, 1, 128);
+
+    while (this->TotalNumTerminatedParticles < this->TotalNumParticles)
+    {
+      std::unordered_map<vtkm::Id, std::vector<DSIHelperInfoType>> workerResults;
+      this->GetWorkerResults(workerResults);
+
+      vtkm::Id numTerm = 0;
+      for (auto& it : workerResults)
+      {
+        for (auto& r : it.second)
+          numTerm += this->UpdateResult(r.Get<DSIHelperInfo<ParticleType>>());
+      }
+
+      vtkm::Id numTermMessages = 0;
+      this->Communicate(messenger, numTerm, numTermMessages);
+
+      this->TotalNumTerminatedParticles += (numTerm + numTermMessages);
+      if (this->TotalNumTerminatedParticles > this->TotalNumParticles)
+        throw vtkm::cont::ErrorFilterExecution("Particle count error");
+    }
+
+    //Let the workers know that we are done.
+    this->SetDone();
+  }
+
+  bool GetBlockAndWait(const vtkm::Id& numLocalTerm) override
+  {
+    std::lock_guard<std::mutex> lock(this->Mutex);
+
+    return (this->ABA<DSIType, ResultType, ParticleType>::GetBlockAndWait(numLocalTerm) &&
+            !this->WorkerActivate && this->WorkerResults.empty());
+  }
+
+  void GetWorkerResults(std::unordered_map<vtkm::Id, std::vector<DSIHelperInfoType>>& results)
+  {
+    results.clear();
+
+    std::lock_guard<std::mutex> lock(this->Mutex);
+    if (!this->WorkerResults.empty())
+    {
+      results = this->WorkerResults;
+      this->WorkerResults.clear();
+    }
+  }
+
+  std::atomic<bool> Done;
+  std::mutex Mutex;
+  bool WorkerActivate;
+  std::condition_variable WorkerActivateCondition;
+  std::unordered_map<vtkm::Id, std::vector<DSIHelperInfoType>> WorkerResults;
+};
+
+}
+}
+}
+
+//#include <vtkm/filter/particleadvection/ABA.hxx>
+
+#endif //vtk_m_filter_ABAThreaded_h
diff --git a/vtkm/filter/particleadvection/PAV.h b/vtkm/filter/particleadvection/PAV.h
index f61fb5089..71068ef43 100644
--- a/vtkm/filter/particleadvection/PAV.h
+++ b/vtkm/filter/particleadvection/PAV.h
@@ -12,6 +12,7 @@
 #define vtk_m_filter_particleadvection_PAV_h
 
 #include <vtkm/filter/particleadvection/ABA.h>
+#include <vtkm/filter/particleadvection/ABAThreaded.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
 #include <vtkm/filter/particleadvection/DSI.h>
 
@@ -53,6 +54,16 @@ public:
   }
 
 private:
+  template <typename AlgorithmType, typename ParticleType>
+  vtkm::cont::PartitionedDataSet RunAlgo(vtkm::Id numSteps,
+                                         vtkm::FloatDefault stepSize,
+                                         const vtkm::cont::ArrayHandle<ParticleType>& seeds)
+  {
+    AlgorithmType algo(this->BoundsMap, this->Blocks);
+    algo.Execute(numSteps, stepSize, seeds);
+    return algo.GetOutput();
+  }
+
   template <typename ParticleType>
   vtkm::cont::PartitionedDataSet Execute(vtkm::Id numSteps,
                                          vtkm::FloatDefault stepSize,
@@ -60,36 +71,39 @@ private:
   {
     if (!this->UseThreadedAlgorithm)
     {
-      //make a templated algorithm execution()
       if (this->ResultType ==
           vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
       {
         using AlgorithmType = vtkm::filter::particleadvection::
           ABA<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
 
-        AlgorithmType algo(this->BoundsMap, this->Blocks);
-        algo.Execute(numSteps, stepSize, seeds);
-        return algo.GetOutput();
+        return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
       else
       {
         using AlgorithmType = vtkm::filter::particleadvection::
           ABA<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
 
-        AlgorithmType algo(this->BoundsMap, this->Blocks);
-        algo.Execute(numSteps, stepSize, seeds);
-        return algo.GetOutput();
+        return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
     }
     else
     {
-      std::cout << "Change me to threaded ABA" << std::endl;
-      using AlgorithmType = vtkm::filter::particleadvection::
-        ABA<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
+      if (this->ResultType ==
+          vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+      {
+        using AlgorithmType = vtkm::filter::particleadvection::
+          ABAThreaded<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
 
-      AlgorithmType algo(this->BoundsMap, this->Blocks);
-      algo.Execute(numSteps, stepSize, seeds);
-      return algo.GetOutput();
+        return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
+      }
+      else
+      {
+        using AlgorithmType = vtkm::filter::particleadvection::
+          ABAThreaded<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
+
+        return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
+      }
     }
   }
 

From 02eabf54511d5ab71954cdeba10ffd5269d8a7bc Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 19 Jul 2022 10:22:37 -0400
Subject: [PATCH 030/104] Fix build errors.

---
 vtkm/filter/particleadvection/CMakeLists.txt        | 1 +
 vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/vtkm/filter/particleadvection/CMakeLists.txt b/vtkm/filter/particleadvection/CMakeLists.txt
index 475a348d3..529a45bbc 100644
--- a/vtkm/filter/particleadvection/CMakeLists.txt
+++ b/vtkm/filter/particleadvection/CMakeLists.txt
@@ -25,6 +25,7 @@ set(headers
   DSISteadyState.hxx
   DSIUnsteadyState.hxx
   ABA.h
+  ABAThreaded.h
   PAV.h
   ParticleAdvectionTypes.h
 )
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
index cfe2eeabf..00c50c4ed 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
@@ -10,7 +10,6 @@
 
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/ParticleAdvection.h>
-#include <vtkm/filter/ParticleAdvection2.h>
 #include <vtkm/filter/Pathline.h>
 #include <vtkm/filter/Streamline.h>
 #include <vtkm/thirdparty/diy/diy.h>

From a2d5f5249a8de31afe593d872236679a907c93b9 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 19 Jul 2022 12:44:17 -0400
Subject: [PATCH 031/104] kick dashboard...

---
 vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx | 1 -
 1 file changed, 1 deletion(-)

diff --git a/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx b/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
index 1b038070f..a6a7e8736 100644
--- a/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
+++ b/vtkm/filter/geometry_refinement/testing/UnitTestTubeFilter.cxx
@@ -23,7 +23,6 @@ void appendPts(vtkm::cont::DataSetBuilderExplicitIterative& dsb,
   ids.push_back(pid);
 }
 
-
 void TestTubeFilters()
 {
   using VecType = vtkm::Vec3f;

From 70f6b2fe2744bbff4a1d15ef8dc4e1080a3592be Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 19 Jul 2022 13:27:29 -0400
Subject: [PATCH 032/104] Remove old files....

---
 vtkm/filter/PathParticle.hxx                  |   2 -
 .../particleadvection/AdvectorBaseAlgorithm.h | 573 ------------------
 .../AdvectorBaseAlgorithm.hxx                 | 161 -----
 .../AdvectorBaseThreadedAlgorithm.h           | 191 ------
 vtkm/filter/particleadvection/CMakeLists.txt  |   6 -
 .../particleadvection/DataSetIntegrator.h     | 142 -----
 .../particleadvection/DataSetIntegrator.hxx   |  91 ---
 .../ParticleAdvectionAlgorithm.h              |   4 -
 8 files changed, 1170 deletions(-)
 delete mode 100644 vtkm/filter/particleadvection/AdvectorBaseAlgorithm.h
 delete mode 100644 vtkm/filter/particleadvection/AdvectorBaseAlgorithm.hxx
 delete mode 100644 vtkm/filter/particleadvection/AdvectorBaseThreadedAlgorithm.h
 delete mode 100644 vtkm/filter/particleadvection/DataSetIntegrator.h
 delete mode 100644 vtkm/filter/particleadvection/DataSetIntegrator.hxx

diff --git a/vtkm/filter/PathParticle.hxx b/vtkm/filter/PathParticle.hxx
index 2bbf3db02..1844818ac 100644
--- a/vtkm/filter/PathParticle.hxx
+++ b/vtkm/filter/PathParticle.hxx
@@ -13,8 +13,6 @@
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/PathParticle.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
 
 #include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
 #include <vtkm/filter/particleadvection/PAV.h>
diff --git a/vtkm/filter/particleadvection/AdvectorBaseAlgorithm.h b/vtkm/filter/particleadvection/AdvectorBaseAlgorithm.h
deleted file mode 100644
index 5384dc709..000000000
--- a/vtkm/filter/particleadvection/AdvectorBaseAlgorithm.h
+++ /dev/null
@@ -1,573 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_particleadvection_AdvectorBaseAlgorithm_h
-#define vtk_m_filter_particleadvection_AdvectorBaseAlgorithm_h
-
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayHandlePermutation.h>
-#include <vtkm/cont/ConvertNumComponentsToOffsets.h>
-#include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/cont/ParticleArrayCopy.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleMessenger.h>
-
-#include <map>
-#include <vector>
-
-namespace vtkm
-{
-namespace filter
-{
-namespace particleadvection
-{
-
-namespace internal
-{
-
-//Helper class to store the different result types.
-//template <typename ResultType>
-template <template <typename> class ResultType, typename ParticleType>
-class ResultHelper;
-
-//Specialization for ParticleAdvectionResult
-//using PAType = vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>;
-
-template <typename ParticleType>
-class ResultHelper<vtkm::worklet::ParticleAdvectionResult, ParticleType>
-{
-  using PAType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
-
-public:
-  static void Store(std::map<vtkm::Id, std::vector<PAType>>& results,
-                    const PAType& res,
-                    vtkm::Id blockId,
-                    const std::vector<vtkm::Id>& indices)
-  {
-    std::cout << "Store: indices= " << indices.size() << std::endl;
-    if (indices.empty())
-      return;
-
-    //Selected out the terminated particles and store them.
-    vtkm::cont::ArrayHandle<ParticleType> termParticles;
-    auto indicesAH = vtkm::cont::make_ArrayHandle(indices, vtkm::CopyFlag::Off);
-    auto perm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, res.Particles);
-
-    vtkm::cont::Algorithm::Copy(perm, termParticles);
-    PAType termRes(termParticles);
-    results[blockId].push_back(termRes);
-    std::cout << "Store: " << results.size() << std::endl;
-  }
-
-  static vtkm::cont::PartitionedDataSet GetOutput(
-    const std::map<vtkm::Id, std::vector<PAType>>& results)
-  {
-    vtkm::cont::PartitionedDataSet output;
-    for (const auto& it : results)
-    {
-      std::size_t nResults = it.second.size();
-      if (nResults == 0)
-        continue;
-
-      std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
-      allParticles.reserve(static_cast<std::size_t>(nResults));
-
-      for (const auto& res : it.second)
-        allParticles.push_back(res.Particles);
-
-      vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
-      vtkm::cont::ParticleArrayCopy(allParticles, pts);
-
-      vtkm::cont::DataSet ds;
-      vtkm::cont::CoordinateSystem outCoords("coordinates", pts);
-      ds.AddCoordinateSystem(outCoords);
-
-      //Create vertex cell set
-      vtkm::Id numPoints = pts.GetNumberOfValues();
-      vtkm::cont::CellSetSingleType<> cells;
-      vtkm::cont::ArrayHandleIndex conn(numPoints);
-      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
-
-      vtkm::cont::ArrayCopy(conn, connectivity);
-      cells.Fill(numPoints, vtkm::CELL_SHAPE_VERTEX, 1, connectivity);
-      ds.SetCellSet(cells);
-
-      output.AppendPartition(ds);
-    }
-
-    return output;
-  }
-};
-
-//Specialization for StreamlineResult
-//using SLType = vtkm::worklet::StreamlineResult<vtkm::Particle>;
-
-template <typename ParticleType>
-class ResultHelper<vtkm::worklet::StreamlineResult, ParticleType>
-{
-  using SLType = vtkm::worklet::StreamlineResult<ParticleType>;
-
-public:
-  static void Store(std::map<vtkm::Id, std::vector<SLType>>& results,
-                    const SLType& res,
-                    vtkm::Id blockId,
-                    const std::vector<vtkm::Id>& vtkmNotUsed(indices))
-  {
-    results[blockId].push_back(res);
-  }
-
-  static vtkm::cont::PartitionedDataSet GetOutput(
-    const std::map<vtkm::Id, std::vector<SLType>>& results)
-  {
-    vtkm::cont::PartitionedDataSet output;
-    for (const auto& it : results)
-    {
-      std::size_t nResults = it.second.size();
-      if (nResults == 0)
-        continue;
-
-      vtkm::cont::DataSet ds;
-      //Easy case with one result.
-      if (nResults == 1)
-      {
-        ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", it.second[0].Positions));
-        ds.SetCellSet(it.second[0].PolyLines);
-      }
-      else
-      {
-        //Append all the results into one data set.
-        vtkm::cont::ArrayHandle<vtkm::Vec3f> appendPts;
-        std::vector<vtkm::Id> posOffsets(nResults);
-
-        const auto& res0 = it.second[0];
-        vtkm::Id totalNumCells = res0.PolyLines.GetNumberOfCells();
-        vtkm::Id totalNumPts = res0.Positions.GetNumberOfValues();
-
-        posOffsets[0] = 0;
-        for (std::size_t i = 1; i < nResults; i++)
-        {
-          const auto& res = it.second[i];
-          posOffsets[i] = totalNumPts;
-          totalNumPts += res.Positions.GetNumberOfValues();
-          totalNumCells += res.PolyLines.GetNumberOfCells();
-        }
-
-        //Append all the points together.
-        appendPts.Allocate(totalNumPts);
-        for (std::size_t i = 0; i < nResults; i++)
-        {
-          const auto& res = it.second[i];
-          // copy all values into appendPts starting at offset.
-          vtkm::cont::Algorithm::CopySubRange(
-            res.Positions, 0, res.Positions.GetNumberOfValues(), appendPts, posOffsets[i]);
-        }
-        vtkm::cont::CoordinateSystem outputCoords =
-          vtkm::cont::CoordinateSystem("coordinates", appendPts);
-        ds.AddCoordinateSystem(outputCoords);
-
-        //Create polylines.
-        std::vector<vtkm::Id> numPtsPerCell(static_cast<std::size_t>(totalNumCells));
-        std::size_t off = 0;
-        for (std::size_t i = 0; i < nResults; i++)
-        {
-          const auto& res = it.second[i];
-          vtkm::Id nCells = res.PolyLines.GetNumberOfCells();
-          for (vtkm::Id j = 0; j < nCells; j++)
-            numPtsPerCell[off++] = static_cast<vtkm::Id>(res.PolyLines.GetNumberOfPointsInCell(j));
-        }
-
-        auto numPointsPerCellArray =
-          vtkm::cont::make_ArrayHandle(numPtsPerCell, vtkm::CopyFlag::Off);
-
-        vtkm::cont::ArrayHandle<vtkm::Id> cellIndex;
-        vtkm::Id connectivityLen =
-          vtkm::cont::Algorithm::ScanExclusive(numPointsPerCellArray, cellIndex);
-        vtkm::cont::ArrayHandleIndex connCount(connectivityLen);
-        vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
-        vtkm::cont::ArrayCopy(connCount, connectivity);
-
-        vtkm::cont::ArrayHandle<vtkm::UInt8> cellTypes;
-        auto polyLineShape = vtkm::cont::make_ArrayHandleConstant<vtkm::UInt8>(
-          vtkm::CELL_SHAPE_POLY_LINE, totalNumCells);
-        vtkm::cont::ArrayCopy(polyLineShape, cellTypes);
-        auto offsets = vtkm::cont::ConvertNumComponentsToOffsets(numPointsPerCellArray);
-
-        vtkm::cont::CellSetExplicit<> polyLines;
-        polyLines.Fill(totalNumPts, cellTypes, connectivity, offsets);
-        ds.SetCellSet(polyLines);
-      }
-      output.AppendPartition(ds);
-    }
-
-    return output;
-  }
-};
-};
-
-
-template <typename DataSetIntegratorType, typename AlgorithmType>
-vtkm::cont::PartitionedDataSet RunAlgo(const vtkm::filter::particleadvection::BoundsMap& boundsMap,
-                                       const std::vector<DataSetIntegratorType>& dsi,
-                                       vtkm::Id numSteps,
-                                       vtkm::FloatDefault stepSize,
-                                       const vtkm::cont::ArrayHandle<vtkm::Particle>& seeds)
-{
-  AlgorithmType algo(boundsMap, dsi);
-
-  algo.SetNumberOfSteps(numSteps);
-  algo.SetStepSize(stepSize);
-  algo.SetSeeds(seeds);
-  algo.Go();
-  return algo.GetOutput();
-}
-
-#if 0
-//
-// Base class for particle advector
-//
-template <typename DataSetIntegratorType, typename ResultType>
-class VTKM_ALWAYS_EXPORT AdvectorBaseAlgorithm
-{
-public:
-  AdvectorBaseAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                        const std::vector<DataSetIntegratorType>& blocks)
-    : Blocks(blocks)
-    , BoundsMap(bm)
-    , NumberOfSteps(0)
-    , NumRanks(this->Comm.size())
-    , Rank(this->Comm.rank())
-    , StepSize(0)
-    , TotalNumParticles(0)
-    , TotalNumTerminatedParticles(0)
-  {
-  }
-
-  //Initialize ParticleAdvectorBase
-  void SetStepSize(vtkm::FloatDefault stepSize) { this->StepSize = stepSize; }
-  void SetNumberOfSteps(vtkm::Id numSteps) { this->NumberOfSteps = numSteps; }
-  void SetSeeds(const vtkm::cont::ArrayHandle<vtkm::Particle>& seeds)
-  {
-    this->ClearParticles();
-
-    vtkm::Id n = seeds.GetNumberOfValues();
-    auto portal = seeds.ReadPortal();
-
-    std::vector<std::vector<vtkm::Id>> blockIDs;
-    std::vector<vtkm::Particle> particles;
-    for (vtkm::Id i = 0; i < n; i++)
-    {
-      const vtkm::Particle p = portal.Get(i);
-      std::vector<vtkm::Id> ids = this->BoundsMap.FindBlocks(p.Pos);
-      if (!ids.empty() && this->BoundsMap.FindRank(ids[0]) == this->Rank)
-      {
-        particles.push_back(p);
-        blockIDs.push_back(ids);
-      }
-    }
-
-    this->SetSeedArray(particles, blockIDs);
-  }
-
-  //Advect all the particles.
-  virtual void Go()
-  {
-    vtkm::filter::particleadvection::ParticleMessenger messenger(
-      this->Comm, this->BoundsMap, 1, 128);
-
-    vtkm::Id nLocal = static_cast<vtkm::Id>(this->Active.size() + this->Inactive.size());
-    this->ComputeTotalNumParticles(nLocal);
-    this->TotalNumTerminatedParticles = 0;
-
-    while (this->TotalNumTerminatedParticles < this->TotalNumParticles)
-    {
-      std::vector<vtkm::Particle> v;
-      vtkm::Id numTerm = 0, blockId = -1;
-      if (GetActiveParticles(v, blockId))
-      {
-        const auto& block = this->GetDataSet(blockId);
-        ResultType r;
-        block.Advect(v, this->StepSize, this->NumberOfSteps, r);
-        numTerm = this->UpdateResult(r, blockId);
-      }
-
-      vtkm::Id numTermMessages = 0;
-      this->Communicate(messenger, numTerm, numTermMessages);
-
-      this->TotalNumTerminatedParticles += (numTerm + numTermMessages);
-      if (this->TotalNumTerminatedParticles > this->TotalNumParticles)
-        throw vtkm::cont::ErrorFilterExecution("Particle count error");
-    }
-  }
-
-  vtkm::cont::PartitionedDataSet GetOutput() const
-  {
-    std::cout<<" ************************** "<<__FILE__<<" "<<__LINE__<<std::endl;
-    //return internal::ResultHelper<ResultType, vtkm::Particle>::GetOutput(this->Results);
-    return vtkm::cont::PartitionedDataSet();
-  }
-
-protected:
-  virtual void ClearParticles()
-  {
-    this->Active.clear();
-    this->Inactive.clear();
-    this->ParticleBlockIDsMap.clear();
-  }
-
-  void ComputeTotalNumParticles(const vtkm::Id& numLocal)
-  {
-    long long total = static_cast<long long>(numLocal);
-#ifdef VTKM_ENABLE_MPI
-    MPI_Comm mpiComm = vtkmdiy::mpi::mpi_cast(this->Comm.handle());
-    MPI_Allreduce(MPI_IN_PLACE, &total, 1, MPI_LONG_LONG, MPI_SUM, mpiComm);
-#endif
-    this->TotalNumParticles = static_cast<vtkm::Id>(total);
-  }
-
-  const DataSetIntegratorType& GetDataSet(vtkm::Id id) const
-  {
-    for (const auto& it : this->Blocks)
-      if (it.GetID() == id)
-        return it;
-    throw vtkm::cont::ErrorFilterExecution("Bad block");
-  }
-
-  virtual void SetSeedArray(const std::vector<vtkm::Particle>& particles,
-                            const std::vector<std::vector<vtkm::Id>>& blockIds)
-  {
-    VTKM_ASSERT(particles.size() == blockIds.size());
-
-    auto pit = particles.begin();
-    auto bit = blockIds.begin();
-    while (pit != particles.end() && bit != blockIds.end())
-    {
-      this->ParticleBlockIDsMap[pit->ID] = *bit;
-      pit++;
-      bit++;
-    }
-
-    this->Active.insert(this->Active.end(), particles.begin(), particles.end());
-  }
-
-  virtual bool GetActiveParticles(std::vector<vtkm::Particle>& particles, vtkm::Id& blockId)
-  {
-    particles.clear();
-    blockId = -1;
-    if (this->Active.empty())
-      return false;
-
-    blockId = this->ParticleBlockIDsMap[this->Active.front().ID][0];
-    auto it = this->Active.begin();
-    while (it != this->Active.end())
-    {
-      auto p = *it;
-      if (blockId == this->ParticleBlockIDsMap[p.ID][0])
-      {
-        particles.push_back(p);
-        it = this->Active.erase(it);
-      }
-      else
-        it++;
-    }
-
-    return !particles.empty();
-  }
-
-  virtual void Communicate(vtkm::filter::particleadvection::ParticleMessenger& messenger,
-                           vtkm::Id numLocalTerminations,
-                           vtkm::Id& numTermMessages)
-  {
-    std::vector<vtkm::Particle> incoming;
-    std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> incomingIDs;
-    numTermMessages = 0;
-    messenger.Exchange(this->Inactive,
-                       this->ParticleBlockIDsMap,
-                       numLocalTerminations,
-                       incoming,
-                       incomingIDs,
-                       numTermMessages,
-                       this->GetBlockAndWait(numLocalTerminations));
-
-    this->Inactive.clear();
-    this->UpdateActive(incoming, incomingIDs);
-  }
-
-  virtual void UpdateActive(const std::vector<vtkm::Particle>& particles,
-                            const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMap)
-  {
-    this->Update(this->Active, particles, idsMap);
-  }
-
-  virtual void UpdateInactive(const std::vector<vtkm::Particle>& particles,
-                              const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMap)
-  {
-    this->Update(this->Inactive, particles, idsMap);
-  }
-
-  void Update(std::vector<vtkm::Particle>& arr,
-              const std::vector<vtkm::Particle>& particles,
-              const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMap)
-  {
-    VTKM_ASSERT(particles.size() == idsMap.size());
-
-    arr.insert(arr.end(), particles.begin(), particles.end());
-    for (const auto& it : idsMap)
-      this->ParticleBlockIDsMap[it.first] = it.second;
-  }
-
-  void UpdateTerminated(const vtkm::cont::ArrayHandle<vtkm::Particle>& particles,
-                        const std::vector<vtkm::Id>& idxTerm)
-  {
-    auto portal = particles.ReadPortal();
-    for (const auto& idx : idxTerm)
-      this->ParticleBlockIDsMap.erase(portal.Get(idx).ID);
-  }
-
-  void ClassifyParticles(const vtkm::cont::ArrayHandle<vtkm::Particle>& particles,
-                         std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMapA,
-                         std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMapI,
-                         std::vector<vtkm::Particle>& A,
-                         std::vector<vtkm::Particle>& I,
-                         std::vector<vtkm::Id>& termIdx) const
-  {
-    A.clear();
-    I.clear();
-    termIdx.clear();
-    idsMapI.clear();
-    idsMapA.clear();
-
-    auto portal = particles.WritePortal();
-    vtkm::Id n = portal.GetNumberOfValues();
-
-    for (vtkm::Id i = 0; i < n; i++)
-    {
-      auto p = portal.Get(i);
-
-      if (p.Status.CheckTerminate())
-        termIdx.push_back(i);
-      else
-      {
-        const auto& it = this->ParticleBlockIDsMap.find(p.ID);
-        VTKM_ASSERT(it != this->ParticleBlockIDsMap.end());
-        auto currBIDs = it->second;
-        VTKM_ASSERT(!currBIDs.empty());
-
-        std::vector<vtkm::Id> newIDs;
-        if (p.Status.CheckSpatialBounds() && !p.Status.CheckTookAnySteps())
-          newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
-        else
-          newIDs = this->BoundsMap.FindBlocks(p.Pos, currBIDs);
-
-        //reset the particle status.
-        p.Status = vtkm::ParticleStatus();
-
-        if (newIDs.empty()) //No blocks, we're done.
-        {
-          p.Status.SetTerminate();
-          termIdx.push_back(i);
-        }
-        else
-        {
-          //If we have more than blockId, we want to minimize communication
-          //and put any blocks owned by this rank first.
-          if (newIDs.size() > 1)
-          {
-            for (auto idit = newIDs.begin(); idit != newIDs.end(); idit++)
-            {
-              vtkm::Id bid = *idit;
-              if (this->BoundsMap.FindRank(bid) == this->Rank)
-              {
-                newIDs.erase(idit);
-                newIDs.insert(newIDs.begin(), bid);
-                break;
-              }
-            }
-          }
-
-          int dstRank = this->BoundsMap.FindRank(newIDs[0]);
-          if (dstRank == this->Rank)
-          {
-            A.push_back(p);
-            idsMapA[p.ID] = newIDs;
-          }
-          else
-          {
-            I.push_back(p);
-            idsMapI[p.ID] = newIDs;
-          }
-        }
-        portal.Set(i, p);
-      }
-    }
-
-    //Make sure we didn't miss anything. Every particle goes into a single bucket.
-    VTKM_ASSERT(static_cast<std::size_t>(n) == (A.size() + I.size() + termIdx.size()));
-  }
-
-
-  vtkm::Id UpdateResult(ResultType& res, vtkm::Id /*blockId*/)
-  {
-    std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> idsMapI, idsMapA;
-    std::vector<vtkm::Particle> A, I;
-    std::vector<vtkm::Id> termIdx;
-    this->ClassifyParticles(res.Particles, idsMapA, idsMapI, A, I, termIdx);
-
-    //Update active, inactive and terminated
-    this->UpdateActive(A, idsMapA);
-    this->UpdateInactive(I, idsMapI);
-
-    vtkm::Id numTerm = static_cast<vtkm::Id>(termIdx.size());
-    if (numTerm > 0)
-      this->UpdateTerminated(res.Particles, termIdx);
-
-    std::cout<<" ************************** "<<__FILE__<<" "<<__LINE__<<std::endl;
-    //internal::ResultHelper<ResultType, vtkm::Particle>::Store(this->Results, res, blockId, termIdx);
-
-    return numTerm;
-  }
-
-  virtual bool GetBlockAndWait(const vtkm::Id& numLocalTerm)
-  {
-    //There are only two cases where blocking would deadlock.
-    //1. There are active particles.
-    //2. numLocalTerm + this->TotalNumberOfTerminatedParticles == this->TotalNumberOfParticles
-    //So, if neither are true, we can safely block and wait for communication to come in.
-
-    if (this->Active.empty() && this->Inactive.empty() &&
-        (numLocalTerm + this->TotalNumTerminatedParticles < this->TotalNumParticles))
-    {
-      return true;
-    }
-
-    return false;
-  }
-
-  //Member data
-  std::vector<vtkm::Particle> Active;
-  std::vector<DataSetIntegratorType> Blocks;
-  vtkm::filter::particleadvection::BoundsMap BoundsMap;
-  vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
-  std::vector<vtkm::Particle> Inactive;
-  vtkm::Id NumberOfSteps;
-  vtkm::Id NumRanks;
-  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
-  vtkm::Id Rank;
-  std::map<vtkm::Id, std::vector<ResultType>> Results;
-  vtkm::FloatDefault StepSize;
-  vtkm::Id TotalNumParticles;
-  vtkm::Id TotalNumTerminatedParticles;
-};
-#endif
-
-}
-}
-} // namespace vtkm::filter::particleadvection
-
-#endif
diff --git a/vtkm/filter/particleadvection/AdvectorBaseAlgorithm.hxx b/vtkm/filter/particleadvection/AdvectorBaseAlgorithm.hxx
deleted file mode 100644
index 6baf02f6e..000000000
--- a/vtkm/filter/particleadvection/AdvectorBaseAlgorithm.hxx
+++ /dev/null
@@ -1,161 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_particleadvection_AdvectorBaseAlgorithm_hxx
-#define vtk_m_filter_particleadvection_AdvectorBaseAlgorithm_hxx
-
-namespace vtkm
-{
-namespace filter
-{
-namespace particleadvection
-{
-
-using PAResultType = vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>;
-using SLResultType = vtkm::worklet::StreamlineResult<vtkm::Particle>;
-
-//Result specific implementation.
-template <>
-inline void AdvectorBaseAlgorithm<PAResultType>::StoreResult(const PAResultType& vtkmNotUsed(res),
-                                                             vtkm::Id vtkmNotUsed(blockId))
-{
-}
-
-template <>
-inline void AdvectorBaseAlgorithm<SLResultType>::StoreResult(const SLResultType& res,
-                                                             vtkm::Id blockId)
-{
-  this->Results[blockId].push_back(res);
-}
-
-template <>
-inline vtkm::cont::PartitionedDataSet AdvectorBaseAlgorithm<PAResultType>::GetOutput()
-{
-  vtkm::cont::PartitionedDataSet output;
-
-  for (const auto& it : this->Terminated)
-  {
-    if (it.second.empty())
-      continue;
-
-    auto particles = vtkm::cont::make_ArrayHandle(it.second, vtkm::CopyFlag::Off);
-    vtkm::cont::ArrayHandle<vtkm::Vec3f> pos;
-    vtkm::cont::ParticleArrayCopy(particles, pos);
-
-    vtkm::cont::DataSet ds;
-    vtkm::cont::CoordinateSystem outCoords("coordinates", pos);
-    ds.AddCoordinateSystem(outCoords);
-
-    //Create vertex cell set
-    vtkm::Id numPoints = pos.GetNumberOfValues();
-    vtkm::cont::CellSetSingleType<> cells;
-    vtkm::cont::ArrayHandleIndex conn(numPoints);
-    vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
-
-    vtkm::cont::ArrayCopy(conn, connectivity);
-    cells.Fill(numPoints, vtkm::CELL_SHAPE_VERTEX, 1, connectivity);
-    ds.SetCellSet(cells);
-
-    output.AppendPartition(ds);
-  }
-
-  return output;
-}
-
-template <>
-inline vtkm::cont::PartitionedDataSet AdvectorBaseAlgorithm<SLResultType>::GetOutput()
-{
-  vtkm::cont::PartitionedDataSet output;
-
-  for (const auto& it : this->Results)
-  {
-    std::size_t nResults = it.second.size();
-    if (nResults == 0)
-      continue;
-
-    vtkm::cont::DataSet ds;
-    //Easy case with one result.
-    if (nResults == 1)
-    {
-      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", it.second[0].Positions));
-      ds.SetCellSet(it.second[0].PolyLines);
-    }
-    else
-    {
-      //Append all the results into one data set.
-      vtkm::cont::ArrayHandle<vtkm::Vec3f> appendPts;
-      std::vector<vtkm::Id> posOffsets(nResults);
-
-      const auto& res0 = it.second[0];
-      vtkm::Id totalNumCells = res0.PolyLines.GetNumberOfCells();
-      vtkm::Id totalNumPts = res0.Positions.GetNumberOfValues();
-
-      posOffsets[0] = 0;
-      for (std::size_t i = 1; i < nResults; i++)
-      {
-        const auto& res = it.second[i];
-        posOffsets[i] = totalNumPts;
-        totalNumPts += res.Positions.GetNumberOfValues();
-        totalNumCells += res.PolyLines.GetNumberOfCells();
-      }
-
-      //Append all the points together.
-      appendPts.Allocate(totalNumPts);
-      for (std::size_t i = 0; i < nResults; i++)
-      {
-        const auto& res = it.second[i];
-        // copy all values into appendPts starting at offset.
-        vtkm::cont::Algorithm::CopySubRange(
-          res.Positions, 0, res.Positions.GetNumberOfValues(), appendPts, posOffsets[i]);
-      }
-      vtkm::cont::CoordinateSystem outputCoords =
-        vtkm::cont::CoordinateSystem("coordinates", appendPts);
-      ds.AddCoordinateSystem(outputCoords);
-
-      //Create polylines.
-      std::vector<vtkm::Id> numPtsPerCell(static_cast<std::size_t>(totalNumCells));
-      std::size_t off = 0;
-      for (std::size_t i = 0; i < nResults; i++)
-      {
-        const auto& res = it.second[i];
-        vtkm::Id nCells = res.PolyLines.GetNumberOfCells();
-        for (vtkm::Id j = 0; j < nCells; j++)
-          numPtsPerCell[off++] = static_cast<vtkm::Id>(res.PolyLines.GetNumberOfPointsInCell(j));
-      }
-
-      auto numPointsPerCellArray = vtkm::cont::make_ArrayHandle(numPtsPerCell, vtkm::CopyFlag::Off);
-
-      vtkm::cont::ArrayHandle<vtkm::Id> cellIndex;
-      vtkm::Id connectivityLen =
-        vtkm::cont::Algorithm::ScanExclusive(numPointsPerCellArray, cellIndex);
-      vtkm::cont::ArrayHandleIndex connCount(connectivityLen);
-      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
-      vtkm::cont::ArrayCopy(connCount, connectivity);
-
-      vtkm::cont::ArrayHandle<vtkm::UInt8> cellTypes;
-      auto polyLineShape = vtkm::cont::make_ArrayHandleConstant<vtkm::UInt8>(
-        vtkm::CELL_SHAPE_POLY_LINE, totalNumCells);
-      vtkm::cont::ArrayCopy(polyLineShape, cellTypes);
-      auto offsets = vtkm::cont::ConvertNumIndicesToOffsets(numPointsPerCellArray);
-
-      vtkm::cont::CellSetExplicit<> polyLines;
-      polyLines.Fill(totalNumPts, cellTypes, connectivity, offsets);
-      ds.SetCellSet(polyLines);
-    }
-    output.AppendPartition(ds);
-  }
-  return output;
-}
-
-}
-}
-} // namespace vtkm::filter::particleadvection
-
-#endif //vtk_m_filter_particleadvection_AdvectorBaseAlgorithm_hxx
diff --git a/vtkm/filter/particleadvection/AdvectorBaseThreadedAlgorithm.h b/vtkm/filter/particleadvection/AdvectorBaseThreadedAlgorithm.h
deleted file mode 100644
index d6bb94610..000000000
--- a/vtkm/filter/particleadvection/AdvectorBaseThreadedAlgorithm.h
+++ /dev/null
@@ -1,191 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_particleadvection_AdvectorBaseThreadedAlgorithm_h
-#define vtk_m_filter_particleadvection_AdvectorBaseThreadedAlgorithm_h
-
-#include <vtkm/filter/particleadvection/AdvectorBaseAlgorithm.h>
-
-#include <thread>
-
-namespace vtkm
-{
-namespace filter
-{
-namespace particleadvection
-{
-
-#if 0
-template <typename DataSetIntegratorType, typename ResultType>
-class VTKM_ALWAYS_EXPORT AdvectorBaseThreadedAlgorithm
-  : public AdvectorBaseAlgorithm<DataSetIntegratorType, ResultType>
-{
-public:
-  AdvectorBaseThreadedAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                                const std::vector<DataSetIntegratorType>& blocks)
-    : AdvectorBaseAlgorithm<DataSetIntegratorType, ResultType>(bm, blocks)
-    , Done(false)
-    , WorkerActivate(false)
-  {
-    //For threaded algorithm, the particles go out of scope in the Work method.
-    //When this happens, they are destructed by the time the Manage thread gets them.
-    //Set the copy flag so the std::vector is copied into the ArrayHandle
-    for (auto& block : this->Blocks)
-      block.SetCopySeedFlag(true);
-  }
-
-  void Go() override
-  {
-    vtkm::Id nLocal = static_cast<vtkm::Id>(this->Active.size() + this->Inactive.size());
-    this->ComputeTotalNumParticles(nLocal);
-
-    std::vector<std::thread> workerThreads;
-    workerThreads.push_back(std::thread(AdvectorBaseThreadedAlgorithm::Worker, this));
-    this->Manage();
-    for (auto& t : workerThreads)
-      t.join();
-  }
-
-protected:
-  bool GetActiveParticles(std::vector<vtkm::Particle>& particles, vtkm::Id& blockId) override
-  {
-    std::lock_guard<std::mutex> lock(this->Mutex);
-    bool val = this->AdvectorBaseAlgorithm<DataSetIntegratorType, ResultType>::GetActiveParticles(
-      particles, blockId);
-    this->WorkerActivate = val;
-    return val;
-  }
-
-  void UpdateActive(const std::vector<vtkm::Particle>& particles,
-                    const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& idsMap) override
-  {
-    if (!particles.empty())
-    {
-      std::lock_guard<std::mutex> lock(this->Mutex);
-      this->AdvectorBaseAlgorithm<DataSetIntegratorType, ResultType>::UpdateActive(particles,
-                                                                                   idsMap);
-
-      //Let workers know there is new work
-      this->WorkerActivateCondition.notify_all();
-      this->WorkerActivate = true;
-    }
-  }
-
-  bool CheckDone()
-  {
-    std::lock_guard<std::mutex> lock(this->Mutex);
-    return this->Done;
-  }
-
-  void SetDone()
-  {
-    std::lock_guard<std::mutex> lock(this->Mutex);
-    this->Done = true;
-    this->WorkerActivateCondition.notify_all();
-  }
-
-  static void Worker(AdvectorBaseThreadedAlgorithm* algo) { algo->Work(); }
-
-  void WorkerWait()
-  {
-    std::unique_lock<std::mutex> lock(this->Mutex);
-    this->WorkerActivateCondition.wait(lock, [this] { return WorkerActivate || Done; });
-  }
-
-  void Work()
-  {
-    while (!this->CheckDone())
-    {
-      std::vector<vtkm::Particle> v;
-      vtkm::Id blockId = -1;
-      if (this->GetActiveParticles(v, blockId))
-      {
-        const auto& block = this->GetDataSet(blockId);
-        ResultType r;
-        block.Advect(v, this->StepSize, this->NumberOfSteps, r);
-        this->UpdateWorkerResult(blockId, r);
-      }
-      else
-        this->WorkerWait();
-    }
-  }
-
-  void Manage()
-  {
-    vtkm::filter::particleadvection::ParticleMessenger messenger(
-      this->Comm, this->BoundsMap, 1, 128);
-
-    while (this->TotalNumTerminatedParticles < this->TotalNumParticles)
-    {
-      std::unordered_map<vtkm::Id, std::vector<ResultType>> workerResults;
-      this->GetWorkerResults(workerResults);
-
-      vtkm::Id numTerm = 0;
-      for (auto& it : workerResults)
-      {
-        vtkm::Id blockId = it.first;
-        for (auto& r : it.second)
-          numTerm += this->UpdateResult(r, blockId);
-      }
-
-      vtkm::Id numTermMessages = 0;
-      this->Communicate(messenger, numTerm, numTermMessages);
-
-      this->TotalNumTerminatedParticles += (numTerm + numTermMessages);
-      if (this->TotalNumTerminatedParticles > this->TotalNumParticles)
-        throw vtkm::cont::ErrorFilterExecution("Particle count error");
-    }
-
-    //Let the workers know that we are done.
-    this->SetDone();
-  }
-
-  bool GetBlockAndWait(const vtkm::Id& numLocalTerm) override
-  {
-    std::lock_guard<std::mutex> lock(this->Mutex);
-
-    return (this->AdvectorBaseAlgorithm<DataSetIntegratorType, ResultType>::GetBlockAndWait(
-              numLocalTerm) &&
-            !this->WorkerActivate && this->WorkerResults.empty());
-  }
-
-  void GetWorkerResults(std::unordered_map<vtkm::Id, std::vector<ResultType>>& results)
-  {
-    results.clear();
-
-    std::lock_guard<std::mutex> lock(this->Mutex);
-    if (!this->WorkerResults.empty())
-    {
-      results = this->WorkerResults;
-      this->WorkerResults.clear();
-    }
-  }
-
-  void UpdateWorkerResult(vtkm::Id blockId, const ResultType& result)
-  {
-    std::lock_guard<std::mutex> lock(this->Mutex);
-
-    auto& it = this->WorkerResults[blockId];
-    it.push_back(result);
-  }
-
-  std::atomic<bool> Done;
-  std::mutex Mutex;
-  bool WorkerActivate;
-  std::condition_variable WorkerActivateCondition;
-  std::unordered_map<vtkm::Id, std::vector<ResultType>> WorkerResults;
-};
-#endif
-
-}
-}
-} // namespace vtkm::filter::particleadvection
-
-#endif
diff --git a/vtkm/filter/particleadvection/CMakeLists.txt b/vtkm/filter/particleadvection/CMakeLists.txt
index 529a45bbc..202e6f1a6 100644
--- a/vtkm/filter/particleadvection/CMakeLists.txt
+++ b/vtkm/filter/particleadvection/CMakeLists.txt
@@ -9,14 +9,8 @@
 ##============================================================================
 
 set(headers
-  AdvectorBaseAlgorithm.h
-  AdvectorBaseAlgorithm.hxx
-  AdvectorBaseThreadedAlgorithm.h
   BoundsMap.h
-  DataSetIntegrator.h
-  DataSetIntegrator.hxx
   Messenger.h
-  ParticleAdvectionAlgorithm.h
   ParticleMessenger.h
   DSI.h
   DSISteadyState.h
diff --git a/vtkm/filter/particleadvection/DataSetIntegrator.h b/vtkm/filter/particleadvection/DataSetIntegrator.h
deleted file mode 100644
index 0e04de28d..000000000
--- a/vtkm/filter/particleadvection/DataSetIntegrator.h
+++ /dev/null
@@ -1,142 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_DataSetIntegrator_h
-#define vtk_m_filter_DataSetIntegrator_h
-
-#include <vtkm/cont/ArrayHandleTransform.h>
-#include <vtkm/cont/DataSet.h>
-#include <vtkm/worklet/ParticleAdvection.h>
-#include <vtkm/worklet/particleadvection/EulerIntegrator.h>
-#include <vtkm/worklet/particleadvection/RK4Integrator.h>
-#include <vtkm/worklet/particleadvection/Stepper.h>
-#include <vtkm/worklet/particleadvection/TemporalGridEvaluators.h>
-
-#include <memory>
-#include <vector>
-
-namespace vtkm
-{
-namespace filter
-{
-namespace particleadvection
-{
-
-template <typename GridEvalType>
-class VTKM_ALWAYS_EXPORT DataSetIntegratorBase
-{
-public:
-  DataSetIntegratorBase(bool copySeeds = false, vtkm::Id id = -1)
-    : CopySeedArray(copySeeds)
-    , Eval(nullptr)
-    , ID(id)
-  {
-  }
-
-  ~DataSetIntegratorBase() = default;
-
-  vtkm::Id GetID() const { return this->ID; }
-  void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
-
-  template <typename ResultType>
-  void Advect(std::vector<vtkm::Particle>& v,
-              vtkm::FloatDefault stepSize,
-              vtkm::Id maxSteps,
-              ResultType& result) const
-  {
-    auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
-    auto seedArray = vtkm::cont::make_ArrayHandle(v, copyFlag);
-    Stepper rk4(*this->Eval, stepSize);
-    this->DoAdvect(seedArray, rk4, maxSteps, result);
-  }
-
-protected:
-  using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-  using Stepper = vtkm::worklet::particleadvection::Stepper<RK4Type, GridEvalType>;
-  using FieldHandleType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-
-  template <typename ResultType>
-  inline void DoAdvect(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
-                       const Stepper& rk4,
-                       vtkm::Id maxSteps,
-                       ResultType& result) const;
-
-  FieldHandleType GetFieldHandle(const vtkm::cont::DataSet& ds, const std::string& fieldNm)
-  {
-    if (!ds.HasField(fieldNm))
-      throw vtkm::cont::ErrorFilterExecution("Field " + fieldNm + " not found on dataset.");
-
-    FieldHandleType fieldArray;
-    auto fieldData = ds.GetField(fieldNm).GetData();
-    vtkm::cont::ArrayCopyShallowIfPossible(fieldData, fieldArray);
-
-    return fieldArray;
-  }
-
-  bool CopySeedArray;
-  std::shared_ptr<GridEvalType> Eval;
-  vtkm::Id ID;
-};
-
-class VTKM_ALWAYS_EXPORT DataSetIntegrator
-  : public DataSetIntegratorBase<vtkm::worklet::particleadvection::GridEvaluator<
-      vtkm::worklet::particleadvection::VelocityField<vtkm::cont::ArrayHandle<vtkm::Vec3f>>>>
-{
-public:
-  DataSetIntegrator(const vtkm::cont::DataSet& ds, vtkm::Id id, const std::string& fieldNm)
-    : DataSetIntegratorBase<vtkm::worklet::particleadvection::GridEvaluator<
-        vtkm::worklet::particleadvection::VelocityField<FieldHandleType>>>(false, id)
-  {
-    using Association = vtkm::cont::Field::Association;
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandleType>;
-    using EvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-    Association association = ds.GetField(fieldNm).GetAssociation();
-    auto fieldArray = this->GetFieldHandle(ds, fieldNm);
-    FieldType field(fieldArray, association);
-    this->Eval = std::shared_ptr<EvalType>(new EvalType(ds, field));
-  }
-};
-
-class VTKM_ALWAYS_EXPORT TemporalDataSetIntegrator
-  : public DataSetIntegratorBase<vtkm::worklet::particleadvection::TemporalGridEvaluator<
-      vtkm::worklet::particleadvection::VelocityField<vtkm::cont::ArrayHandle<vtkm::Vec3f>>>>
-{
-  using FieldHandleType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-
-public:
-  TemporalDataSetIntegrator(const vtkm::cont::DataSet& ds1,
-                            vtkm::FloatDefault t1,
-                            const vtkm::cont::DataSet& ds2,
-                            vtkm::FloatDefault t2,
-                            vtkm::Id id,
-                            const std::string& fieldNm)
-    : DataSetIntegratorBase<vtkm::worklet::particleadvection::TemporalGridEvaluator<
-        vtkm::worklet::particleadvection::VelocityField<FieldHandleType>>>(false, id)
-  {
-    auto fieldArray1 = this->GetFieldHandle(ds1, fieldNm);
-    auto fieldArray2 = this->GetFieldHandle(ds2, fieldNm);
-
-    using EvalType = vtkm::worklet::particleadvection::TemporalGridEvaluator<
-      vtkm::worklet::particleadvection::VelocityField<FieldHandleType>>;
-
-    this->Eval =
-      std::shared_ptr<EvalType>(new EvalType(ds1, t1, fieldArray1, ds2, t2, fieldArray2));
-  }
-};
-
-}
-}
-} // namespace vtkm::filter::particleadvection
-
-#ifndef vtk_m_filter_particleadvection_DataSetIntegrator_hxx
-#include <vtkm/filter/particleadvection/DataSetIntegrator.hxx>
-#endif
-
-#endif //vtk_m_filter_DataSetIntegrator_h
diff --git a/vtkm/filter/particleadvection/DataSetIntegrator.hxx b/vtkm/filter/particleadvection/DataSetIntegrator.hxx
deleted file mode 100644
index da3893277..000000000
--- a/vtkm/filter/particleadvection/DataSetIntegrator.hxx
+++ /dev/null
@@ -1,91 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_DataSetIntegrator_hxx
-#define vtk_m_filter_DataSetIntegrator_hxx
-
-namespace vtkm
-{
-namespace filter
-{
-namespace particleadvection
-{
-
-using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<
-  vtkm::worklet::particleadvection::VelocityField<vtkm::cont::ArrayHandle<vtkm::Vec3f>>>;
-using TemporalGridEvalType = vtkm::worklet::particleadvection::TemporalGridEvaluator<
-  vtkm::worklet::particleadvection::VelocityField<vtkm::cont::ArrayHandle<vtkm::Vec3f>>>;
-using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-using Stepper = vtkm::worklet::particleadvection::Stepper<RK4Type, GridEvalType>;
-using TemporalRK4Type = vtkm::worklet::particleadvection::RK4Integrator<TemporalGridEvalType>;
-using TemporalStepper =
-  vtkm::worklet::particleadvection::Stepper<TemporalRK4Type, TemporalGridEvalType>;
-
-//-----
-// Specialization for ParticleAdvection worklet
-template <>
-template <>
-inline void DataSetIntegratorBase<GridEvalType>::DoAdvect(
-  vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
-  const Stepper& stepper,
-  vtkm::Id maxSteps,
-  vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>& result) const
-{
-  vtkm::worklet::ParticleAdvection Worklet;
-  result = Worklet.Run(stepper, seeds, maxSteps);
-}
-
-//-----
-// Specialization for Streamline worklet
-template <>
-template <>
-inline void DataSetIntegratorBase<GridEvalType>::DoAdvect(
-  vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
-  const Stepper& stepper,
-  vtkm::Id maxSteps,
-  vtkm::worklet::StreamlineResult<vtkm::Particle>& result) const
-{
-  vtkm::worklet::Streamline Worklet;
-  result = Worklet.Run(stepper, seeds, maxSteps);
-}
-
-//-----
-// Specialization for PathParticle worklet
-template <>
-template <>
-inline void DataSetIntegratorBase<TemporalGridEvalType>::DoAdvect(
-  vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
-  const TemporalStepper& stepper,
-  vtkm::Id maxSteps,
-  vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>& result) const
-{
-  vtkm::worklet::ParticleAdvection Worklet;
-  result = Worklet.Run(stepper, seeds, maxSteps);
-}
-
-//-----
-// Specialization for Pathline worklet
-template <>
-template <>
-inline void DataSetIntegratorBase<TemporalGridEvalType>::DoAdvect(
-  vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
-  const TemporalStepper& stepper,
-  vtkm::Id maxSteps,
-  vtkm::worklet::StreamlineResult<vtkm::Particle>& result) const
-{
-  vtkm::worklet::Streamline Worklet;
-  result = Worklet.Run(stepper, seeds, maxSteps);
-}
-
-}
-}
-} // namespace vtkm::filter::particleadvection
-
-#endif
diff --git a/vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h b/vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h
index 7dc3d244c..c5c0c230e 100644
--- a/vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h
+++ b/vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h
@@ -11,10 +11,6 @@
 #ifndef vtk_m_filter_particleadvection_ParticleAdvectionAlgorithm_h
 #define vtk_m_filter_particleadvection_ParticleAdvectionAlgorithm_h
 
-#include <vtkm/filter/particleadvection/AdvectorBaseAlgorithm.h>
-#include <vtkm/filter/particleadvection/AdvectorBaseThreadedAlgorithm.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-
 namespace vtkm
 {
 namespace filter

From d6e23e7dffe644f4d689e6390f31169f474dfe91 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 19 Jul 2022 14:15:21 -0400
Subject: [PATCH 033/104] Rename classes.

---
 vtkm/filter/NewFilterParticleAdvection.h      |  6 +--
 .../NewFilterParticleAdvectionSteadyState.h   |  8 ++--
 .../NewFilterParticleAdvectionUnsteadyState.h |  4 +-
 vtkm/filter/ParticleAdvection.hxx             |  8 ++--
 vtkm/filter/PathParticle.hxx                  |  8 ++--
 vtkm/filter/Pathline.hxx                      |  8 ++--
 vtkm/filter/Streamline.hxx                    |  8 ++--
 .../{ABA.h => AdvectAlgorithm.h}              | 17 ++++----
 ...BAThreaded.h => AdvectAlgorithmThreaded.h} | 33 ++++++++--------
 vtkm/filter/particleadvection/CMakeLists.txt  | 18 ++++-----
 .../{DSI.h => DataSetIntegrator.h}            | 22 +++++------
 .../{DSI.hxx => DataSetIntegrator.hxx}        | 17 ++++----
 ...State.h => DataSetIntegratorSteadyState.h} | 33 +++++++++-------
 ...e.hxx => DataSetIntegratorSteadyState.hxx} | 19 ++++-----
 ...ate.h => DataSetIntegratorUnsteadyState.h} | 39 +++++++++++--------
 ...hxx => DataSetIntegratorUnsteadyState.hxx} | 14 +++----
 .../{PAV.h => ParticleAdvector.h}             | 32 +++++++--------
 17 files changed, 153 insertions(+), 141 deletions(-)
 rename vtkm/filter/particleadvection/{ABA.h => AdvectAlgorithm.h} (95%)
 rename vtkm/filter/particleadvection/{ABAThreaded.h => AdvectAlgorithmThreaded.h} (81%)
 rename vtkm/filter/particleadvection/{DSI.h => DataSetIntegrator.h} (88%)
 rename vtkm/filter/particleadvection/{DSI.hxx => DataSetIntegrator.hxx} (92%)
 rename vtkm/filter/particleadvection/{DSISteadyState.h => DataSetIntegratorSteadyState.h} (60%)
 rename vtkm/filter/particleadvection/{DSISteadyState.hxx => DataSetIntegratorSteadyState.hxx} (88%)
 rename vtkm/filter/particleadvection/{DSIUnsteadyState.h => DataSetIntegratorUnsteadyState.h} (64%)
 rename vtkm/filter/particleadvection/{DSIUnsteadyState.hxx => DataSetIntegratorUnsteadyState.hxx} (92%)
 rename vtkm/filter/particleadvection/{PAV.h => ParticleAdvector.h} (76%)

diff --git a/vtkm/filter/NewFilterParticleAdvection.h b/vtkm/filter/NewFilterParticleAdvection.h
index 5e5d9ae9a..b8cec2bde 100644
--- a/vtkm/filter/NewFilterParticleAdvection.h
+++ b/vtkm/filter/NewFilterParticleAdvection.h
@@ -14,9 +14,9 @@
 #include <vtkm/Particle.h>
 #include <vtkm/filter/NewFilterField.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DSI.h>
-#include <vtkm/filter/particleadvection/DSISteadyState.h>
-#include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
+#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
+#include <vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h>
+#include <vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 
 namespace vtkm
diff --git a/vtkm/filter/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
index 31d7b66ac..62a7663bb 100644
--- a/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
@@ -33,11 +33,11 @@ protected:
     this->NewFilterParticleAdvection::ValidateOptions();
   }
 
-  VTKM_CONT std::vector<vtkm::filter::particleadvection::DSISteadyState*> CreateDataSetIntegrators(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
+  VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegratorSteadyState*>
+  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
+                           const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
   {
-    using DSIType = vtkm::filter::particleadvection::DSISteadyState;
+    using DSIType = vtkm::filter::particleadvection::DataSetIntegratorSteadyState;
 
     std::string activeField = this->GetActiveFieldName();
 
diff --git a/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h
index 21bb4bf61..93d426a16 100644
--- a/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h
@@ -41,11 +41,11 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("PreviousTime must be less than NextTime");
   }
 
-  VTKM_CONT std::vector<vtkm::filter::particleadvection::DSIUnsteadyState*>
+  VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState*>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
                            const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
   {
-    using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
+    using DSIType = vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState;
 
     std::string activeField = this->GetActiveFieldName();
 
diff --git a/vtkm/filter/ParticleAdvection.hxx b/vtkm/filter/ParticleAdvection.hxx
index 0e8a3222e..c640696ff 100644
--- a/vtkm/filter/ParticleAdvection.hxx
+++ b/vtkm/filter/ParticleAdvection.hxx
@@ -14,9 +14,9 @@
 #include <vtkm/filter/ParticleAdvection.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
 
-#include <vtkm/filter/particleadvection/DSISteadyState.h>
-#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/filter/particleadvection/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -26,13 +26,13 @@ namespace filter
 VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  using DSIType = vtkm::filter::particleadvection::DSISteadyState;
+  using DSIType = vtkm::filter::particleadvection::DataSetIntegratorSteadyState;
   this->ValidateOptions();
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  vtkm::filter::particleadvection::PAV<DSIType> pav(
+  vtkm::filter::particleadvection::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
 
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
diff --git a/vtkm/filter/PathParticle.hxx b/vtkm/filter/PathParticle.hxx
index 1844818ac..c7d17ea14 100644
--- a/vtkm/filter/PathParticle.hxx
+++ b/vtkm/filter/PathParticle.hxx
@@ -14,9 +14,9 @@
 #include <vtkm/filter/PathParticle.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
 
-#include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
-#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/filter/particleadvection/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -26,13 +26,13 @@ namespace filter
 VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
+  using DSIType = vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState;
   this->ValidateOptions();
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  vtkm::filter::particleadvection::PAV<DSIType> pav(
+  vtkm::filter::particleadvection::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
 
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
diff --git a/vtkm/filter/Pathline.hxx b/vtkm/filter/Pathline.hxx
index 5f4ee0e73..d845a26ef 100644
--- a/vtkm/filter/Pathline.hxx
+++ b/vtkm/filter/Pathline.hxx
@@ -15,9 +15,9 @@
 #include <vtkm/filter/particleadvection/BoundsMap.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
 
-#include <vtkm/filter/particleadvection/DSIUnsteadyState.h>
-#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/filter/particleadvection/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -27,13 +27,13 @@ namespace filter
 VTKM_CONT vtkm::cont::PartitionedDataSet Pathline::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  using DSIType = vtkm::filter::particleadvection::DSIUnsteadyState;
+  using DSIType = vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState;
   this->ValidateOptions();
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  vtkm::filter::particleadvection::PAV<DSIType> pav(
+  vtkm::filter::particleadvection::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
 
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
diff --git a/vtkm/filter/Streamline.hxx b/vtkm/filter/Streamline.hxx
index 7c8286188..e115d4a16 100644
--- a/vtkm/filter/Streamline.hxx
+++ b/vtkm/filter/Streamline.hxx
@@ -14,9 +14,9 @@
 #include <vtkm/filter/Streamline.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
 
-#include <vtkm/filter/particleadvection/DSISteadyState.h>
-#include <vtkm/filter/particleadvection/PAV.h>
+#include <vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/filter/particleadvection/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -26,13 +26,13 @@ namespace filter
 VTKM_CONT inline vtkm::cont::PartitionedDataSet Streamline::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  using DSIType = vtkm::filter::particleadvection::DSISteadyState;
+  using DSIType = vtkm::filter::particleadvection::DataSetIntegratorSteadyState;
   this->ValidateOptions();
 
   vtkm::filter::particleadvection::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  vtkm::filter::particleadvection::PAV<DSIType> pav(
+  vtkm::filter::particleadvection::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
 
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
diff --git a/vtkm/filter/particleadvection/ABA.h b/vtkm/filter/particleadvection/AdvectAlgorithm.h
similarity index 95%
rename from vtkm/filter/particleadvection/ABA.h
rename to vtkm/filter/particleadvection/AdvectAlgorithm.h
index c9970122b..ba544045e 100644
--- a/vtkm/filter/particleadvection/ABA.h
+++ b/vtkm/filter/particleadvection/AdvectAlgorithm.h
@@ -8,12 +8,12 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_ABA_h
-#define vtk_m_filter_ABA_h
+#ifndef vtk_m_filter_AdvectAlgorithm_h
+#define vtk_m_filter_AdvectAlgorithm_h
 
 #include <vtkm/cont/PartitionedDataSet.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 #include <vtkm/filter/particleadvection/ParticleMessenger.h>
 
 
@@ -25,10 +25,11 @@ namespace particleadvection
 {
 
 template <typename DSIType, template <typename> class ResultType, typename ParticleType>
-class ABA
+class AdvectAlgorithm
 {
 public:
-  ABA(const vtkm::filter::particleadvection::BoundsMap& bm, std::vector<DSIType*>& blocks)
+  AdvectAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
+                  std::vector<DSIType*>& blocks)
     : Blocks(blocks)
     , BoundsMap(bm)
     , NumRanks(this->Comm.size())
@@ -137,7 +138,7 @@ public:
     this->TotalNumParticles = static_cast<vtkm::Id>(total);
   }
 
-  DSI* GetDataSet(vtkm::Id id)
+  DataSetIntegrator* GetDataSet(vtkm::Id id)
   {
     for (auto& it : this->Blocks)
       if (it->GetID() == id)
@@ -281,6 +282,4 @@ public:
 }
 }
 
-//#include <vtkm/filter/particleadvection/ABA.hxx>
-
-#endif //vtk_m_filter_ABA_h
+#endif //vtk_m_filter_AdvectAlgorithm_h
diff --git a/vtkm/filter/particleadvection/ABAThreaded.h b/vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h
similarity index 81%
rename from vtkm/filter/particleadvection/ABAThreaded.h
rename to vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h
index 46126b8b5..998e6466f 100644
--- a/vtkm/filter/particleadvection/ABAThreaded.h
+++ b/vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h
@@ -8,13 +8,13 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_ABAThreaded_h
-#define vtk_m_filter_ABAThreaded_h
+#ifndef vtk_m_filter_AdvectAlgorithmThreaded_h
+#define vtk_m_filter_AdvectAlgorithmThreaded_h
 
 #include <vtkm/cont/PartitionedDataSet.h>
-#include <vtkm/filter/particleadvection/ABA.h>
+#include <vtkm/filter/particleadvection/AdvectAlgorithm.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 #include <vtkm/filter/particleadvection/ParticleMessenger.h>
 
 #include <thread>
@@ -27,11 +27,12 @@ namespace particleadvection
 {
 
 template <typename DSIType, template <typename> class ResultType, typename ParticleType>
-class ABAThreaded : public ABA<DSIType, ResultType, ParticleType>
+class AdvectAlgorithmThreaded : public AdvectAlgorithm<DSIType, ResultType, ParticleType>
 {
 public:
-  ABAThreaded(const vtkm::filter::particleadvection::BoundsMap& bm, std::vector<DSIType*>& blocks)
-    : ABA<DSIType, ResultType, ParticleType>(bm, blocks)
+  AdvectAlgorithmThreaded(const vtkm::filter::particleadvection::BoundsMap& bm,
+                          std::vector<DSIType*>& blocks)
+    : AdvectAlgorithm<DSIType, ResultType, ParticleType>(bm, blocks)
     , Done(false)
     , WorkerActivate(false)
   {
@@ -48,7 +49,7 @@ public:
     this->ComputeTotalNumParticles(nLocal);
 
     std::vector<std::thread> workerThreads;
-    workerThreads.push_back(std::thread(ABAThreaded::Worker, this));
+    workerThreads.push_back(std::thread(AdvectAlgorithmThreaded::Worker, this));
     this->Manage();
 
     //This will only work for 1 thread. For > 1, the Blocks will need a mutex.
@@ -61,7 +62,8 @@ protected:
   bool GetActiveParticles(std::vector<ParticleType>& particles, vtkm::Id& blockId) override
   {
     std::lock_guard<std::mutex> lock(this->Mutex);
-    bool val = this->ABA<DSIType, ResultType, ParticleType>::GetActiveParticles(particles, blockId);
+    bool val = this->AdvectAlgorithm<DSIType, ResultType, ParticleType>::GetActiveParticles(
+      particles, blockId);
     this->WorkerActivate = val;
     return val;
   }
@@ -72,7 +74,7 @@ protected:
     if (!particles.empty())
     {
       std::lock_guard<std::mutex> lock(this->Mutex);
-      this->ABA<DSIType, ResultType, ParticleType>::UpdateActive(particles, idsMap);
+      this->AdvectAlgorithm<DSIType, ResultType, ParticleType>::UpdateActive(particles, idsMap);
 
       //Let workers know there is new work
       this->WorkerActivateCondition.notify_all();
@@ -93,7 +95,7 @@ protected:
     this->WorkerActivateCondition.notify_all();
   }
 
-  static void Worker(ABAThreaded* algo) { algo->Work(); }
+  static void Worker(AdvectAlgorithmThreaded* algo) { algo->Work(); }
 
   void WorkerWait()
   {
@@ -160,8 +162,9 @@ protected:
   {
     std::lock_guard<std::mutex> lock(this->Mutex);
 
-    return (this->ABA<DSIType, ResultType, ParticleType>::GetBlockAndWait(numLocalTerm) &&
-            !this->WorkerActivate && this->WorkerResults.empty());
+    return (
+      this->AdvectAlgorithm<DSIType, ResultType, ParticleType>::GetBlockAndWait(numLocalTerm) &&
+      !this->WorkerActivate && this->WorkerResults.empty());
   }
 
   void GetWorkerResults(std::unordered_map<vtkm::Id, std::vector<DSIHelperInfoType>>& results)
@@ -187,6 +190,4 @@ protected:
 }
 }
 
-//#include <vtkm/filter/particleadvection/ABA.hxx>
-
-#endif //vtk_m_filter_ABAThreaded_h
+#endif //vtk_m_filter_AdvectAlgorithmThreaded_h
diff --git a/vtkm/filter/particleadvection/CMakeLists.txt b/vtkm/filter/particleadvection/CMakeLists.txt
index 202e6f1a6..5a1b112c4 100644
--- a/vtkm/filter/particleadvection/CMakeLists.txt
+++ b/vtkm/filter/particleadvection/CMakeLists.txt
@@ -12,15 +12,15 @@ set(headers
   BoundsMap.h
   Messenger.h
   ParticleMessenger.h
-  DSI.h
-  DSISteadyState.h
-  DSIUnsteadyState.h
-  DSI.hxx
-  DSISteadyState.hxx
-  DSIUnsteadyState.hxx
-  ABA.h
-  ABAThreaded.h
-  PAV.h
+  DataSetIntegrator.h
+  DataSetIntegratorSteadyState.h
+  DataSetIntegratorUnsteadyState.h
+  DataSetIntegrator.hxx
+  DataSetIntegratorSteadyState.hxx
+  DataSetIntegratorUnsteadyState.hxx
+  AdvectAlgorithm.h
+  AdvectAlgorithmThreaded.h
+  ParticleAdvector.h
   ParticleAdvectionTypes.h
 )
 
diff --git a/vtkm/filter/particleadvection/DSI.h b/vtkm/filter/particleadvection/DataSetIntegrator.h
similarity index 88%
rename from vtkm/filter/particleadvection/DSI.h
rename to vtkm/filter/particleadvection/DataSetIntegrator.h
index 12b0edf9b..8b40faca7 100644
--- a/vtkm/filter/particleadvection/DSI.h
+++ b/vtkm/filter/particleadvection/DataSetIntegrator.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_DSI_h
-#define vtk_m_filter_particleadvection_DSI_h
+#ifndef vtk_m_filter_particleadvection_DataSetIntegrator_h
+#define vtk_m_filter_particleadvection_DataSetIntegrator_h
 
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
@@ -53,7 +53,7 @@ public:
 using DSIHelperInfoType = vtkm::cont::internal::Variant<DSIHelperInfo<vtkm::Particle>,
                                                         DSIHelperInfo<vtkm::ChargedParticle>>;
 
-class DSI
+class DataSetIntegrator
 {
 protected:
   using VelocityFieldNameType = std::string;
@@ -68,11 +68,11 @@ protected:
                                   vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
 
 public:
-  DSI(vtkm::Id id,
-      const FieldNameType& fieldName,
-      vtkm::filter::particleadvection::IntegrationSolverType solverType,
-      vtkm::filter::particleadvection::VectorFieldType vecFieldType,
-      vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
+  DataSetIntegrator(vtkm::Id id,
+                    const FieldNameType& fieldName,
+                    vtkm::filter::particleadvection::IntegrationSolverType solverType,
+                    vtkm::filter::particleadvection::VectorFieldType vecFieldType,
+                    vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
     : FieldName(fieldName)
     , Id(id)
     , SolverType(solverType)
@@ -157,8 +157,8 @@ protected:
 }
 }
 
-#ifndef vtk_m_filter_particleadvection_DSI_hxx
-#include <vtkm/filter/particleadvection/DSI.hxx>
+#ifndef vtk_m_filter_particleadvection_DataSetIntegrator_hxx
+#include <vtkm/filter/particleadvection/DataSetIntegrator.hxx>
 #endif
 
-#endif //vtk_m_filter_particleadvection_DSI_h
+#endif //vtk_m_filter_particleadvection_DataSetIntegrator_h
diff --git a/vtkm/filter/particleadvection/DSI.hxx b/vtkm/filter/particleadvection/DataSetIntegrator.hxx
similarity index 92%
rename from vtkm/filter/particleadvection/DSI.hxx
rename to vtkm/filter/particleadvection/DataSetIntegrator.hxx
index 25f034512..4f6d277b5 100644
--- a/vtkm/filter/particleadvection/DSI.hxx
+++ b/vtkm/filter/particleadvection/DataSetIntegrator.hxx
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_DSI_hxx
-#define vtk_m_filter_particleadvection_DSI_hxx
+#ifndef vtk_m_filter_particleadvection_DataSetIntegrator_hxx
+#define vtk_m_filter_particleadvection_DataSetIntegrator_hxx
 
 #include <vtkm/cont/ParticleArrayCopy.h>
 
@@ -21,8 +21,9 @@ namespace particleadvection
 {
 
 template <typename ParticleType>
-VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
-                                      DSIHelperInfo<ParticleType>& dsiInfo) const
+VTKM_CONT void DataSetIntegrator::ClassifyParticles(
+  const vtkm::cont::ArrayHandle<ParticleType>& particles,
+  DSIHelperInfo<ParticleType>& dsiInfo) const
 {
   dsiInfo.A.clear();
   dsiInfo.I.clear();
@@ -106,8 +107,8 @@ VTKM_CONT void DSI::ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType
 }
 
 template <typename ParticleType, template <typename> class ResultType>
-VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
-                                 DSIHelperInfo<ParticleType>& dsiInfo)
+VTKM_CONT void DataSetIntegrator::UpdateResult(const ResultType<ParticleType>& result,
+                                               DSIHelperInfo<ParticleType>& dsiInfo)
 {
   this->ClassifyParticles(result.Particles, dsiInfo);
 
@@ -131,7 +132,7 @@ VTKM_CONT void DSI::UpdateResult(const ResultType<ParticleType>& result,
 }
 
 template <typename ParticleType>
-VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
+VTKM_CONT bool DataSetIntegrator::GetOutput(vtkm::cont::DataSet& ds) const
 {
   std::size_t nResults = this->Results.size();
   if (nResults == 0)
@@ -247,4 +248,4 @@ VTKM_CONT bool DSI::GetOutput(vtkm::cont::DataSet& ds) const
 }
 }
 
-#endif //vtk_m_filter_particleadvection_DSI_hxx
+#endif //vtk_m_filter_particleadvection_DataSetIntegrator_hxx
diff --git a/vtkm/filter/particleadvection/DSISteadyState.h b/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h
similarity index 60%
rename from vtkm/filter/particleadvection/DSISteadyState.h
rename to vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h
index 340198004..ad52314c7 100644
--- a/vtkm/filter/particleadvection/DSISteadyState.h
+++ b/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h
@@ -8,10 +8,10 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_DSISteadyState_h
-#define vtk_m_filter_particleadvection_DSISteadyState_h
+#ifndef vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_h
+#define vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_h
 
-#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 
 namespace vtkm
 {
@@ -20,16 +20,21 @@ namespace filter
 namespace particleadvection
 {
 
-class DSISteadyState : public vtkm::filter::particleadvection::DSI
+class DataSetIntegratorSteadyState : public vtkm::filter::particleadvection::DataSetIntegrator
 {
 public:
-  DSISteadyState(const vtkm::cont::DataSet& ds,
-                 vtkm::Id id,
-                 const FieldNameType& fieldName,
-                 vtkm::filter::particleadvection::IntegrationSolverType solverType,
-                 vtkm::filter::particleadvection::VectorFieldType vecFieldType,
-                 vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
-    : vtkm::filter::particleadvection::DSI(id, fieldName, solverType, vecFieldType, resultType)
+  DataSetIntegratorSteadyState(
+    const vtkm::cont::DataSet& ds,
+    vtkm::Id id,
+    const FieldNameType& fieldName,
+    vtkm::filter::particleadvection::IntegrationSolverType solverType,
+    vtkm::filter::particleadvection::VectorFieldType vecFieldType,
+    vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
+    : vtkm::filter::particleadvection::DataSetIntegrator(id,
+                                                         fieldName,
+                                                         solverType,
+                                                         vecFieldType,
+                                                         resultType)
     , DataSet(ds)
   {
   }
@@ -68,8 +73,8 @@ private:
 }
 }
 
-#ifndef vtk_m_filter_particleadvection_DSISteadyState_hxx
-#include <vtkm/filter/particleadvection/DSISteadyState.hxx>
+#ifndef vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_hxx
+#include <vtkm/filter/particleadvection/DataSetIntegratorSteadyState.hxx>
 #endif
 
-#endif //vtk_m_filter_particleadvection_DSISteadyState_h
+#endif //vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_h
diff --git a/vtkm/filter/particleadvection/DSISteadyState.hxx b/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.hxx
similarity index 88%
rename from vtkm/filter/particleadvection/DSISteadyState.hxx
rename to vtkm/filter/particleadvection/DataSetIntegratorSteadyState.hxx
index 01869aa64..5b91d2328 100644
--- a/vtkm/filter/particleadvection/DSISteadyState.hxx
+++ b/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.hxx
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_DSISteadyState_hxx
-#define vtk_m_filter_particleadvection_DSISteadyState_hxx
+#ifndef vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_hxx
+#define vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_hxx
 
 namespace vtkm
 {
@@ -107,9 +107,9 @@ public:
 };
 }
 
-VTKM_CONT inline void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                               vtkm::FloatDefault stepSize,
-                                               vtkm::Id maxSteps)
+VTKM_CONT inline void DataSetIntegratorSteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                                             vtkm::FloatDefault stepSize,
+                                                             vtkm::Id maxSteps)
 {
   using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
 
@@ -145,9 +145,10 @@ VTKM_CONT inline void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
     throw vtkm::cont::ErrorFilterExecution("Unsupported vector field type");
 }
 
-VTKM_CONT inline void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
-                                               vtkm::FloatDefault vtkmNotUsed(stepSize),
-                                               vtkm::Id vtkmNotUsed(maxSteps))
+VTKM_CONT inline void DataSetIntegratorSteadyState::DoAdvect(
+  DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
+  vtkm::FloatDefault vtkmNotUsed(stepSize),
+  vtkm::Id vtkmNotUsed(maxSteps))
 {
 }
 
@@ -155,4 +156,4 @@ VTKM_CONT inline void DSISteadyState::DoAdvect(DSIHelperInfo<vtkm::ChargedPartic
 }
 }
 
-#endif //vtk_m_filter_particleadvection_DSISteadyState_hxx
+#endif //vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_hxx
diff --git a/vtkm/filter/particleadvection/DSIUnsteadyState.h b/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h
similarity index 64%
rename from vtkm/filter/particleadvection/DSIUnsteadyState.h
rename to vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h
index 75fd57a67..3bc00c195 100644
--- a/vtkm/filter/particleadvection/DSIUnsteadyState.h
+++ b/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h
@@ -8,10 +8,10 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_DSIUnsteadyState_h
-#define vtk_m_filter_particleadvection_DSIUnsteadyState_h
+#ifndef vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_h
+#define vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_h
 
-#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 
 namespace vtkm
 {
@@ -20,19 +20,24 @@ namespace filter
 namespace particleadvection
 {
 
-class DSIUnsteadyState : public vtkm::filter::particleadvection::DSI
+class DataSetIntegratorUnsteadyState : public vtkm::filter::particleadvection::DataSetIntegrator
 {
 public:
-  DSIUnsteadyState(const vtkm::cont::DataSet& ds1,
-                   const vtkm::cont::DataSet& ds2,
-                   vtkm::FloatDefault t1,
-                   vtkm::FloatDefault t2,
-                   vtkm::Id id,
-                   const vtkm::filter::particleadvection::DSI::FieldNameType& fieldName,
-                   vtkm::filter::particleadvection::IntegrationSolverType solverType,
-                   vtkm::filter::particleadvection::VectorFieldType vecFieldType,
-                   vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
-    : vtkm::filter::particleadvection::DSI(id, fieldName, solverType, vecFieldType, resultType)
+  DataSetIntegratorUnsteadyState(
+    const vtkm::cont::DataSet& ds1,
+    const vtkm::cont::DataSet& ds2,
+    vtkm::FloatDefault t1,
+    vtkm::FloatDefault t2,
+    vtkm::Id id,
+    const vtkm::filter::particleadvection::DataSetIntegrator::FieldNameType& fieldName,
+    vtkm::filter::particleadvection::IntegrationSolverType solverType,
+    vtkm::filter::particleadvection::VectorFieldType vecFieldType,
+    vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
+    : vtkm::filter::particleadvection::DataSetIntegrator(id,
+                                                         fieldName,
+                                                         solverType,
+                                                         vecFieldType,
+                                                         resultType)
     , DataSet1(ds1)
     , DataSet2(ds2)
     , Time1(t1)
@@ -84,8 +89,8 @@ private:
 }
 }
 
-#ifndef vtk_m_filter_particleadvection_DSIUnsteadyState_hxx
-#include <vtkm/filter/particleadvection/DSIUnsteadyState.hxx>
+#ifndef vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_hxx
+#include <vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.hxx>
 #endif
 
-#endif //vtk_m_filter_particleadvection_DSIUnsteadyState_h
+#endif //vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_h
diff --git a/vtkm/filter/particleadvection/DSIUnsteadyState.hxx b/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.hxx
similarity index 92%
rename from vtkm/filter/particleadvection/DSIUnsteadyState.hxx
rename to vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.hxx
index 80a71b0a0..60fb254f2 100644
--- a/vtkm/filter/particleadvection/DSIUnsteadyState.hxx
+++ b/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.hxx
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_DSIUnsteadyState_hxx
-#define vtk_m_filter_particleadvection_DSIUnsteadyState_hxx
+#ifndef vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_hxx
+#define vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_hxx
 
 #include <vtkm/worklet/particleadvection/TemporalGridEvaluators.h>
 
@@ -123,9 +123,9 @@ public:
 
 }
 
-VTKM_CONT inline void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                                 vtkm::FloatDefault stepSize,
-                                                 vtkm::Id maxSteps)
+VTKM_CONT inline void DataSetIntegratorUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                                               vtkm::FloatDefault stepSize,
+                                                               vtkm::Id maxSteps)
 {
   using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
 
@@ -179,7 +179,7 @@ VTKM_CONT inline void DSIUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>&
     throw vtkm::cont::ErrorFilterExecution("Unsupported vector field type");
 }
 
-VTKM_CONT inline void DSIUnsteadyState::DoAdvect(
+VTKM_CONT inline void DataSetIntegratorUnsteadyState::DoAdvect(
   DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
   vtkm::FloatDefault vtkmNotUsed(stepSize),
   vtkm::Id vtkmNotUsed(maxSteps))
@@ -190,4 +190,4 @@ VTKM_CONT inline void DSIUnsteadyState::DoAdvect(
 }
 }
 
-#endif //vtk_m_filter_particleadvection_DSIUnsteadyState_hxx
+#endif //vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_hxx
diff --git a/vtkm/filter/particleadvection/PAV.h b/vtkm/filter/particleadvection/ParticleAdvector.h
similarity index 76%
rename from vtkm/filter/particleadvection/PAV.h
rename to vtkm/filter/particleadvection/ParticleAdvector.h
index 71068ef43..979451ad5 100644
--- a/vtkm/filter/particleadvection/PAV.h
+++ b/vtkm/filter/particleadvection/ParticleAdvector.h
@@ -8,13 +8,13 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_PAV_h
-#define vtk_m_filter_particleadvection_PAV_h
+#ifndef vtk_m_filter_particleadvection_ParticleAdvector_h
+#define vtk_m_filter_particleadvection_ParticleAdvector_h
 
-#include <vtkm/filter/particleadvection/ABA.h>
-#include <vtkm/filter/particleadvection/ABAThreaded.h>
+#include <vtkm/filter/particleadvection/AdvectAlgorithm.h>
+#include <vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h>
 #include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DSI.h>
+#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
 
 namespace vtkm
 {
@@ -24,13 +24,13 @@ namespace particleadvection
 {
 
 template <typename DSIType>
-class PAV
+class ParticleAdvector
 {
 public:
-  PAV(const vtkm::filter::particleadvection::BoundsMap& bm,
-      const std::vector<DSIType*> blocks,
-      const bool& useThreaded,
-      const vtkm::filter::particleadvection::ParticleAdvectionResultType& parType)
+  ParticleAdvector(const vtkm::filter::particleadvection::BoundsMap& bm,
+                   const std::vector<DSIType*> blocks,
+                   const bool& useThreaded,
+                   const vtkm::filter::particleadvection::ParticleAdvectionResultType& parType)
     : Blocks(blocks)
     , BoundsMap(bm)
     , ResultType(parType)
@@ -50,7 +50,7 @@ public:
     else if (seeds.IsBaseComponentType<vtkm::ChargedParticle>())
       return this->Execute(numSteps, stepSize, seeds.AsArrayHandle<ChargedParticleArray>());
 
-    throw vtkm::cont::ErrorFilterExecution("Unsupported options in ABA");
+    throw vtkm::cont::ErrorFilterExecution("Unsupported options in AdvectAlgorithm");
   }
 
 private:
@@ -75,14 +75,14 @@ private:
           vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
       {
         using AlgorithmType = vtkm::filter::particleadvection::
-          ABA<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
+          AdvectAlgorithm<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
       else
       {
         using AlgorithmType = vtkm::filter::particleadvection::
-          ABA<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
+          AdvectAlgorithm<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
@@ -93,14 +93,14 @@ private:
           vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
       {
         using AlgorithmType = vtkm::filter::particleadvection::
-          ABAThreaded<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
+          AdvectAlgorithmThreaded<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
       else
       {
         using AlgorithmType = vtkm::filter::particleadvection::
-          ABAThreaded<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
+          AdvectAlgorithmThreaded<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
@@ -119,4 +119,4 @@ private:
 }
 
 
-#endif //vtk_m_filter_particleadvection_PAV_h
+#endif //vtk_m_filter_particleadvection_ParticleAdvector_h

From da3b4f4d478046295e8d6eb3277807cecaf7ace3 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 20 Jul 2022 11:57:46 -0400
Subject: [PATCH 034/104] Cleanup. Get rid of hxx files.

---
 vtkm/filter/CMakeLists.txt                    |   1 -
 .../NewFilterParticleAdvectionSteadyState.h   |   5 -
 vtkm/filter/particleadvection/CMakeLists.txt  |   3 -
 .../particleadvection/DataSetIntegrator.h     | 230 +++++++++++++++-
 .../particleadvection/DataSetIntegrator.hxx   | 251 ------------------
 .../DataSetIntegratorSteadyState.h            | 153 ++++++++++-
 .../DataSetIntegratorSteadyState.hxx          | 159 -----------
 .../DataSetIntegratorUnsteadyState.h          | 176 +++++++++++-
 .../DataSetIntegratorUnsteadyState.hxx        | 193 --------------
 .../particleadvection/ParticleMessenger.cxx   | 246 -----------------
 .../particleadvection/ParticleMessenger.h     | 227 +++++++++++++++-
 11 files changed, 758 insertions(+), 886 deletions(-)
 delete mode 100644 vtkm/filter/particleadvection/DataSetIntegrator.hxx
 delete mode 100644 vtkm/filter/particleadvection/DataSetIntegratorSteadyState.hxx
 delete mode 100644 vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.hxx
 delete mode 100644 vtkm/filter/particleadvection/ParticleMessenger.cxx

diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index 07a04ff7b..b8306e071 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -128,7 +128,6 @@ set(extra_header_template_sources
 
 set(extra_sources_device
   particleadvection/Messenger.cxx
-  #particleadvection/ParticleMessenger.cxx
   )
 
 set(core_headers
diff --git a/vtkm/filter/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
index 62a7663bb..1f84d1fe8 100644
--- a/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
@@ -28,11 +28,6 @@ public:
   }
 
 protected:
-  VTKM_CONT virtual void ValidateOptions() const override
-  {
-    this->NewFilterParticleAdvection::ValidateOptions();
-  }
-
   VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegratorSteadyState*>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
                            const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
diff --git a/vtkm/filter/particleadvection/CMakeLists.txt b/vtkm/filter/particleadvection/CMakeLists.txt
index 5a1b112c4..3a67cd184 100644
--- a/vtkm/filter/particleadvection/CMakeLists.txt
+++ b/vtkm/filter/particleadvection/CMakeLists.txt
@@ -15,9 +15,6 @@ set(headers
   DataSetIntegrator.h
   DataSetIntegratorSteadyState.h
   DataSetIntegratorUnsteadyState.h
-  DataSetIntegrator.hxx
-  DataSetIntegratorSteadyState.hxx
-  DataSetIntegratorUnsteadyState.hxx
   AdvectAlgorithm.h
   AdvectAlgorithmThreaded.h
   ParticleAdvector.h
diff --git a/vtkm/filter/particleadvection/DataSetIntegrator.h b/vtkm/filter/particleadvection/DataSetIntegrator.h
index 8b40faca7..ace3eb91a 100644
--- a/vtkm/filter/particleadvection/DataSetIntegrator.h
+++ b/vtkm/filter/particleadvection/DataSetIntegrator.h
@@ -13,6 +13,8 @@
 
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
+#include <vtkm/cont/ParticleArrayCopy.h>
+#include <vtkm/filter/particleadvection/BoundsMap.h>
 #include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
 #include <vtkm/worklet/ParticleAdvection.h>
 #include <vtkm/worklet/particleadvection/EulerIntegrator.h>
@@ -114,7 +116,6 @@ protected:
   VTKM_CONT void UpdateResult(const ResultType<ParticleType>& result,
                               DSIHelperInfo<ParticleType>& dsiInfo);
 
-protected:
   VTKM_CONT bool IsParticleAdvectionResult() const
   {
     return this->AdvectionResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE;
@@ -152,13 +153,232 @@ protected:
   std::vector<RType> Results;
 };
 
+template <typename ParticleType>
+VTKM_CONT void DataSetIntegrator::ClassifyParticles(
+  const vtkm::cont::ArrayHandle<ParticleType>& particles,
+  DSIHelperInfo<ParticleType>& dsiInfo) const
+{
+  dsiInfo.A.clear();
+  dsiInfo.I.clear();
+  dsiInfo.TermID.clear();
+  dsiInfo.TermIdx.clear();
+  dsiInfo.IdMapI.clear();
+  dsiInfo.IdMapA.clear();
+
+  auto portal = particles.WritePortal();
+  vtkm::Id n = portal.GetNumberOfValues();
+
+  for (vtkm::Id i = 0; i < n; i++)
+  {
+    auto p = portal.Get(i);
+
+    if (p.Status.CheckTerminate())
+    {
+      dsiInfo.TermIdx.push_back(i);
+      dsiInfo.TermID.push_back(p.ID);
+    }
+    else
+    {
+      const auto& it = dsiInfo.ParticleBlockIDsMap.find(p.ID);
+      VTKM_ASSERT(it != dsiInfo.ParticleBlockIDsMap.end());
+      auto currBIDs = it->second;
+      VTKM_ASSERT(!currBIDs.empty());
+
+      std::vector<vtkm::Id> newIDs;
+      if (p.Status.CheckSpatialBounds() && !p.Status.CheckTookAnySteps())
+        newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
+      else
+        newIDs = dsiInfo.BoundsMap.FindBlocks(p.Pos, currBIDs);
+
+      //reset the particle status.
+      p.Status = vtkm::ParticleStatus();
+
+      if (newIDs.empty()) //No blocks, we're done.
+      {
+        p.Status.SetTerminate();
+        dsiInfo.TermIdx.push_back(i);
+        dsiInfo.TermID.push_back(p.ID);
+      }
+      else
+      {
+        //If we have more than blockId, we want to minimize communication
+        //and put any blocks owned by this rank first.
+        if (newIDs.size() > 1)
+        {
+          for (auto idit = newIDs.begin(); idit != newIDs.end(); idit++)
+          {
+            vtkm::Id bid = *idit;
+            if (dsiInfo.BoundsMap.FindRank(bid) == this->Rank)
+            {
+              newIDs.erase(idit);
+              newIDs.insert(newIDs.begin(), bid);
+              break;
+            }
+          }
+        }
+
+        int dstRank = dsiInfo.BoundsMap.FindRank(newIDs[0]);
+        if (dstRank == this->Rank)
+        {
+          dsiInfo.A.push_back(p);
+          dsiInfo.IdMapA[p.ID] = newIDs;
+        }
+        else
+        {
+          dsiInfo.I.push_back(p);
+          dsiInfo.IdMapI[p.ID] = newIDs;
+        }
+      }
+      portal.Set(i, p);
+    }
+  }
+
+  //Make sure we didn't miss anything. Every particle goes into a single bucket.
+  VTKM_ASSERT(static_cast<std::size_t>(n) ==
+              (dsiInfo.A.size() + dsiInfo.I.size() + dsiInfo.TermIdx.size()));
+  VTKM_ASSERT(dsiInfo.TermIdx.size() == dsiInfo.TermID.size());
+}
+
+template <typename ParticleType, template <typename> class ResultType>
+VTKM_CONT void DataSetIntegrator::UpdateResult(const ResultType<ParticleType>& result,
+                                               DSIHelperInfo<ParticleType>& dsiInfo)
+{
+  this->ClassifyParticles(result.Particles, dsiInfo);
+
+  if (this->IsParticleAdvectionResult())
+  {
+    if (dsiInfo.TermIdx.empty())
+      return;
+
+    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+    auto indicesAH = vtkm::cont::make_ArrayHandle(dsiInfo.TermIdx, vtkm::CopyFlag::Off);
+    auto termPerm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, result.Particles);
+
+    vtkm::cont::ArrayHandle<ParticleType> termParticles;
+    vtkm::cont::Algorithm::Copy(termPerm, termParticles);
+
+    ResType termRes(termParticles);
+    this->Results.push_back(termRes);
+  }
+  else if (this->IsStreamlineResult())
+    this->Results.push_back(result);
+}
+
+template <typename ParticleType>
+VTKM_CONT bool DataSetIntegrator::GetOutput(vtkm::cont::DataSet& ds) const
+{
+  std::size_t nResults = this->Results.size();
+  if (nResults == 0)
+    return false;
+
+  if (this->IsParticleAdvectionResult())
+  {
+    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+
+    std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
+    allParticles.reserve(nResults);
+    for (const auto& vres : this->Results)
+      allParticles.push_back(vres.Get<ResType>().Particles);
+
+    vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
+    vtkm::cont::ParticleArrayCopy(allParticles, pts);
+
+    vtkm::Id numPoints = pts.GetNumberOfValues();
+    if (numPoints > 0)
+    {
+      //Create coordinate system and vertex cell set.
+      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", pts));
+
+      vtkm::cont::CellSetSingleType<> cells;
+      vtkm::cont::ArrayHandleIndex conn(numPoints);
+      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
+
+      vtkm::cont::ArrayCopy(conn, connectivity);
+      cells.Fill(numPoints, vtkm::CELL_SHAPE_VERTEX, 1, connectivity);
+      ds.SetCellSet(cells);
+    }
+  }
+  else if (this->IsStreamlineResult())
+  {
+    using ResType = vtkm::worklet::StreamlineResult<ParticleType>;
+
+    //Easy case with one result.
+    if (nResults == 1)
+    {
+      const auto& res = this->Results[0].Get<ResType>();
+      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", res.Positions));
+      ds.SetCellSet(res.PolyLines);
+    }
+    else
+    {
+      std::vector<vtkm::Id> posOffsets(nResults, 0);
+      vtkm::Id totalNumCells = 0, totalNumPts = 0;
+      for (std::size_t i = 0; i < nResults; i++)
+      {
+        const auto& res = this->Results[i].Get<ResType>();
+        if (i == 0)
+          posOffsets[i] = 0;
+        else
+          posOffsets[i] = totalNumPts;
+
+        totalNumPts += res.Positions.GetNumberOfValues();
+        totalNumCells += res.PolyLines.GetNumberOfCells();
+      }
+
+      //Append all the points together.
+      vtkm::cont::ArrayHandle<vtkm::Vec3f> appendPts;
+      appendPts.Allocate(totalNumPts);
+      for (std::size_t i = 0; i < nResults; i++)
+      {
+        const auto& res = this->Results[i].Get<ResType>();
+        // copy all values into appendPts starting at offset.
+        vtkm::cont::Algorithm::CopySubRange(
+          res.Positions, 0, res.Positions.GetNumberOfValues(), appendPts, posOffsets[i]);
+      }
+      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", appendPts));
+
+      //Create polylines.
+      std::vector<vtkm::Id> numPtsPerCell(static_cast<std::size_t>(totalNumCells));
+      std::size_t off = 0;
+      for (std::size_t i = 0; i < nResults; i++)
+      {
+        const auto& res = this->Results[i].Get<ResType>();
+        vtkm::Id nCells = res.PolyLines.GetNumberOfCells();
+        for (vtkm::Id j = 0; j < nCells; j++)
+          numPtsPerCell[off++] = static_cast<vtkm::Id>(res.PolyLines.GetNumberOfPointsInCell(j));
+      }
+
+      auto numPointsPerCellArray = vtkm::cont::make_ArrayHandle(numPtsPerCell, vtkm::CopyFlag::Off);
+
+      vtkm::cont::ArrayHandle<vtkm::Id> cellIndex;
+      vtkm::Id connectivityLen =
+        vtkm::cont::Algorithm::ScanExclusive(numPointsPerCellArray, cellIndex);
+      vtkm::cont::ArrayHandleIndex connCount(connectivityLen);
+      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
+      vtkm::cont::ArrayCopy(connCount, connectivity);
+
+      vtkm::cont::ArrayHandle<vtkm::UInt8> cellTypes;
+      auto polyLineShape = vtkm::cont::make_ArrayHandleConstant<vtkm::UInt8>(
+        vtkm::CELL_SHAPE_POLY_LINE, totalNumCells);
+      vtkm::cont::ArrayCopy(polyLineShape, cellTypes);
+      auto offsets = vtkm::cont::ConvertNumComponentsToOffsets(numPointsPerCellArray);
+
+      vtkm::cont::CellSetExplicit<> polyLines;
+      polyLines.Fill(totalNumPts, cellTypes, connectivity, offsets);
+      ds.SetCellSet(polyLines);
+    }
+  }
+  else
+  {
+    throw vtkm::cont::ErrorFilterExecution("Unsupported ParticleAdvectionResultType");
+  }
+
+  return true;
+}
+
 
 }
 }
 }
 
-#ifndef vtk_m_filter_particleadvection_DataSetIntegrator_hxx
-#include <vtkm/filter/particleadvection/DataSetIntegrator.hxx>
-#endif
-
 #endif //vtk_m_filter_particleadvection_DataSetIntegrator_h
diff --git a/vtkm/filter/particleadvection/DataSetIntegrator.hxx b/vtkm/filter/particleadvection/DataSetIntegrator.hxx
deleted file mode 100644
index 4f6d277b5..000000000
--- a/vtkm/filter/particleadvection/DataSetIntegrator.hxx
+++ /dev/null
@@ -1,251 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_particleadvection_DataSetIntegrator_hxx
-#define vtk_m_filter_particleadvection_DataSetIntegrator_hxx
-
-#include <vtkm/cont/ParticleArrayCopy.h>
-
-namespace vtkm
-{
-namespace filter
-{
-namespace particleadvection
-{
-
-template <typename ParticleType>
-VTKM_CONT void DataSetIntegrator::ClassifyParticles(
-  const vtkm::cont::ArrayHandle<ParticleType>& particles,
-  DSIHelperInfo<ParticleType>& dsiInfo) const
-{
-  dsiInfo.A.clear();
-  dsiInfo.I.clear();
-  dsiInfo.TermID.clear();
-  dsiInfo.TermIdx.clear();
-  dsiInfo.IdMapI.clear();
-  dsiInfo.IdMapA.clear();
-
-  auto portal = particles.WritePortal();
-  vtkm::Id n = portal.GetNumberOfValues();
-
-  for (vtkm::Id i = 0; i < n; i++)
-  {
-    auto p = portal.Get(i);
-
-    if (p.Status.CheckTerminate())
-    {
-      dsiInfo.TermIdx.push_back(i);
-      dsiInfo.TermID.push_back(p.ID);
-    }
-    else
-    {
-      const auto& it = dsiInfo.ParticleBlockIDsMap.find(p.ID);
-      VTKM_ASSERT(it != dsiInfo.ParticleBlockIDsMap.end());
-      auto currBIDs = it->second;
-      VTKM_ASSERT(!currBIDs.empty());
-
-      std::vector<vtkm::Id> newIDs;
-      if (p.Status.CheckSpatialBounds() && !p.Status.CheckTookAnySteps())
-        newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
-      else
-        newIDs = dsiInfo.BoundsMap.FindBlocks(p.Pos, currBIDs);
-
-      //reset the particle status.
-      p.Status = vtkm::ParticleStatus();
-
-      if (newIDs.empty()) //No blocks, we're done.
-      {
-        p.Status.SetTerminate();
-        dsiInfo.TermIdx.push_back(i);
-        dsiInfo.TermID.push_back(p.ID);
-      }
-      else
-      {
-        //If we have more than blockId, we want to minimize communication
-        //and put any blocks owned by this rank first.
-        if (newIDs.size() > 1)
-        {
-          for (auto idit = newIDs.begin(); idit != newIDs.end(); idit++)
-          {
-            vtkm::Id bid = *idit;
-            if (dsiInfo.BoundsMap.FindRank(bid) == this->Rank)
-            {
-              newIDs.erase(idit);
-              newIDs.insert(newIDs.begin(), bid);
-              break;
-            }
-          }
-        }
-
-        int dstRank = dsiInfo.BoundsMap.FindRank(newIDs[0]);
-        if (dstRank == this->Rank)
-        {
-          dsiInfo.A.push_back(p);
-          dsiInfo.IdMapA[p.ID] = newIDs;
-        }
-        else
-        {
-          dsiInfo.I.push_back(p);
-          dsiInfo.IdMapI[p.ID] = newIDs;
-        }
-      }
-      portal.Set(i, p);
-    }
-  }
-
-  //Make sure we didn't miss anything. Every particle goes into a single bucket.
-  VTKM_ASSERT(static_cast<std::size_t>(n) ==
-              (dsiInfo.A.size() + dsiInfo.I.size() + dsiInfo.TermIdx.size()));
-  VTKM_ASSERT(dsiInfo.TermIdx.size() == dsiInfo.TermID.size());
-}
-
-template <typename ParticleType, template <typename> class ResultType>
-VTKM_CONT void DataSetIntegrator::UpdateResult(const ResultType<ParticleType>& result,
-                                               DSIHelperInfo<ParticleType>& dsiInfo)
-{
-  this->ClassifyParticles(result.Particles, dsiInfo);
-
-  if (this->IsParticleAdvectionResult())
-  {
-    if (dsiInfo.TermIdx.empty())
-      return;
-
-    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
-    auto indicesAH = vtkm::cont::make_ArrayHandle(dsiInfo.TermIdx, vtkm::CopyFlag::Off);
-    auto termPerm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, result.Particles);
-
-    vtkm::cont::ArrayHandle<ParticleType> termParticles;
-    vtkm::cont::Algorithm::Copy(termPerm, termParticles);
-
-    ResType termRes(termParticles);
-    this->Results.push_back(termRes);
-  }
-  else if (this->IsStreamlineResult())
-    this->Results.push_back(result);
-}
-
-template <typename ParticleType>
-VTKM_CONT bool DataSetIntegrator::GetOutput(vtkm::cont::DataSet& ds) const
-{
-  std::size_t nResults = this->Results.size();
-  if (nResults == 0)
-    return false;
-
-  if (this->IsParticleAdvectionResult())
-  {
-    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
-
-    std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
-    allParticles.reserve(nResults);
-    for (const auto& vres : this->Results)
-      allParticles.push_back(vres.Get<ResType>().Particles);
-
-    vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
-    vtkm::cont::ParticleArrayCopy(allParticles, pts);
-
-    vtkm::Id numPoints = pts.GetNumberOfValues();
-    if (numPoints > 0)
-    {
-      //Create coordinate system and vertex cell set.
-      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", pts));
-
-      vtkm::cont::CellSetSingleType<> cells;
-      vtkm::cont::ArrayHandleIndex conn(numPoints);
-      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
-
-      vtkm::cont::ArrayCopy(conn, connectivity);
-      cells.Fill(numPoints, vtkm::CELL_SHAPE_VERTEX, 1, connectivity);
-      ds.SetCellSet(cells);
-    }
-  }
-  else if (this->IsStreamlineResult())
-  {
-    using ResType = vtkm::worklet::StreamlineResult<ParticleType>;
-
-    //Easy case with one result.
-    if (nResults == 1)
-    {
-      const auto& res = this->Results[0].Get<ResType>();
-      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", res.Positions));
-      ds.SetCellSet(res.PolyLines);
-    }
-    else
-    {
-      std::vector<vtkm::Id> posOffsets(nResults, 0);
-      vtkm::Id totalNumCells = 0, totalNumPts = 0;
-      for (std::size_t i = 0; i < nResults; i++)
-      {
-        const auto& res = this->Results[i].Get<ResType>();
-        if (i == 0)
-          posOffsets[i] = 0;
-        else
-          posOffsets[i] = totalNumPts;
-
-        totalNumPts += res.Positions.GetNumberOfValues();
-        totalNumCells += res.PolyLines.GetNumberOfCells();
-      }
-
-      //Append all the points together.
-      vtkm::cont::ArrayHandle<vtkm::Vec3f> appendPts;
-      appendPts.Allocate(totalNumPts);
-      for (std::size_t i = 0; i < nResults; i++)
-      {
-        const auto& res = this->Results[i].Get<ResType>();
-        // copy all values into appendPts starting at offset.
-        vtkm::cont::Algorithm::CopySubRange(
-          res.Positions, 0, res.Positions.GetNumberOfValues(), appendPts, posOffsets[i]);
-      }
-      ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", appendPts));
-
-      //Create polylines.
-      std::vector<vtkm::Id> numPtsPerCell(static_cast<std::size_t>(totalNumCells));
-      std::size_t off = 0;
-      for (std::size_t i = 0; i < nResults; i++)
-      {
-        const auto& res = this->Results[i].Get<ResType>();
-        vtkm::Id nCells = res.PolyLines.GetNumberOfCells();
-        for (vtkm::Id j = 0; j < nCells; j++)
-          numPtsPerCell[off++] = static_cast<vtkm::Id>(res.PolyLines.GetNumberOfPointsInCell(j));
-      }
-
-      auto numPointsPerCellArray = vtkm::cont::make_ArrayHandle(numPtsPerCell, vtkm::CopyFlag::Off);
-
-      vtkm::cont::ArrayHandle<vtkm::Id> cellIndex;
-      vtkm::Id connectivityLen =
-        vtkm::cont::Algorithm::ScanExclusive(numPointsPerCellArray, cellIndex);
-      vtkm::cont::ArrayHandleIndex connCount(connectivityLen);
-      vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
-      vtkm::cont::ArrayCopy(connCount, connectivity);
-
-      vtkm::cont::ArrayHandle<vtkm::UInt8> cellTypes;
-      auto polyLineShape = vtkm::cont::make_ArrayHandleConstant<vtkm::UInt8>(
-        vtkm::CELL_SHAPE_POLY_LINE, totalNumCells);
-      vtkm::cont::ArrayCopy(polyLineShape, cellTypes);
-      auto offsets = vtkm::cont::ConvertNumComponentsToOffsets(numPointsPerCellArray);
-
-      vtkm::cont::CellSetExplicit<> polyLines;
-      polyLines.Fill(totalNumPts, cellTypes, connectivity, offsets);
-      ds.SetCellSet(polyLines);
-    }
-  }
-  else
-  {
-    throw vtkm::cont::ErrorFilterExecution("Unsupported ParticleAdvectionResultType");
-  }
-
-  return true;
-}
-
-
-}
-}
-}
-
-#endif //vtk_m_filter_particleadvection_DataSetIntegrator_hxx
diff --git a/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h b/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h
index ad52314c7..fd47026c9 100644
--- a/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h
+++ b/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h
@@ -39,13 +39,13 @@ public:
   {
   }
 
-  VTKM_CONT virtual inline void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                         vtkm::FloatDefault stepSize,
-                                         vtkm::Id maxSteps) override;
+  VTKM_CONT inline void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                 vtkm::FloatDefault stepSize,
+                                 vtkm::Id maxSteps) override;
 
-  VTKM_CONT virtual inline void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
-                                         vtkm::FloatDefault stepSize,
-                                         vtkm::Id maxSteps) override;
+  VTKM_CONT inline void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
+                                 vtkm::FloatDefault stepSize,
+                                 vtkm::Id maxSteps) override;
 
 protected:
   template <typename ArrayType>
@@ -69,12 +69,143 @@ private:
   vtkm::cont::DataSet DataSet;
 };
 
-}
-}
+
+namespace internal
+{
+using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+using SteadyStateGridEvalType = vtkm::worklet::particleadvection::GridEvaluator<VelocityFieldType>;
+
+template <typename GridEvalType, typename ParticleType>
+class AdvectHelper;
+
+template <typename ParticleType>
+class AdvectHelper<SteadyStateGridEvalType, ParticleType>
+{
+public:
+  static void Advect(const VelocityFieldType& velField,
+                     const vtkm::cont::DataSet& ds,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  static void Advect(const VelocityFieldType& velField,
+                     const vtkm::cont::DataSet& ds,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::StreamlineResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField, ds, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  template <typename WorkletType,
+            template <typename>
+            class ResultType,
+            template <typename>
+            class SolverType>
+  static void DoAdvect(const VelocityFieldType& velField,
+                       const vtkm::cont::DataSet& ds,
+                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                       vtkm::FloatDefault stepSize,
+                       vtkm::Id maxSteps,
+                       ResultType<ParticleType>& result)
+  {
+    using StepperType =
+      vtkm::worklet::particleadvection::Stepper<SolverType<SteadyStateGridEvalType>,
+                                                SteadyStateGridEvalType>;
+
+    WorkletType worklet;
+    SteadyStateGridEvalType eval(ds, velField);
+    StepperType stepper(eval, stepSize);
+    result = worklet.Run(stepper, seedArray, maxSteps);
+  }
+};
 }
 
-#ifndef vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_hxx
-#include <vtkm/filter/particleadvection/DataSetIntegratorSteadyState.hxx>
-#endif
+VTKM_CONT inline void DataSetIntegratorSteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                                             vtkm::FloatDefault stepSize,
+                                                             vtkm::Id maxSteps)
+{
+  using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+
+  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
+  auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
+
+  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
+  {
+    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+    FieldType velField;
+    this->GetVelocityField(velField);
+
+    using AHType = internal::AdvectHelper<internal::SteadyStateGridEvalType, vtkm::Particle>;
+
+    if (this->IsParticleAdvectionResult())
+    {
+      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
+      AHType::Advect(
+        velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
+      this->UpdateResult(result, b);
+    }
+    else if (this->IsStreamlineResult())
+    {
+      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
+      AHType::Advect(
+        velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
+      this->UpdateResult(result, b);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported result type");
+  }
+  else
+    throw vtkm::cont::ErrorFilterExecution("Unsupported vector field type");
+}
+
+VTKM_CONT inline void DataSetIntegratorSteadyState::DoAdvect(
+  DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
+  vtkm::FloatDefault vtkmNotUsed(stepSize),
+  vtkm::Id vtkmNotUsed(maxSteps))
+{
+}
+
+}
+}
+}
 
 #endif //vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_h
diff --git a/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.hxx b/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.hxx
deleted file mode 100644
index 5b91d2328..000000000
--- a/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.hxx
+++ /dev/null
@@ -1,159 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_hxx
-#define vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_hxx
-
-namespace vtkm
-{
-namespace filter
-{
-namespace particleadvection
-{
-
-namespace internal
-{
-using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-using SteadyStateGridEvalType = vtkm::worklet::particleadvection::GridEvaluator<VelocityFieldType>;
-
-template <typename GridEvalType, typename ParticleType>
-class AdvectHelper;
-
-template <typename ParticleType>
-class AdvectHelper<SteadyStateGridEvalType, ParticleType>
-{
-public:
-  static void Advect(const VelocityFieldType& velField,
-                     const vtkm::cont::DataSet& ds,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& solverType,
-                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
-  {
-    if (solverType == IntegrationSolverType::RK4_TYPE)
-    {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    }
-    else if (solverType == IntegrationSolverType::EULER_TYPE)
-    {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  static void Advect(const VelocityFieldType& velField,
-                     const vtkm::cont::DataSet& ds,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& solverType,
-                     vtkm::worklet::StreamlineResult<ParticleType>& result)
-  {
-    if (solverType == IntegrationSolverType::RK4_TYPE)
-    {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    }
-    else if (solverType == IntegrationSolverType::EULER_TYPE)
-    {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField, ds, seedArray, stepSize, maxSteps, result);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  template <typename WorkletType,
-            template <typename>
-            class ResultType,
-            template <typename>
-            class SolverType>
-  static void DoAdvect(const VelocityFieldType& velField,
-                       const vtkm::cont::DataSet& ds,
-                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                       vtkm::FloatDefault stepSize,
-                       vtkm::Id maxSteps,
-                       ResultType<ParticleType>& result)
-  {
-    using StepperType =
-      vtkm::worklet::particleadvection::Stepper<SolverType<SteadyStateGridEvalType>,
-                                                SteadyStateGridEvalType>;
-
-    WorkletType worklet;
-    SteadyStateGridEvalType eval(ds, velField);
-    StepperType stepper(eval, stepSize);
-    result = worklet.Run(stepper, seedArray, maxSteps);
-  }
-};
-}
-
-VTKM_CONT inline void DataSetIntegratorSteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                                             vtkm::FloatDefault stepSize,
-                                                             vtkm::Id maxSteps)
-{
-  using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-
-  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
-  auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
-
-  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
-  {
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-    FieldType velField;
-    this->GetVelocityField(velField);
-
-    using AHType = internal::AdvectHelper<internal::SteadyStateGridEvalType, vtkm::Particle>;
-
-    if (this->IsParticleAdvectionResult())
-    {
-      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
-      AHType::Advect(
-        velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
-      this->UpdateResult(result, b);
-    }
-    else if (this->IsStreamlineResult())
-    {
-      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
-      AHType::Advect(
-        velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
-      this->UpdateResult(result, b);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported result type");
-  }
-  else
-    throw vtkm::cont::ErrorFilterExecution("Unsupported vector field type");
-}
-
-VTKM_CONT inline void DataSetIntegratorSteadyState::DoAdvect(
-  DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
-  vtkm::FloatDefault vtkmNotUsed(stepSize),
-  vtkm::Id vtkmNotUsed(maxSteps))
-{
-}
-
-}
-}
-}
-
-#endif //vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_hxx
diff --git a/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h b/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h
index 3bc00c195..374375095 100644
--- a/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h
+++ b/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h
@@ -12,6 +12,7 @@
 #define vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_h
 
 #include <vtkm/filter/particleadvection/DataSetIntegrator.h>
+#include <vtkm/worklet/particleadvection/TemporalGridEvaluators.h>
 
 namespace vtkm
 {
@@ -85,12 +86,177 @@ private:
   vtkm::FloatDefault Time2;
 };
 
-}
-}
+
+
+namespace internal
+{
+using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+using UnsteadyStateGridEvalType =
+  vtkm::worklet::particleadvection::TemporalGridEvaluator<VelocityFieldType>;
+
+template <typename GridEvalType, typename ParticleType>
+class AdvectHelper;
+
+template <typename ParticleType>
+class AdvectHelper<UnsteadyStateGridEvalType, ParticleType>
+{
+public:
+  static void Advect(const VelocityFieldType& velField1,
+                     const vtkm::cont::DataSet& ds1,
+                     vtkm::FloatDefault t1,
+                     const VelocityFieldType& velField2,
+                     const vtkm::cont::DataSet& ds2,
+                     vtkm::FloatDefault t2,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::ParticleAdvection,
+               vtkm::worklet::ParticleAdvectionResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  static void Advect(const VelocityFieldType& velField1,
+                     const vtkm::cont::DataSet& ds1,
+                     vtkm::FloatDefault t1,
+                     const VelocityFieldType& velField2,
+                     const vtkm::cont::DataSet& ds2,
+                     vtkm::FloatDefault t2,
+                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                     vtkm::FloatDefault stepSize,
+                     vtkm::Id maxSteps,
+                     const IntegrationSolverType& solverType,
+                     vtkm::worklet::StreamlineResult<ParticleType>& result)
+  {
+    if (solverType == IntegrationSolverType::RK4_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::RK4Integrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else if (solverType == IntegrationSolverType::EULER_TYPE)
+    {
+      DoAdvect<vtkm::worklet::Streamline,
+               vtkm::worklet::StreamlineResult,
+               vtkm::worklet::particleadvection::EulerIntegrator>(
+        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
+  }
+
+  template <typename WorkletType,
+            template <typename>
+            class ResultType,
+            template <typename>
+            class SolverType>
+  static void DoAdvect(const VelocityFieldType& velField1,
+                       const vtkm::cont::DataSet& ds1,
+                       vtkm::FloatDefault t1,
+                       const VelocityFieldType& velField2,
+                       const vtkm::cont::DataSet& ds2,
+                       vtkm::FloatDefault t2,
+                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
+                       vtkm::FloatDefault stepSize,
+                       vtkm::Id maxSteps,
+                       ResultType<ParticleType>& result)
+  {
+    using StepperType =
+      vtkm::worklet::particleadvection::Stepper<SolverType<UnsteadyStateGridEvalType>,
+                                                UnsteadyStateGridEvalType>;
+
+    WorkletType worklet;
+    UnsteadyStateGridEvalType eval(ds1, t1, velField1, ds2, t2, velField2);
+    StepperType stepper(eval, stepSize);
+    result = worklet.Run(stepper, seedArray, maxSteps);
+  }
+};
+
 }
 
-#ifndef vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_hxx
-#include <vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.hxx>
-#endif
+VTKM_CONT inline void DataSetIntegratorUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                                               vtkm::FloatDefault stepSize,
+                                                               vtkm::Id maxSteps)
+{
+  using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
+
+  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
+  auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
+
+  using AHType = internal::AdvectHelper<internal::UnsteadyStateGridEvalType, vtkm::Particle>;
+
+  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
+  {
+    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+    FieldType velField1, velField2;
+    this->GetVelocityFields(velField1, velField2);
+
+    if (this->IsParticleAdvectionResult())
+    {
+      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
+      AHType::Advect(velField1,
+                     this->DataSet1,
+                     this->Time1,
+                     velField2,
+                     this->DataSet2,
+                     this->Time2,
+                     seedArray,
+                     stepSize,
+                     maxSteps,
+                     this->SolverType,
+                     result);
+      this->UpdateResult(result, b);
+    }
+    else if (this->IsStreamlineResult())
+    {
+      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
+      AHType::Advect(velField1,
+                     this->DataSet1,
+                     this->Time1,
+                     velField2,
+                     this->DataSet2,
+                     this->Time2,
+                     seedArray,
+                     stepSize,
+                     maxSteps,
+                     this->SolverType,
+                     result);
+      this->UpdateResult(result, b);
+    }
+    else
+      throw vtkm::cont::ErrorFilterExecution("Unsupported result type");
+  }
+  else
+    throw vtkm::cont::ErrorFilterExecution("Unsupported vector field type");
+}
+
+VTKM_CONT inline void DataSetIntegratorUnsteadyState::DoAdvect(
+  DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
+  vtkm::FloatDefault vtkmNotUsed(stepSize),
+  vtkm::Id vtkmNotUsed(maxSteps))
+{
+}
+
+
+}
+}
+}
 
 #endif //vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_h
diff --git a/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.hxx b/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.hxx
deleted file mode 100644
index 60fb254f2..000000000
--- a/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.hxx
+++ /dev/null
@@ -1,193 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_hxx
-#define vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_hxx
-
-#include <vtkm/worklet/particleadvection/TemporalGridEvaluators.h>
-
-namespace vtkm
-{
-namespace filter
-{
-namespace particleadvection
-{
-
-namespace internal
-{
-using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-using UnsteadyStateGridEvalType =
-  vtkm::worklet::particleadvection::TemporalGridEvaluator<VelocityFieldType>;
-
-template <typename GridEvalType, typename ParticleType>
-class AdvectHelper;
-
-template <typename ParticleType>
-class AdvectHelper<UnsteadyStateGridEvalType, ParticleType>
-{
-public:
-  static void Advect(const VelocityFieldType& velField1,
-                     const vtkm::cont::DataSet& ds1,
-                     vtkm::FloatDefault t1,
-                     const VelocityFieldType& velField2,
-                     const vtkm::cont::DataSet& ds2,
-                     vtkm::FloatDefault t2,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& solverType,
-                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
-  {
-    if (solverType == IntegrationSolverType::RK4_TYPE)
-    {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
-        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
-    }
-    else if (solverType == IntegrationSolverType::EULER_TYPE)
-    {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  static void Advect(const VelocityFieldType& velField1,
-                     const vtkm::cont::DataSet& ds1,
-                     vtkm::FloatDefault t1,
-                     const VelocityFieldType& velField2,
-                     const vtkm::cont::DataSet& ds2,
-                     vtkm::FloatDefault t2,
-                     vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                     vtkm::FloatDefault stepSize,
-                     vtkm::Id maxSteps,
-                     const IntegrationSolverType& solverType,
-                     vtkm::worklet::StreamlineResult<ParticleType>& result)
-  {
-    if (solverType == IntegrationSolverType::RK4_TYPE)
-    {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
-        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
-    }
-    else if (solverType == IntegrationSolverType::EULER_TYPE)
-    {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
-        velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported Integrator type");
-  }
-
-  template <typename WorkletType,
-            template <typename>
-            class ResultType,
-            template <typename>
-            class SolverType>
-  static void DoAdvect(const VelocityFieldType& velField1,
-                       const vtkm::cont::DataSet& ds1,
-                       vtkm::FloatDefault t1,
-                       const VelocityFieldType& velField2,
-                       const vtkm::cont::DataSet& ds2,
-                       vtkm::FloatDefault t2,
-                       vtkm::cont::ArrayHandle<ParticleType>& seedArray,
-                       vtkm::FloatDefault stepSize,
-                       vtkm::Id maxSteps,
-                       ResultType<ParticleType>& result)
-  {
-    using StepperType =
-      vtkm::worklet::particleadvection::Stepper<SolverType<UnsteadyStateGridEvalType>,
-                                                UnsteadyStateGridEvalType>;
-
-    WorkletType worklet;
-    UnsteadyStateGridEvalType eval(ds1, t1, velField1, ds2, t2, velField2);
-    StepperType stepper(eval, stepSize);
-    result = worklet.Run(stepper, seedArray, maxSteps);
-  }
-};
-
-}
-
-VTKM_CONT inline void DataSetIntegratorUnsteadyState::DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                                               vtkm::FloatDefault stepSize,
-                                                               vtkm::Id maxSteps)
-{
-  using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-
-  auto copyFlag = (this->CopySeedArray ? vtkm::CopyFlag::On : vtkm::CopyFlag::Off);
-  auto seedArray = vtkm::cont::make_ArrayHandle(b.V, copyFlag);
-
-  using AHType = internal::AdvectHelper<internal::UnsteadyStateGridEvalType, vtkm::Particle>;
-
-  if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
-  {
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-    FieldType velField1, velField2;
-    this->GetVelocityFields(velField1, velField2);
-
-    if (this->IsParticleAdvectionResult())
-    {
-      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
-      AHType::Advect(velField1,
-                     this->DataSet1,
-                     this->Time1,
-                     velField2,
-                     this->DataSet2,
-                     this->Time2,
-                     seedArray,
-                     stepSize,
-                     maxSteps,
-                     this->SolverType,
-                     result);
-      this->UpdateResult(result, b);
-    }
-    else if (this->IsStreamlineResult())
-    {
-      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
-      AHType::Advect(velField1,
-                     this->DataSet1,
-                     this->Time1,
-                     velField2,
-                     this->DataSet2,
-                     this->Time2,
-                     seedArray,
-                     stepSize,
-                     maxSteps,
-                     this->SolverType,
-                     result);
-      this->UpdateResult(result, b);
-    }
-    else
-      throw vtkm::cont::ErrorFilterExecution("Unsupported result type");
-  }
-  else
-    throw vtkm::cont::ErrorFilterExecution("Unsupported vector field type");
-}
-
-VTKM_CONT inline void DataSetIntegratorUnsteadyState::DoAdvect(
-  DSIHelperInfo<vtkm::ChargedParticle>& vtkmNotUsed(b),
-  vtkm::FloatDefault vtkmNotUsed(stepSize),
-  vtkm::Id vtkmNotUsed(maxSteps))
-{
-}
-
-}
-}
-}
-
-#endif //vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_hxx
diff --git a/vtkm/filter/particleadvection/ParticleMessenger.cxx b/vtkm/filter/particleadvection/ParticleMessenger.cxx
deleted file mode 100644
index 6a7a0fe12..000000000
--- a/vtkm/filter/particleadvection/ParticleMessenger.cxx
+++ /dev/null
@@ -1,246 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#include <vtkm/filter/particleadvection/ParticleMessenger.h>
-
-#include <iostream>
-#include <string.h>
-#include <vtkm/cont/Logging.h>
-#include <vtkm/cont/Serialization.h>
-
-namespace vtkm
-{
-namespace filter
-{
-namespace particleadvection
-{
-
-VTKM_CONT
-template <typename ParticleType>
-ParticleMessenger<ParticleType>::ParticleMessenger(
-  vtkmdiy::mpi::communicator& comm,
-  const vtkm::filter::particleadvection::BoundsMap& boundsMap,
-  int msgSz,
-  int numParticles,
-  int numBlockIds)
-  : Messenger(comm)
-#ifdef VTKM_ENABLE_MPI
-  , BoundsMap(boundsMap)
-#endif
-{
-#ifdef VTKM_ENABLE_MPI
-  this->RegisterMessages(msgSz, numParticles, numBlockIds);
-#else
-  (void)(boundsMap);
-  (void)(msgSz);
-  (void)(numParticles);
-  (void)(numBlockIds);
-#endif
-}
-
-template <typename ParticleType>
-std::size_t ParticleMessenger<ParticleType>::CalcParticleBufferSize(std::size_t nParticles,
-                                                                    std::size_t nBlockIds)
-{
-  std::size_t pSize = sizeof(ParticleType);
-
-#ifndef NDEBUG
-  vtkmdiy::MemoryBuffer buff;
-  ParticleType p;
-  vtkmdiy::save(buff, p);
-
-  //Make sure the buffer size is correct.
-  VTKM_ASSERT(pSize == buff.size());
-#endif
-
-  return
-    // rank
-    sizeof(int)
-    //std::vector<ParticleType> p;
-    //p.size()
-    + sizeof(std::size_t)
-    //nParticles of ParticleType
-    + nParticles * pSize
-    // std::vector<vtkm::Id> blockIDs for each particle.
-    // blockIDs.size() for each particle
-    + nParticles * sizeof(std::size_t)
-    // nBlockIDs of vtkm::Id for each particle.
-    + nParticles * nBlockIds * sizeof(vtkm::Id);
-}
-
-VTKM_CONT
-template <typename ParticleType>
-void ParticleMessenger<ParticleType>::SerialExchange(
-  const std::vector<ParticleType>& outData,
-  const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
-  vtkm::Id vtkmNotUsed(numLocalTerm),
-  std::vector<ParticleType>& inData,
-  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
-  bool vtkmNotUsed(blockAndWait)) const
-{
-  for (auto& p : outData)
-  {
-    const auto& bids = outBlockIDsMap.find(p.ID)->second;
-    inData.push_back(p);
-    inDataBlockIDsMap[p.ID] = bids;
-  }
-}
-
-VTKM_CONT
-template <typename ParticleType>
-void ParticleMessenger<ParticleType>::Exchange(
-  const std::vector<ParticleType>& outData,
-  const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
-  vtkm::Id numLocalTerm,
-  std::vector<ParticleType>& inData,
-  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
-  vtkm::Id& numTerminateMessages,
-  bool blockAndWait)
-{
-  numTerminateMessages = 0;
-  inDataBlockIDsMap.clear();
-
-  if (this->GetNumRanks() == 1)
-    return this->SerialExchange(
-      outData, outBlockIDsMap, numLocalTerm, inData, inDataBlockIDsMap, blockAndWait);
-
-#ifdef VTKM_ENABLE_MPI
-
-  //dstRank, vector of (particles,blockIDs)
-  std::unordered_map<int, std::vector<ParticleCommType>> sendData;
-
-  for (const auto& p : outData)
-  {
-    const auto& bids = outBlockIDsMap.find(p.ID)->second;
-    int dstRank = this->BoundsMap.FindRank(bids[0]);
-    sendData[dstRank].push_back(std::make_pair(p, bids));
-  }
-
-  //Do all the sends first.
-  if (numLocalTerm > 0)
-    this->SendAllMsg({ MSG_TERMINATE, static_cast<int>(numLocalTerm) });
-  this->SendParticles(sendData);
-  this->CheckPendingSendRequests();
-
-  //Check if we have anything coming in.
-  std::vector<ParticleRecvCommType> particleData;
-  std::vector<MsgCommType> msgData;
-  if (RecvAny(&msgData, &particleData, blockAndWait))
-  {
-    for (const auto& it : particleData)
-      for (const auto& v : it.second)
-      {
-        const auto& p = v.first;
-        const auto& bids = v.second;
-        inData.push_back(p);
-        inDataBlockIDsMap[p.ID] = bids;
-      }
-
-    for (const auto& m : msgData)
-    {
-      if (m.second[0] == MSG_TERMINATE)
-        numTerminateMessages += static_cast<vtkm::Id>(m.second[1]);
-    }
-  }
-#endif
-}
-
-#ifdef VTKM_ENABLE_MPI
-
-VTKM_CONT
-template <typename ParticleType>
-void ParticleMessenger<ParticleType>::RegisterMessages(int msgSz, int nParticles, int numBlockIds)
-{
-  //Determine buffer size for msg and particle tags.
-  std::size_t messageBuffSz = CalcMessageBufferSize(msgSz + 1);
-  std::size_t particleBuffSz = CalcParticleBufferSize(nParticles, numBlockIds);
-
-  int numRecvs = std::min(64, this->GetNumRanks() - 1);
-
-  this->RegisterTag(ParticleMessenger::MESSAGE_TAG, numRecvs, messageBuffSz);
-  this->RegisterTag(ParticleMessenger::PARTICLE_TAG, numRecvs, particleBuffSz);
-
-  this->InitializeBuffers();
-}
-
-VTKM_CONT
-template <typename ParticleType>
-void ParticleMessenger<ParticleType>::SendMsg(int dst, const std::vector<int>& msg)
-{
-  vtkmdiy::MemoryBuffer buff;
-
-  //Write data.
-  vtkmdiy::save(buff, this->GetRank());
-  vtkmdiy::save(buff, msg);
-  this->SendData(dst, ParticleMessenger::MESSAGE_TAG, buff);
-}
-
-VTKM_CONT
-template <typename ParticleType>
-void ParticleMessenger<ParticleType>::SendAllMsg(const std::vector<int>& msg)
-{
-  for (int i = 0; i < this->GetNumRanks(); i++)
-    if (i != this->GetRank())
-      this->SendMsg(i, msg);
-}
-
-VTKM_CONT
-template <typename ParticleType>
-bool ParticleMessenger<ParticleType>::RecvAny(std::vector<MsgCommType>* msgs,
-                                              std::vector<ParticleRecvCommType>* recvParticles,
-                                              bool blockAndWait)
-{
-  std::set<int> tags;
-  if (msgs)
-  {
-    tags.insert(ParticleMessenger::MESSAGE_TAG);
-    msgs->resize(0);
-  }
-  if (recvParticles)
-  {
-    tags.insert(ParticleMessenger::PARTICLE_TAG);
-    recvParticles->resize(0);
-  }
-
-  if (tags.empty())
-    return false;
-
-  std::vector<std::pair<int, vtkmdiy::MemoryBuffer>> buffers;
-  if (!this->RecvData(tags, buffers, blockAndWait))
-    return false;
-
-  for (auto& buff : buffers)
-  {
-    if (buff.first == ParticleMessenger::MESSAGE_TAG)
-    {
-      int sendRank;
-      std::vector<int> m;
-      vtkmdiy::load(buff.second, sendRank);
-      vtkmdiy::load(buff.second, m);
-      msgs->push_back(std::make_pair(sendRank, m));
-    }
-    else if (buff.first == ParticleMessenger::PARTICLE_TAG)
-    {
-      int sendRank;
-      std::vector<ParticleCommType> particles;
-
-      vtkmdiy::load(buff.second, sendRank);
-      vtkmdiy::load(buff.second, particles);
-      recvParticles->push_back(std::make_pair(sendRank, particles));
-    }
-  }
-
-  return true;
-}
-
-#endif
-}
-}
-} // vtkm::filter::particleadvection
diff --git a/vtkm/filter/particleadvection/ParticleMessenger.h b/vtkm/filter/particleadvection/ParticleMessenger.h
index 7ceb7b124..fc960777a 100644
--- a/vtkm/filter/particleadvection/ParticleMessenger.h
+++ b/vtkm/filter/particleadvection/ParticleMessenger.h
@@ -62,11 +62,7 @@ protected:
 #ifdef VTKM_ENABLE_MPI
   static constexpr int MSG_TERMINATE = 1;
 
-  enum
-  {
-    MESSAGE_TAG = 0x42000,
-    PARTICLE_TAG = 0x42001
-  };
+  enum { MESSAGE_TAG = 0x42000, PARTICLE_TAG = 0x42001 };
 
   VTKM_CONT void RegisterMessages(int msgSz, int nParticles, int numBlockIds);
 
@@ -109,8 +105,227 @@ protected:
   static std::size_t CalcParticleBufferSize(std::size_t nParticles, std::size_t numBlockIds = 2);
 };
 
+//methods
+
+VTKM_CONT
+template <typename ParticleType>
+ParticleMessenger<ParticleType>::ParticleMessenger(
+  vtkmdiy::mpi::communicator& comm,
+  const vtkm::filter::particleadvection::BoundsMap& boundsMap,
+  int msgSz,
+  int numParticles,
+  int numBlockIds)
+  : Messenger(comm)
+#ifdef VTKM_ENABLE_MPI
+  , BoundsMap(boundsMap)
+#endif
+{
+#ifdef VTKM_ENABLE_MPI
+  this->RegisterMessages(msgSz, numParticles, numBlockIds);
+#else
+  (void)(boundsMap);
+  (void)(msgSz);
+  (void)(numParticles);
+  (void)(numBlockIds);
+#endif
+}
+
+template <typename ParticleType>
+std::size_t ParticleMessenger<ParticleType>::CalcParticleBufferSize(std::size_t nParticles,
+                                                                    std::size_t nBlockIds)
+{
+  std::size_t pSize = sizeof(ParticleType);
+
+#ifndef NDEBUG
+  vtkmdiy::MemoryBuffer buff;
+  ParticleType p;
+  vtkmdiy::save(buff, p);
+
+  //Make sure the buffer size is correct.
+  VTKM_ASSERT(pSize == buff.size());
+#endif
+
+  return
+    // rank
+    sizeof(int)
+    //std::vector<ParticleType> p;
+    //p.size()
+    + sizeof(std::size_t)
+    //nParticles of ParticleType
+    + nParticles * pSize
+    // std::vector<vtkm::Id> blockIDs for each particle.
+    // blockIDs.size() for each particle
+    + nParticles * sizeof(std::size_t)
+    // nBlockIDs of vtkm::Id for each particle.
+    + nParticles * nBlockIds * sizeof(vtkm::Id);
+}
+
+VTKM_CONT
+template <typename ParticleType>
+void ParticleMessenger<ParticleType>::SerialExchange(
+  const std::vector<ParticleType>& outData,
+  const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
+  vtkm::Id vtkmNotUsed(numLocalTerm),
+  std::vector<ParticleType>& inData,
+  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
+  bool vtkmNotUsed(blockAndWait)) const
+{
+  for (auto& p : outData)
+  {
+    const auto& bids = outBlockIDsMap.find(p.ID)->second;
+    inData.push_back(p);
+    inDataBlockIDsMap[p.ID] = bids;
+  }
+}
+
+VTKM_CONT
+template <typename ParticleType>
+void ParticleMessenger<ParticleType>::Exchange(
+  const std::vector<ParticleType>& outData,
+  const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
+  vtkm::Id numLocalTerm,
+  std::vector<ParticleType>& inData,
+  std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
+  vtkm::Id& numTerminateMessages,
+  bool blockAndWait)
+{
+  numTerminateMessages = 0;
+  inDataBlockIDsMap.clear();
+
+  if (this->GetNumRanks() == 1)
+    return this->SerialExchange(
+      outData, outBlockIDsMap, numLocalTerm, inData, inDataBlockIDsMap, blockAndWait);
 
 #ifdef VTKM_ENABLE_MPI
+
+  //dstRank, vector of (particles,blockIDs)
+  std::unordered_map<int, std::vector<ParticleCommType>> sendData;
+
+  for (const auto& p : outData)
+  {
+    const auto& bids = outBlockIDsMap.find(p.ID)->second;
+    int dstRank = this->BoundsMap.FindRank(bids[0]);
+    sendData[dstRank].push_back(std::make_pair(p, bids));
+  }
+
+  //Do all the sends first.
+  if (numLocalTerm > 0)
+    this->SendAllMsg({ MSG_TERMINATE, static_cast<int>(numLocalTerm) });
+  this->SendParticles(sendData);
+  this->CheckPendingSendRequests();
+
+  //Check if we have anything coming in.
+  std::vector<ParticleRecvCommType> particleData;
+  std::vector<MsgCommType> msgData;
+  if (RecvAny(&msgData, &particleData, blockAndWait))
+  {
+    for (const auto& it : particleData)
+      for (const auto& v : it.second)
+      {
+        const auto& p = v.first;
+        const auto& bids = v.second;
+        inData.push_back(p);
+        inDataBlockIDsMap[p.ID] = bids;
+      }
+
+    for (const auto& m : msgData)
+    {
+      if (m.second[0] == MSG_TERMINATE)
+        numTerminateMessages += static_cast<vtkm::Id>(m.second[1]);
+    }
+  }
+#endif
+}
+
+
+#ifdef VTKM_ENABLE_MPI
+
+VTKM_CONT
+template <typename ParticleType>
+void ParticleMessenger<ParticleType>::RegisterMessages(int msgSz, int nParticles, int numBlockIds)
+{
+  //Determine buffer size for msg and particle tags.
+  std::size_t messageBuffSz = CalcMessageBufferSize(msgSz + 1);
+  std::size_t particleBuffSz = CalcParticleBufferSize(nParticles, numBlockIds);
+
+  int numRecvs = std::min(64, this->GetNumRanks() - 1);
+
+  this->RegisterTag(ParticleMessenger::MESSAGE_TAG, numRecvs, messageBuffSz);
+  this->RegisterTag(ParticleMessenger::PARTICLE_TAG, numRecvs, particleBuffSz);
+
+  this->InitializeBuffers();
+}
+
+VTKM_CONT
+template <typename ParticleType>
+void ParticleMessenger<ParticleType>::SendMsg(int dst, const std::vector<int>& msg)
+{
+  vtkmdiy::MemoryBuffer buff;
+
+  //Write data.
+  vtkmdiy::save(buff, this->GetRank());
+  vtkmdiy::save(buff, msg);
+  this->SendData(dst, ParticleMessenger::MESSAGE_TAG, buff);
+}
+
+VTKM_CONT
+template <typename ParticleType>
+void ParticleMessenger<ParticleType>::SendAllMsg(const std::vector<int>& msg)
+{
+  for (int i = 0; i < this->GetNumRanks(); i++)
+    if (i != this->GetRank())
+      this->SendMsg(i, msg);
+}
+
+VTKM_CONT
+template <typename ParticleType>
+bool ParticleMessenger<ParticleType>::RecvAny(std::vector<MsgCommType>* msgs,
+                                              std::vector<ParticleRecvCommType>* recvParticles,
+                                              bool blockAndWait)
+{
+  std::set<int> tags;
+  if (msgs)
+  {
+    tags.insert(ParticleMessenger::MESSAGE_TAG);
+    msgs->resize(0);
+  }
+  if (recvParticles)
+  {
+    tags.insert(ParticleMessenger::PARTICLE_TAG);
+    recvParticles->resize(0);
+  }
+
+  if (tags.empty())
+    return false;
+
+  std::vector<std::pair<int, vtkmdiy::MemoryBuffer>> buffers;
+  if (!this->RecvData(tags, buffers, blockAndWait))
+    return false;
+
+  for (auto& buff : buffers)
+  {
+    if (buff.first == ParticleMessenger::MESSAGE_TAG)
+    {
+      int sendRank;
+      std::vector<int> m;
+      vtkmdiy::load(buff.second, sendRank);
+      vtkmdiy::load(buff.second, m);
+      msgs->push_back(std::make_pair(sendRank, m));
+    }
+    else if (buff.first == ParticleMessenger::PARTICLE_TAG)
+    {
+      int sendRank;
+      std::vector<ParticleCommType> particles;
+
+      vtkmdiy::load(buff.second, sendRank);
+      vtkmdiy::load(buff.second, particles);
+      recvParticles->push_back(std::make_pair(sendRank, particles));
+    }
+  }
+
+  return true;
+}
+
 VTKM_CONT
 template <typename ParticleType>
 template <typename P, template <typename, typename> class Container, typename Allocator>
@@ -146,6 +361,4 @@ inline void ParticleMessenger<ParticleType>::SendParticles(
 }
 } // namespace vtkm::filter::particleadvection
 
-#include <vtkm/filter/particleadvection/ParticleMessenger.cxx>
-
 #endif

From ccdba3598e43ec7ac40ecc15246965239dfe1e89 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 20 Jul 2022 14:14:48 -0400
Subject: [PATCH 035/104] Use std::shared_ptr for DSI

---
 .../NewFilterParticleAdvectionSteadyState.h   |  9 ++++----
 .../NewFilterParticleAdvectionUnsteadyState.h | 23 ++++++++++---------
 .../particleadvection/AdvectAlgorithm.h       | 10 ++++----
 .../AdvectAlgorithmThreaded.h                 |  6 ++---
 .../particleadvection/ParticleAdvector.h      |  4 ++--
 5 files changed, 27 insertions(+), 25 deletions(-)

diff --git a/vtkm/filter/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
index 1f84d1fe8..4bc9f2c2c 100644
--- a/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
@@ -28,7 +28,8 @@ public:
   }
 
 protected:
-  VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegratorSteadyState*>
+  VTKM_CONT
+  std::vector<std::shared_ptr<vtkm::filter::particleadvection::DataSetIntegratorSteadyState>>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
                            const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
   {
@@ -36,7 +37,7 @@ protected:
 
     std::string activeField = this->GetActiveFieldName();
 
-    std::vector<DSIType*> dsi;
+    std::vector<std::shared_ptr<DSIType>> dsi;
     for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
     {
       vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
@@ -44,8 +45,8 @@ protected:
       if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-      dsi.push_back(new DSIType(
-        ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
+      dsi.push_back(std::shared_ptr<DSIType>(new DSIType(
+        ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType)));
     }
 
     return dsi;
diff --git a/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h
index 93d426a16..2642d2440 100644
--- a/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h
@@ -41,7 +41,8 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("PreviousTime must be less than NextTime");
   }
 
-  VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState*>
+  VTKM_CONT
+  std::vector<std::shared_ptr<vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState>>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
                            const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
   {
@@ -49,7 +50,7 @@ protected:
 
     std::string activeField = this->GetActiveFieldName();
 
-    std::vector<DSIType*> dsi;
+    std::vector<std::shared_ptr<DSIType>> dsi;
     for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
     {
       vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
@@ -59,15 +60,15 @@ protected:
           (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-      dsi.push_back(new DSIType(ds1,
-                                ds2,
-                                this->Time1,
-                                this->Time2,
-                                blockId,
-                                activeField,
-                                this->SolverType,
-                                this->VecFieldType,
-                                this->ResultType));
+      dsi.push_back(std::shared_ptr<DSIType>(new DSIType(ds1,
+                                                         ds2,
+                                                         this->Time1,
+                                                         this->Time2,
+                                                         blockId,
+                                                         activeField,
+                                                         this->SolverType,
+                                                         this->VecFieldType,
+                                                         this->ResultType)));
     }
 
     return dsi;
diff --git a/vtkm/filter/particleadvection/AdvectAlgorithm.h b/vtkm/filter/particleadvection/AdvectAlgorithm.h
index ba544045e..7af243707 100644
--- a/vtkm/filter/particleadvection/AdvectAlgorithm.h
+++ b/vtkm/filter/particleadvection/AdvectAlgorithm.h
@@ -29,7 +29,7 @@ class AdvectAlgorithm
 {
 public:
   AdvectAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                  std::vector<DSIType*>& blocks)
+                  std::vector<std::shared_ptr<DSIType>>& blocks)
     : Blocks(blocks)
     , BoundsMap(bm)
     , NumRanks(this->Comm.size())
@@ -54,7 +54,7 @@ public:
     for (const auto& b : this->Blocks)
     {
       vtkm::cont::DataSet ds;
-      if (b->template GetOutput<ParticleType>(ds))
+      if (b.get()->template GetOutput<ParticleType>(ds))
         output.AppendPartition(ds);
     }
 
@@ -141,8 +141,8 @@ public:
   DataSetIntegrator* GetDataSet(vtkm::Id id)
   {
     for (auto& it : this->Blocks)
-      if (it->GetID() == id)
-        return it;
+      if (it.get()->GetID() == id)
+        return it.get();
 
     throw vtkm::cont::ErrorFilterExecution("Bad block");
   }
@@ -265,7 +265,7 @@ public:
 
   //Member data
   std::vector<ParticleType> Active;
-  std::vector<DSIType*> Blocks;
+  std::vector<std::shared_ptr<DSIType>> Blocks;
   vtkm::filter::particleadvection::BoundsMap BoundsMap;
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
   std::vector<ParticleType> Inactive;
diff --git a/vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h b/vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h
index 998e6466f..6eb2a48a8 100644
--- a/vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h
+++ b/vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h
@@ -31,7 +31,7 @@ class AdvectAlgorithmThreaded : public AdvectAlgorithm<DSIType, ResultType, Part
 {
 public:
   AdvectAlgorithmThreaded(const vtkm::filter::particleadvection::BoundsMap& bm,
-                          std::vector<DSIType*>& blocks)
+                          std::vector<std::shared_ptr<DSIType>>& blocks)
     : AdvectAlgorithm<DSIType, ResultType, ParticleType>(bm, blocks)
     , Done(false)
     , WorkerActivate(false)
@@ -39,8 +39,8 @@ public:
     //For threaded algorithm, the particles go out of scope in the Work method.
     //When this happens, they are destructed by the time the Manage thread gets them.
     //Set the copy flag so the std::vector is copied into the ArrayHandle
-    for (auto block : this->Blocks)
-      block->SetCopySeedFlag(true);
+    for (auto& block : this->Blocks)
+      block.get()->SetCopySeedFlag(true);
   }
 
   void Go() override
diff --git a/vtkm/filter/particleadvection/ParticleAdvector.h b/vtkm/filter/particleadvection/ParticleAdvector.h
index 979451ad5..833cea67d 100644
--- a/vtkm/filter/particleadvection/ParticleAdvector.h
+++ b/vtkm/filter/particleadvection/ParticleAdvector.h
@@ -28,7 +28,7 @@ class ParticleAdvector
 {
 public:
   ParticleAdvector(const vtkm::filter::particleadvection::BoundsMap& bm,
-                   const std::vector<DSIType*> blocks,
+                   const std::vector<std::shared_ptr<DSIType>> blocks,
                    const bool& useThreaded,
                    const vtkm::filter::particleadvection::ParticleAdvectionResultType& parType)
     : Blocks(blocks)
@@ -108,7 +108,7 @@ private:
   }
 
 
-  std::vector<DSIType*> Blocks;
+  std::vector<std::shared_ptr<DSIType>> Blocks;
   vtkm::filter::particleadvection::BoundsMap BoundsMap;
   ParticleAdvectionResultType ResultType;
   bool UseThreadedAlgorithm;

From 292f7017cf25a3450edc683c8339a6593605d603 Mon Sep 17 00:00:00 2001
From: Li-Ta Lo <ollie@lanl.gov>
Date: Thu, 21 Jul 2022 08:25:52 -0600
Subject: [PATCH 036/104] move Probe::DoMapField into a free function

---
 vtkm/filter/resampling/Probe.cxx | 51 ++++++++++++++++++--------------
 vtkm/filter/resampling/Probe.h   |  9 ------
 2 files changed, 29 insertions(+), 31 deletions(-)

diff --git a/vtkm/filter/resampling/Probe.cxx b/vtkm/filter/resampling/Probe.cxx
index c492d5088..7fc1c1dd9 100644
--- a/vtkm/filter/resampling/Probe.cxx
+++ b/vtkm/filter/resampling/Probe.cxx
@@ -19,34 +19,21 @@ namespace filter
 {
 namespace resampling
 {
-vtkm::cont::DataSet Probe::DoExecute(const vtkm::cont::DataSet& input)
+
+namespace
 {
-  vtkm::worklet::Probe worklet;
-  worklet.Run(input.GetCellSet(),
-              input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex()),
-              this->Geometry.GetCoordinateSystem().GetData());
 
-  auto mapper = [&](auto& outDataSet, const auto& f) { this->DoMapField(outDataSet, f, worklet); };
-  auto output = this->CreateResult(
-    input, this->Geometry.GetCellSet(), this->Geometry.GetCoordinateSystems(), mapper);
-  output.AddField(vtkm::cont::make_FieldPoint("HIDDEN", worklet.GetHiddenPointsField()));
-  output.AddField(
-    vtkm::cont::make_FieldCell("HIDDEN", worklet.GetHiddenCellsField(output.GetCellSet())));
-
-  return output;
-}
-
-
-bool Probe::DoMapField(vtkm::cont::DataSet& result,
-                       const vtkm::cont::Field& field,
-                       const vtkm::worklet::Probe& worklet)
+bool DoMapField(vtkm::cont::DataSet& result,
+                const vtkm::cont::Field& field,
+                const vtkm::worklet::Probe& worklet,
+                vtkm::Float64 InvalidValue)
 {
   if (field.IsFieldPoint())
   {
     auto resolve = [&](const auto& concrete) {
       using T = typename std::decay_t<decltype(concrete)>::ValueType;
       vtkm::cont::ArrayHandle<T> outputArray = worklet.ProcessPointField(
-        concrete, vtkm::cont::internal::CastInvalidValue<T>(this->InvalidValue));
+        concrete, vtkm::cont::internal::CastInvalidValue<T>(InvalidValue));
       result.AddPointField(field.GetName(), outputArray);
     };
     field.GetData()
@@ -57,8 +44,7 @@ bool Probe::DoMapField(vtkm::cont::DataSet& result,
   else if (field.IsFieldCell())
   {
     vtkm::cont::Field outField;
-    if (vtkm::filter::MapFieldPermutation(
-          field, worklet.GetCellIds(), outField, this->InvalidValue))
+    if (vtkm::filter::MapFieldPermutation(field, worklet.GetCellIds(), outField, InvalidValue))
     {
       // output field should be associated with points
       outField = vtkm::cont::Field(
@@ -78,6 +64,27 @@ bool Probe::DoMapField(vtkm::cont::DataSet& result,
     return false;
   }
 }
+} // anonymous namespace
+
+vtkm::cont::DataSet Probe::DoExecute(const vtkm::cont::DataSet& input)
+{
+  vtkm::worklet::Probe worklet;
+  worklet.Run(input.GetCellSet(),
+              input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex()),
+              this->Geometry.GetCoordinateSystem().GetData());
+
+  auto mapper = [&](auto& outDataSet, const auto& f) {
+    DoMapField(outDataSet, f, worklet, this->InvalidValue);
+  };
+  auto output = this->CreateResult(
+    input, this->Geometry.GetCellSet(), this->Geometry.GetCoordinateSystems(), mapper);
+  output.AddField(vtkm::cont::make_FieldPoint("HIDDEN", worklet.GetHiddenPointsField()));
+  output.AddField(
+    vtkm::cont::make_FieldCell("HIDDEN", worklet.GetHiddenCellsField(output.GetCellSet())));
+
+  return output;
+}
+
 } // namespace resampling
 } // namespace filter
 } // namespace vtkm
diff --git a/vtkm/filter/resampling/Probe.h b/vtkm/filter/resampling/Probe.h
index 01291c6fd..92df9f48b 100644
--- a/vtkm/filter/resampling/Probe.h
+++ b/vtkm/filter/resampling/Probe.h
@@ -15,11 +15,6 @@
 
 namespace vtkm
 {
-namespace worklet
-{
-class Probe;
-}
-
 namespace filter
 {
 namespace resampling
@@ -43,10 +38,6 @@ public:
 private:
   VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
 
-  bool DoMapField(vtkm::cont::DataSet& result,
-                  const vtkm::cont::Field& field,
-                  const vtkm::worklet::Probe& worklet);
-
   vtkm::cont::DataSet Geometry;
 
   vtkm::Float64 InvalidValue = vtkm::Nan64();

From cc41309cfc5d008ca84fab169dc16ca43c23d615 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 22 Jul 2022 12:00:22 -0400
Subject: [PATCH 037/104] Move all into flow dir.

---
 vtkm/filter/CMakeLists.txt                    | 35 +-----------
 .../AdvectAlgorithm.h                         | 16 +++---
 .../AdvectAlgorithmThreaded.h                 | 12 ++---
 .../{particleadvection => flow}/BoundsMap.h   |  0
 vtkm/filter/flow/CMakeLists.txt               | 54 +++++++++++++++++++
 .../DataSetIntegrator.h                       |  4 +-
 .../DataSetIntegratorSteadyState.h            |  2 +-
 .../DataSetIntegratorUnsteadyState.h          |  2 +-
 .../{particleadvection => flow}/Messenger.cxx |  2 +-
 .../{particleadvection => flow}/Messenger.h   |  4 +-
 .../{ => flow}/NewFilterParticleAdvection.h   | 14 ++---
 .../NewFilterParticleAdvectionSteadyState.h   | 11 ++--
 .../NewFilterParticleAdvectionUnsteadyState.h | 36 +++++++------
 .../ParticleAdvection.cxx}                    | 13 ++---
 vtkm/filter/{ => flow}/ParticleAdvection.h    | 12 ++---
 .../ParticleAdvectionAlgorithm.h              |  0
 .../ParticleAdvectionTypes.h                  |  0
 .../ParticleAdvector.h                        | 12 ++---
 .../ParticleMessenger.h                       |  8 ++-
 .../PathParticle.cxx}                         | 13 ++---
 vtkm/filter/{ => flow}/PathParticle.h         | 12 ++---
 .../{Pathline.hxx => flow/Pathline.cxx}       | 15 +++---
 vtkm/filter/{ => flow}/Pathline.h             | 12 ++---
 .../{Streamline.hxx => flow/Streamline.cxx}   | 15 +++---
 vtkm/filter/{ => flow}/Streamline.h           | 14 +++--
 vtkm/filter/particleadvection/CMakeLists.txt  | 25 ---------
 vtkm/filter/testing/RenderTestStreamline.cxx  |  2 +-
 .../testing/UnitTestStreamlineFilter.cxx      |  8 +--
 .../testing/UnitTestStreamlineFilterMPI.cxx   |  6 +--
 29 files changed, 166 insertions(+), 193 deletions(-)
 rename vtkm/filter/{particleadvection => flow}/AdvectAlgorithm.h (95%)
 rename vtkm/filter/{particleadvection => flow}/AdvectAlgorithmThreaded.h (94%)
 rename vtkm/filter/{particleadvection => flow}/BoundsMap.h (100%)
 create mode 100644 vtkm/filter/flow/CMakeLists.txt
 rename vtkm/filter/{particleadvection => flow}/DataSetIntegrator.h (99%)
 rename vtkm/filter/{particleadvection => flow}/DataSetIntegratorSteadyState.h (99%)
 rename vtkm/filter/{particleadvection => flow}/DataSetIntegratorUnsteadyState.h (99%)
 rename vtkm/filter/{particleadvection => flow}/Messenger.cxx (99%)
 rename vtkm/filter/{particleadvection => flow}/Messenger.h (97%)
 rename vtkm/filter/{ => flow}/NewFilterParticleAdvection.h (90%)
 rename vtkm/filter/{ => flow}/NewFilterParticleAdvectionSteadyState.h (85%)
 rename vtkm/filter/{ => flow}/NewFilterParticleAdvectionUnsteadyState.h (65%)
 rename vtkm/filter/{ParticleAdvection.hxx => flow/ParticleAdvection.cxx} (74%)
 rename vtkm/filter/{ => flow}/ParticleAdvection.h (79%)
 rename vtkm/filter/{particleadvection => flow}/ParticleAdvectionAlgorithm.h (100%)
 rename vtkm/filter/{particleadvection => flow}/ParticleAdvectionTypes.h (100%)
 rename vtkm/filter/{particleadvection => flow}/ParticleAdvector.h (91%)
 rename vtkm/filter/{particleadvection => flow}/ParticleMessenger.h (97%)
 rename vtkm/filter/{PathParticle.hxx => flow/PathParticle.cxx} (75%)
 rename vtkm/filter/{ => flow}/PathParticle.h (79%)
 rename vtkm/filter/{Pathline.hxx => flow/Pathline.cxx} (72%)
 rename vtkm/filter/{ => flow}/Pathline.h (80%)
 rename vtkm/filter/{Streamline.hxx => flow/Streamline.cxx} (70%)
 rename vtkm/filter/{ => flow}/Streamline.h (75%)
 delete mode 100644 vtkm/filter/particleadvection/CMakeLists.txt

diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index b8306e071..274cc72d5 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -76,8 +76,6 @@ set(common_headers
   FilterDataSetWithField.h
   FilterField.h
   Filter.h
-  FilterParticleAdvection.h
-  FilterTemporalParticleAdvection.h
   FilterTraits.h
   PolicyBase.h
   PolicyDefault.h
@@ -90,8 +88,6 @@ set(common_header_template_sources
   FilterDataSetWithField.hxx
   FilterField.hxx
   Filter.hxx
-  FilterParticleAdvection.hxx
-  FilterTemporalParticleAdvection.hxx
   )
 
 vtkm_declare_headers(${common_header_template_sources})
@@ -104,10 +100,6 @@ set(extra_headers
   Lagrangian.h
   LagrangianStructures.h
   MIRFilter.h
-  ParticleAdvection.h
-  Pathline.h
-  PathParticle.h
-  Streamline.h
   StreamSurface.h
   )
 
@@ -119,24 +111,13 @@ set(extra_header_template_sources
   Lagrangian.hxx
   LagrangianStructures.hxx
   MIRFilter.hxx
-  ParticleAdvection.hxx
-  Pathline.hxx
-  PathParticle.hxx
-  Streamline.hxx
   StreamSurface.hxx
   )
 
-set(extra_sources_device
-  particleadvection/Messenger.cxx
-  )
-
 set(core_headers
   FieldSelection.h
   NewFilter.h
   NewFilterField.h
-  NewFilterParticleAdvection.h
-  NewFilterParticleAdvectionSteadyState.h
-  NewFilterParticleAdvectionUnsteadyState.h
   MapFieldMergeAverage.h
   MapFieldPermutation.h
   TaskQueue.h
@@ -160,30 +141,16 @@ vtkm_library(
 
 add_library(vtkm_filter INTERFACE)
 
-vtkm_library(
-  NAME vtkm_filter_extra
-  TEMPLATE_SOURCES ${extra_header_template_sources}
-  HEADERS ${extra_headers}
-  DEVICE_SOURCES ${extra_sources_device}
-  USE_VTKM_JOB_POOL
-)
-
 set_target_properties(
   vtkm_filter_core
-  vtkm_filter_extra
   PROPERTIES
   UNITY_BUILD ON
   UNITY_BUILD_MODE BATCH
 )
 
 target_link_libraries(vtkm_filter_core PUBLIC vtkm_cont vtkm_worklet)
-target_link_libraries(vtkm_filter_extra PUBLIC vtkm_cont vtkm_worklet)
-if (VTKm_ENABLE_MPI)
-  target_link_libraries(vtkm_filter_extra PUBLIC MPI::MPI_CXX)
-endif()
 
 target_link_libraries(vtkm_filter PUBLIC INTERFACE
-  vtkm_filter_extra
   vtkm_filter_core
   )
 
@@ -194,9 +161,9 @@ add_subdirectory(connected_components)
 add_subdirectory(contour)
 add_subdirectory(density_estimate)
 add_subdirectory(entity_extraction)
+add_subdirectory(flow)
 add_subdirectory(image_processing)
 add_subdirectory(internal)
-add_subdirectory(particleadvection)
 add_subdirectory(field_conversion)
 add_subdirectory(field_transform)
 add_subdirectory(geometry_refinement)
diff --git a/vtkm/filter/particleadvection/AdvectAlgorithm.h b/vtkm/filter/flow/AdvectAlgorithm.h
similarity index 95%
rename from vtkm/filter/particleadvection/AdvectAlgorithm.h
rename to vtkm/filter/flow/AdvectAlgorithm.h
index 7af243707..a7367db4f 100644
--- a/vtkm/filter/particleadvection/AdvectAlgorithm.h
+++ b/vtkm/filter/flow/AdvectAlgorithm.h
@@ -12,9 +12,9 @@
 #define vtk_m_filter_AdvectAlgorithm_h
 
 #include <vtkm/cont/PartitionedDataSet.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleMessenger.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/DataSetIntegrator.h>
+#include <vtkm/filter/flow/ParticleMessenger.h>
 
 
 namespace vtkm
@@ -29,7 +29,7 @@ class AdvectAlgorithm
 {
 public:
   AdvectAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                  std::vector<std::shared_ptr<DSIType>>& blocks)
+                  std::vector<DSIType*>& blocks)
     : Blocks(blocks)
     , BoundsMap(bm)
     , NumRanks(this->Comm.size())
@@ -54,7 +54,7 @@ public:
     for (const auto& b : this->Blocks)
     {
       vtkm::cont::DataSet ds;
-      if (b.get()->template GetOutput<ParticleType>(ds))
+      if (b->template GetOutput<ParticleType>(ds))
         output.AppendPartition(ds);
     }
 
@@ -141,8 +141,8 @@ public:
   DataSetIntegrator* GetDataSet(vtkm::Id id)
   {
     for (auto& it : this->Blocks)
-      if (it.get()->GetID() == id)
-        return it.get();
+      if (it->GetID() == id)
+        return it;
 
     throw vtkm::cont::ErrorFilterExecution("Bad block");
   }
@@ -265,7 +265,7 @@ public:
 
   //Member data
   std::vector<ParticleType> Active;
-  std::vector<std::shared_ptr<DSIType>> Blocks;
+  std::vector<DSIType*> Blocks;
   vtkm::filter::particleadvection::BoundsMap BoundsMap;
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
   std::vector<ParticleType> Inactive;
diff --git a/vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h b/vtkm/filter/flow/AdvectAlgorithmThreaded.h
similarity index 94%
rename from vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h
rename to vtkm/filter/flow/AdvectAlgorithmThreaded.h
index 6eb2a48a8..e23756575 100644
--- a/vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h
+++ b/vtkm/filter/flow/AdvectAlgorithmThreaded.h
@@ -12,10 +12,10 @@
 #define vtk_m_filter_AdvectAlgorithmThreaded_h
 
 #include <vtkm/cont/PartitionedDataSet.h>
-#include <vtkm/filter/particleadvection/AdvectAlgorithm.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleMessenger.h>
+#include <vtkm/filter/flow/AdvectAlgorithm.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/DataSetIntegrator.h>
+#include <vtkm/filter/flow/ParticleMessenger.h>
 
 #include <thread>
 
@@ -31,7 +31,7 @@ class AdvectAlgorithmThreaded : public AdvectAlgorithm<DSIType, ResultType, Part
 {
 public:
   AdvectAlgorithmThreaded(const vtkm::filter::particleadvection::BoundsMap& bm,
-                          std::vector<std::shared_ptr<DSIType>>& blocks)
+                          std::vector<DSIType*>& blocks)
     : AdvectAlgorithm<DSIType, ResultType, ParticleType>(bm, blocks)
     , Done(false)
     , WorkerActivate(false)
@@ -40,7 +40,7 @@ public:
     //When this happens, they are destructed by the time the Manage thread gets them.
     //Set the copy flag so the std::vector is copied into the ArrayHandle
     for (auto& block : this->Blocks)
-      block.get()->SetCopySeedFlag(true);
+      block->SetCopySeedFlag(true);
   }
 
   void Go() override
diff --git a/vtkm/filter/particleadvection/BoundsMap.h b/vtkm/filter/flow/BoundsMap.h
similarity index 100%
rename from vtkm/filter/particleadvection/BoundsMap.h
rename to vtkm/filter/flow/BoundsMap.h
diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
new file mode 100644
index 000000000..5226a77e3
--- /dev/null
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -0,0 +1,54 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##============================================================================
+set(flow_headers
+  AdvectAlgorithm.h
+  AdvectAlgorithmThreaded.h
+  BoundsMap.h
+  DataSetIntegrator.h
+  DataSetIntegratorSteadyState.h
+  DataSetIntegratorUnsteadyState.h
+  Messenger.h
+  NewFilterParticleAdvection.h
+  NewFilterParticleAdvectionSteadyState.h
+  NewFilterParticleAdvectionUnsteadyState.h
+  ParticleAdvectionAlgorithm.h
+  ParticleAdvectionTypes.h
+  ParticleAdvector.h
+  ParticleMessenger.h
+  ParticleAdvection.h
+  Pathline.h
+  PathParticle.h
+  Streamline.h
+  )
+
+set(flow_sources
+  Messenger.cxx
+  ParticleAdvection.cxx
+  Pathline.cxx
+  PathParticle.cxx
+  Streamline.cxx
+  )
+
+vtkm_library(
+  NAME vtkm_filter_flow
+  HEADERS ${flow_headers}
+  DEVICE_SOURCES ${flow_sources}
+  USE_VTKM_JOB_POOL
+)
+
+target_link_libraries(vtkm_filter_flow PUBLIC vtkm_worklet vtkm_filter_core)
+target_link_libraries(vtkm_filter PUBLIC INTERFACE vtkm_filter_flow)
+
+#add_subdirectory(worklet)
+
+#-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
+#if (VTKm_ENABLE_TESTING)
+#  add_subdirectory(testing)
+#endif ()
diff --git a/vtkm/filter/particleadvection/DataSetIntegrator.h b/vtkm/filter/flow/DataSetIntegrator.h
similarity index 99%
rename from vtkm/filter/particleadvection/DataSetIntegrator.h
rename to vtkm/filter/flow/DataSetIntegrator.h
index ace3eb91a..eadda65ae 100644
--- a/vtkm/filter/particleadvection/DataSetIntegrator.h
+++ b/vtkm/filter/flow/DataSetIntegrator.h
@@ -14,8 +14,8 @@
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/cont/ParticleArrayCopy.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
 #include <vtkm/worklet/ParticleAdvection.h>
 #include <vtkm/worklet/particleadvection/EulerIntegrator.h>
 #include <vtkm/worklet/particleadvection/IntegratorStatus.h>
diff --git a/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h b/vtkm/filter/flow/DataSetIntegratorSteadyState.h
similarity index 99%
rename from vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h
rename to vtkm/filter/flow/DataSetIntegratorSteadyState.h
index fd47026c9..ad674be60 100644
--- a/vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h
+++ b/vtkm/filter/flow/DataSetIntegratorSteadyState.h
@@ -11,7 +11,7 @@
 #ifndef vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_h
 #define vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_h
 
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
+#include <vtkm/filter/flow/DataSetIntegrator.h>
 
 namespace vtkm
 {
diff --git a/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h b/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
similarity index 99%
rename from vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h
rename to vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
index 374375095..384018ac0 100644
--- a/vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h
+++ b/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
@@ -11,7 +11,7 @@
 #ifndef vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_h
 #define vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_h
 
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
+#include <vtkm/filter/flow/DataSetIntegrator.h>
 #include <vtkm/worklet/particleadvection/TemporalGridEvaluators.h>
 
 namespace vtkm
diff --git a/vtkm/filter/particleadvection/Messenger.cxx b/vtkm/filter/flow/Messenger.cxx
similarity index 99%
rename from vtkm/filter/particleadvection/Messenger.cxx
rename to vtkm/filter/flow/Messenger.cxx
index 86397c454..2dcade5ad 100644
--- a/vtkm/filter/particleadvection/Messenger.cxx
+++ b/vtkm/filter/flow/Messenger.cxx
@@ -12,7 +12,7 @@
 #include <sstream>
 #include <string.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/particleadvection/Messenger.h>
+#include <vtkm/filter/flow/Messenger.h>
 
 #ifdef VTKM_ENABLE_MPI
 #include <vtkm/thirdparty/diy/mpi-cast.h>
diff --git a/vtkm/filter/particleadvection/Messenger.h b/vtkm/filter/flow/Messenger.h
similarity index 97%
rename from vtkm/filter/particleadvection/Messenger.h
rename to vtkm/filter/flow/Messenger.h
index a9443961e..8d5bff416 100644
--- a/vtkm/filter/particleadvection/Messenger.h
+++ b/vtkm/filter/flow/Messenger.h
@@ -11,8 +11,6 @@
 #ifndef vtk_m_filter_Messenger_h
 #define vtk_m_filter_Messenger_h
 
-#include <vtkm/filter/vtkm_filter_extra_export.h>
-
 #include <vtkm/Types.h>
 #include <vtkm/cont/Serialization.h>
 #include <vtkm/thirdparty/diy/diy.h>
@@ -33,7 +31,7 @@ namespace filter
 namespace particleadvection
 {
 
-class VTKM_FILTER_EXTRA_EXPORT Messenger
+class Messenger
 {
 public:
   VTKM_CONT Messenger(vtkmdiy::mpi::communicator& comm);
diff --git a/vtkm/filter/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
similarity index 90%
rename from vtkm/filter/NewFilterParticleAdvection.h
rename to vtkm/filter/flow/NewFilterParticleAdvection.h
index b8cec2bde..06089321f 100644
--- a/vtkm/filter/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -13,11 +13,11 @@
 
 #include <vtkm/Particle.h>
 #include <vtkm/filter/NewFilterField.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h>
-#include <vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/DataSetIntegrator.h>
+#include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
+#include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
 
 namespace vtkm
 {
@@ -35,8 +35,8 @@ public:
 
   VTKM_CONT
   NewFilterParticleAdvection(vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
-    : vtkm::filter::NewFilterField()
-    , NumberOfSteps(0)
+    //    : vtkm::filter::NewFilterField()
+    : NumberOfSteps(0)
     , ResultType(rType)
     , SolverType(vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE)
     , StepSize(0)
diff --git a/vtkm/filter/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
similarity index 85%
rename from vtkm/filter/NewFilterParticleAdvectionSteadyState.h
rename to vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index 4bc9f2c2c..317243bfe 100644
--- a/vtkm/filter/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -11,7 +11,7 @@
 #ifndef vtk_m_filter_NewFilterParticleAdvectionSteadyState_h
 #define vtk_m_filter_NewFilterParticleAdvectionSteadyState_h
 
-#include <vtkm/filter/NewFilterParticleAdvection.h>
+#include <vtkm/filter/flow/NewFilterParticleAdvection.h>
 
 namespace vtkm
 {
@@ -28,8 +28,7 @@ public:
   }
 
 protected:
-  VTKM_CONT
-  std::vector<std::shared_ptr<vtkm::filter::particleadvection::DataSetIntegratorSteadyState>>
+  VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegratorSteadyState*>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
                            const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
   {
@@ -37,7 +36,7 @@ protected:
 
     std::string activeField = this->GetActiveFieldName();
 
-    std::vector<std::shared_ptr<DSIType>> dsi;
+    std::vector<DSIType*> dsi;
     for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
     {
       vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
@@ -45,8 +44,8 @@ protected:
       if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-      dsi.push_back(std::shared_ptr<DSIType>(new DSIType(
-        ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType)));
+      dsi.push_back(new DSIType(
+        ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
     }
 
     return dsi;
diff --git a/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
similarity index 65%
rename from vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h
rename to vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index 2642d2440..beb507d54 100644
--- a/vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -11,7 +11,7 @@
 #ifndef vtk_m_filter_NewFilterParticleAdvectionUnsteadyState_h
 #define vtk_m_filter_NewFilterParticleAdvectionUnsteadyState_h
 
-#include <vtkm/filter/NewFilterParticleAdvection.h>
+#include <vtkm/filter/flow/NewFilterParticleAdvection.h>
 
 namespace vtkm
 {
@@ -28,10 +28,13 @@ public:
   {
   }
 
-  void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
-  void SetNextTime(vtkm::FloatDefault t2) { this->Time2 = t2; }
-  void SetNextDataSet(const vtkm::cont::DataSet& ds) { this->Input2 = { ds }; }
-  void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->Input2 = pds; }
+  VTKM_CONT void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
+
+  VTKM_CONT void SetNextTime(vtkm::FloatDefault t2) { this->Time2 = t2; }
+
+  VTKM_CONT void SetNextDataSet(const vtkm::cont::DataSet& ds) { this->Input2 = { ds }; }
+
+  VTKM_CONT void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->Input2 = pds; }
 
 protected:
   VTKM_CONT virtual void ValidateOptions() const override
@@ -41,8 +44,7 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("PreviousTime must be less than NextTime");
   }
 
-  VTKM_CONT
-  std::vector<std::shared_ptr<vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState>>
+  VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState*>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
                            const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
   {
@@ -50,7 +52,7 @@ protected:
 
     std::string activeField = this->GetActiveFieldName();
 
-    std::vector<std::shared_ptr<DSIType>> dsi;
+    std::vector<DSIType*> dsi;
     for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
     {
       vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
@@ -60,15 +62,15 @@ protected:
           (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-      dsi.push_back(std::shared_ptr<DSIType>(new DSIType(ds1,
-                                                         ds2,
-                                                         this->Time1,
-                                                         this->Time2,
-                                                         blockId,
-                                                         activeField,
-                                                         this->SolverType,
-                                                         this->VecFieldType,
-                                                         this->ResultType)));
+      dsi.push_back(new DSIType(ds1,
+                                ds2,
+                                this->Time1,
+                                this->Time2,
+                                blockId,
+                                activeField,
+                                this->SolverType,
+                                this->VecFieldType,
+                                this->ResultType));
     }
 
     return dsi;
diff --git a/vtkm/filter/ParticleAdvection.hxx b/vtkm/filter/flow/ParticleAdvection.cxx
similarity index 74%
rename from vtkm/filter/ParticleAdvection.hxx
rename to vtkm/filter/flow/ParticleAdvection.cxx
index c640696ff..88e63ca09 100644
--- a/vtkm/filter/ParticleAdvection.hxx
+++ b/vtkm/filter/flow/ParticleAdvection.cxx
@@ -7,16 +7,14 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-#ifndef vtk_m_filter_ParticleAdvection_hxx
-#define vtk_m_filter_ParticleAdvection_hxx
 
 #include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/ParticleAdvection.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/ParticleAdvection.h>
 
-#include <vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-#include <vtkm/filter/particleadvection/ParticleAdvector.h>
+#include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -40,4 +38,3 @@ VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection::DoExecutePartitions(
 
 }
 } // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/ParticleAdvection.h b/vtkm/filter/flow/ParticleAdvection.h
similarity index 79%
rename from vtkm/filter/ParticleAdvection.h
rename to vtkm/filter/flow/ParticleAdvection.h
index e4270dfd9..b9f4a4c6c 100644
--- a/vtkm/filter/ParticleAdvection.h
+++ b/vtkm/filter/flow/ParticleAdvection.h
@@ -12,8 +12,9 @@
 #define vtk_m_filter_ParticleAdvection_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterParticleAdvectionSteadyState.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
 {
@@ -24,7 +25,8 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class ParticleAdvection : public vtkm::filter::NewFilterParticleAdvectionSteadyState
+class VTKM_FILTER_FLOW_EXPORT ParticleAdvection
+  : public vtkm::filter::NewFilterParticleAdvectionSteadyState
 {
 public:
   VTKM_CONT ParticleAdvection()
@@ -41,8 +43,4 @@ protected:
 }
 } // namespace vtkm::filter
 
-#ifndef vtk_m_filter_ParticleAdvection_hxx
-#include <vtkm/filter/ParticleAdvection.hxx>
-#endif
-
 #endif // vtk_m_filter_ParticleAdvection_h
diff --git a/vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h b/vtkm/filter/flow/ParticleAdvectionAlgorithm.h
similarity index 100%
rename from vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h
rename to vtkm/filter/flow/ParticleAdvectionAlgorithm.h
diff --git a/vtkm/filter/particleadvection/ParticleAdvectionTypes.h b/vtkm/filter/flow/ParticleAdvectionTypes.h
similarity index 100%
rename from vtkm/filter/particleadvection/ParticleAdvectionTypes.h
rename to vtkm/filter/flow/ParticleAdvectionTypes.h
diff --git a/vtkm/filter/particleadvection/ParticleAdvector.h b/vtkm/filter/flow/ParticleAdvector.h
similarity index 91%
rename from vtkm/filter/particleadvection/ParticleAdvector.h
rename to vtkm/filter/flow/ParticleAdvector.h
index 833cea67d..80fe96c3a 100644
--- a/vtkm/filter/particleadvection/ParticleAdvector.h
+++ b/vtkm/filter/flow/ParticleAdvector.h
@@ -11,10 +11,10 @@
 #ifndef vtk_m_filter_particleadvection_ParticleAdvector_h
 #define vtk_m_filter_particleadvection_ParticleAdvector_h
 
-#include <vtkm/filter/particleadvection/AdvectAlgorithm.h>
-#include <vtkm/filter/particleadvection/AdvectAlgorithmThreaded.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
+#include <vtkm/filter/flow/AdvectAlgorithm.h>
+#include <vtkm/filter/flow/AdvectAlgorithmThreaded.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/DataSetIntegrator.h>
 
 namespace vtkm
 {
@@ -28,7 +28,7 @@ class ParticleAdvector
 {
 public:
   ParticleAdvector(const vtkm::filter::particleadvection::BoundsMap& bm,
-                   const std::vector<std::shared_ptr<DSIType>> blocks,
+                   const std::vector<DSIType*> blocks,
                    const bool& useThreaded,
                    const vtkm::filter::particleadvection::ParticleAdvectionResultType& parType)
     : Blocks(blocks)
@@ -108,7 +108,7 @@ private:
   }
 
 
-  std::vector<std::shared_ptr<DSIType>> Blocks;
+  std::vector<DSIType*> Blocks;
   vtkm::filter::particleadvection::BoundsMap BoundsMap;
   ParticleAdvectionResultType ResultType;
   bool UseThreadedAlgorithm;
diff --git a/vtkm/filter/particleadvection/ParticleMessenger.h b/vtkm/filter/flow/ParticleMessenger.h
similarity index 97%
rename from vtkm/filter/particleadvection/ParticleMessenger.h
rename to vtkm/filter/flow/ParticleMessenger.h
index fc960777a..9c7cf2dcb 100644
--- a/vtkm/filter/particleadvection/ParticleMessenger.h
+++ b/vtkm/filter/flow/ParticleMessenger.h
@@ -11,12 +11,10 @@
 #ifndef vtk_m_filter_ParticleMessenger_h
 #define vtk_m_filter_ParticleMessenger_h
 
-#include <vtkm/filter/vtkm_filter_extra_export.h>
-
 #include <vtkm/Particle.h>
 #include <vtkm/cont/Serialization.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/Messenger.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/Messenger.h>
 
 #include <list>
 #include <map>
@@ -31,7 +29,7 @@ namespace particleadvection
 {
 
 template <typename ParticleType>
-class VTKM_FILTER_EXTRA_EXPORT ParticleMessenger : public vtkm::filter::particleadvection::Messenger
+class ParticleMessenger : public vtkm::filter::particleadvection::Messenger
 {
   //sendRank, message
   using MsgCommType = std::pair<int, std::vector<int>>;
diff --git a/vtkm/filter/PathParticle.hxx b/vtkm/filter/flow/PathParticle.cxx
similarity index 75%
rename from vtkm/filter/PathParticle.hxx
rename to vtkm/filter/flow/PathParticle.cxx
index c7d17ea14..00456cee4 100644
--- a/vtkm/filter/PathParticle.hxx
+++ b/vtkm/filter/flow/PathParticle.cxx
@@ -7,16 +7,14 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-#ifndef vtk_m_filter_PathParticle_hxx
-#define vtk_m_filter_PathParticle_hxx
 
 #include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/PathParticle.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/PathParticle.h>
 
-#include <vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-#include <vtkm/filter/particleadvection/ParticleAdvector.h>
+#include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -40,4 +38,3 @@ VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle::DoExecutePartitions(
 
 }
 } // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/PathParticle.h b/vtkm/filter/flow/PathParticle.h
similarity index 79%
rename from vtkm/filter/PathParticle.h
rename to vtkm/filter/flow/PathParticle.h
index 721e34d8b..51e6b00be 100644
--- a/vtkm/filter/PathParticle.h
+++ b/vtkm/filter/flow/PathParticle.h
@@ -12,8 +12,9 @@
 #define vtk_m_filter_PathParticle_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
 {
@@ -24,7 +25,8 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class PathParticle : public vtkm::filter::NewFilterParticleAdvectionUnsteadyState
+class VTKM_FILTER_FLOW_EXPORT PathParticle
+  : public vtkm::filter::NewFilterParticleAdvectionUnsteadyState
 {
 public:
   VTKM_CONT PathParticle()
@@ -41,8 +43,4 @@ protected:
 }
 } // namespace vtkm::filter
 
-#ifndef vtk_m_filter_PathParticle_hxx
-#include <vtkm/filter/PathParticle.hxx>
-#endif
-
 #endif // vtk_m_filter_PathParticle_h
diff --git a/vtkm/filter/Pathline.hxx b/vtkm/filter/flow/Pathline.cxx
similarity index 72%
rename from vtkm/filter/Pathline.hxx
rename to vtkm/filter/flow/Pathline.cxx
index d845a26ef..3369ab2bb 100644
--- a/vtkm/filter/Pathline.hxx
+++ b/vtkm/filter/flow/Pathline.cxx
@@ -7,17 +7,15 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-#ifndef vtk_m_filter_Pathline_hxx
-#define vtk_m_filter_Pathline_hxx
 
 #include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/Pathline.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionAlgorithm.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/ParticleAdvectionAlgorithm.h>
+#include <vtkm/filter/flow/Pathline.h>
 
-#include <vtkm/filter/particleadvection/DataSetIntegratorUnsteadyState.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-#include <vtkm/filter/particleadvection/ParticleAdvector.h>
+#include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -41,4 +39,3 @@ VTKM_CONT vtkm::cont::PartitionedDataSet Pathline::DoExecutePartitions(
 
 }
 } // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/Pathline.h b/vtkm/filter/flow/Pathline.h
similarity index 80%
rename from vtkm/filter/Pathline.h
rename to vtkm/filter/flow/Pathline.h
index 6cc141b82..fec35a425 100644
--- a/vtkm/filter/Pathline.h
+++ b/vtkm/filter/flow/Pathline.h
@@ -12,8 +12,9 @@
 #define vtk_m_filter_Pathline_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterParticleAdvectionUnsteadyState.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
 {
@@ -24,7 +25,8 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class Pathline : public vtkm::filter::NewFilterParticleAdvectionUnsteadyState
+class VTKM_FILTER_FLOW_EXPORT Pathline
+  : public vtkm::filter::NewFilterParticleAdvectionUnsteadyState
 {
 public:
   VTKM_CONT Pathline()
@@ -41,8 +43,4 @@ protected:
 }
 } // namespace vtkm::filter
 
-#ifndef vtk_m_filter_Pathline_hxx
-#include <vtkm/filter/Pathline.hxx>
-#endif
-
 #endif // vtk_m_filter_Pathline_h
diff --git a/vtkm/filter/Streamline.hxx b/vtkm/filter/flow/Streamline.cxx
similarity index 70%
rename from vtkm/filter/Streamline.hxx
rename to vtkm/filter/flow/Streamline.cxx
index e115d4a16..26a7b6308 100644
--- a/vtkm/filter/Streamline.hxx
+++ b/vtkm/filter/flow/Streamline.cxx
@@ -7,23 +7,21 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-#ifndef vtk_m_filter_Streamline_hxx
-#define vtk_m_filter_Streamline_hxx
 
 #include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/Streamline.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/Streamline.h>
 
-#include <vtkm/filter/particleadvection/DataSetIntegratorSteadyState.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-#include <vtkm/filter/particleadvection/ParticleAdvector.h>
+#include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/ParticleAdvector.h>
 
 namespace vtkm
 {
 namespace filter
 {
 
-VTKM_CONT inline vtkm::cont::PartitionedDataSet Streamline::DoExecutePartitions(
+VTKM_CONT vtkm::cont::PartitionedDataSet Streamline::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
   using DSIType = vtkm::filter::particleadvection::DataSetIntegratorSteadyState;
@@ -40,4 +38,3 @@ VTKM_CONT inline vtkm::cont::PartitionedDataSet Streamline::DoExecutePartitions(
 
 }
 } // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/Streamline.h b/vtkm/filter/flow/Streamline.h
similarity index 75%
rename from vtkm/filter/Streamline.h
rename to vtkm/filter/flow/Streamline.h
index 91396e8d5..f94893d6e 100644
--- a/vtkm/filter/Streamline.h
+++ b/vtkm/filter/flow/Streamline.h
@@ -12,8 +12,9 @@
 #define vtk_m_filter_Streamline_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/NewFilterParticleAdvectionSteadyState.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
 {
@@ -24,7 +25,8 @@ namespace filter
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
-class Streamline : public vtkm::filter::NewFilterParticleAdvectionSteadyState
+class VTKM_FILTER_FLOW_EXPORT Streamline
+  : public vtkm::filter::NewFilterParticleAdvectionSteadyState
 {
 public:
   VTKM_CONT Streamline()
@@ -34,15 +36,11 @@ public:
   }
 
 protected:
-  VTKM_CONT inline vtkm::cont::PartitionedDataSet DoExecutePartitions(
+  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
 };
 
 }
 } // namespace vtkm::filter
 
-#ifndef vtk_m_filter_Streamline_hxx
-#include <vtkm/filter/Streamline.hxx>
-#endif
-
 #endif // vtk_m_filter_Streamline_h
diff --git a/vtkm/filter/particleadvection/CMakeLists.txt b/vtkm/filter/particleadvection/CMakeLists.txt
deleted file mode 100644
index 3a67cd184..000000000
--- a/vtkm/filter/particleadvection/CMakeLists.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-##============================================================================
-##  Copyright (c) Kitware, Inc.
-##  All rights reserved.
-##  See LICENSE.txt for details.
-##
-##  This software is distributed WITHOUT ANY WARRANTY; without even
-##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-##  PURPOSE.  See the above copyright notice for more information.
-##============================================================================
-
-set(headers
-  BoundsMap.h
-  Messenger.h
-  ParticleMessenger.h
-  DataSetIntegrator.h
-  DataSetIntegratorSteadyState.h
-  DataSetIntegratorUnsteadyState.h
-  AdvectAlgorithm.h
-  AdvectAlgorithmThreaded.h
-  ParticleAdvector.h
-  ParticleAdvectionTypes.h
-)
-
-#-----------------------------------------------------------------------------
-vtkm_declare_headers(${headers})
diff --git a/vtkm/filter/testing/RenderTestStreamline.cxx b/vtkm/filter/testing/RenderTestStreamline.cxx
index 03f128ca4..84833f7c5 100644
--- a/vtkm/filter/testing/RenderTestStreamline.cxx
+++ b/vtkm/filter/testing/RenderTestStreamline.cxx
@@ -14,7 +14,7 @@
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/io/VTKDataSetReader.h>
 
-#include <vtkm/filter/Streamline.h>
+#include <vtkm/filter/flow/Streamline.h>
 #include <vtkm/filter/geometry_refinement/Tube.h>
 
 #include <vtkm/rendering/testing/RenderTest.h>
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index a182061e4..8e9110453 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -10,10 +10,10 @@
 
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
-#include <vtkm/filter/ParticleAdvection.h>
-#include <vtkm/filter/PathParticle.h>
-#include <vtkm/filter/Pathline.h>
-#include <vtkm/filter/Streamline.h>
+#include <vtkm/filter/flow/ParticleAdvection.h>
+#include <vtkm/filter/flow/PathParticle.h>
+#include <vtkm/filter/flow/Pathline.h>
+#include <vtkm/filter/flow/Streamline.h>
 #include <vtkm/io/VTKDataSetReader.h>
 #include <vtkm/io/VTKDataSetWriter.h>
 #include <vtkm/worklet/testing/GenerateTestDataSets.h>
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
index 00c50c4ed..a122731ec 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
@@ -9,9 +9,9 @@
 //============================================================================
 
 #include <vtkm/cont/testing/Testing.h>
-#include <vtkm/filter/ParticleAdvection.h>
-#include <vtkm/filter/Pathline.h>
-#include <vtkm/filter/Streamline.h>
+#include <vtkm/filter/flow/ParticleAdvection.h>
+#include <vtkm/filter/flow/Pathline.h>
+#include <vtkm/filter/flow/Streamline.h>
 #include <vtkm/thirdparty/diy/diy.h>
 #include <vtkm/worklet/testing/GenerateTestDataSets.h>
 

From a6a11f9c5b35a9161e2dd31f7355c5699126c4dd Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 22 Jul 2022 12:31:08 -0400
Subject: [PATCH 038/104] Change namespace to flow

---
 vtkm/filter/flow/AdvectAlgorithm.h            |  22 ++-
 vtkm/filter/flow/AdvectAlgorithmThreaded.h    |  13 +-
 vtkm/filter/flow/BoundsMap.h                  |  10 +-
 vtkm/filter/flow/DataSetIntegrator.h          |  30 ++--
 .../flow/DataSetIntegratorSteadyState.h       |  29 ++--
 .../flow/DataSetIntegratorUnsteadyState.h     |  24 ++-
 vtkm/filter/flow/Messenger.cxx                |   4 +-
 vtkm/filter/flow/Messenger.h                  |   8 +-
 vtkm/filter/flow/NewFilterParticleAdvection.h |  32 ++--
 .../NewFilterParticleAdvectionSteadyState.h   |  23 +--
 .../NewFilterParticleAdvectionUnsteadyState.h |  20 +--
 vtkm/filter/flow/ParticleAdvection.cxx        |  11 +-
 vtkm/filter/flow/ParticleAdvection.h          |  16 +-
 vtkm/filter/flow/ParticleAdvectionAlgorithm.h | 149 ------------------
 vtkm/filter/flow/ParticleAdvectionTypes.h     |  10 +-
 vtkm/filter/flow/ParticleAdvector.h           |  30 ++--
 vtkm/filter/flow/ParticleMessenger.h          |  25 ++-
 vtkm/filter/flow/PathParticle.cxx             |  11 +-
 vtkm/filter/flow/PathParticle.h               |  10 +-
 vtkm/filter/flow/Pathline.cxx                 |  12 +-
 vtkm/filter/flow/Pathline.h                   |  11 +-
 vtkm/filter/flow/Streamline.cxx               |  11 +-
 vtkm/filter/flow/Streamline.h                 |  11 +-
 vtkm/filter/testing/RenderTestStreamline.cxx  |   2 +-
 .../testing/UnitTestStreamlineFilter.cxx      |  22 +--
 .../testing/UnitTestStreamlineFilterMPI.cxx   |  12 +-
 26 files changed, 212 insertions(+), 346 deletions(-)
 delete mode 100644 vtkm/filter/flow/ParticleAdvectionAlgorithm.h

diff --git a/vtkm/filter/flow/AdvectAlgorithm.h b/vtkm/filter/flow/AdvectAlgorithm.h
index a7367db4f..99f5e76b9 100644
--- a/vtkm/filter/flow/AdvectAlgorithm.h
+++ b/vtkm/filter/flow/AdvectAlgorithm.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_AdvectAlgorithm_h
-#define vtk_m_filter_AdvectAlgorithm_h
+#ifndef vtk_m_filter_flow_AdvectAlgorithm_h
+#define vtk_m_filter_flow_AdvectAlgorithm_h
 
 #include <vtkm/cont/PartitionedDataSet.h>
 #include <vtkm/filter/flow/BoundsMap.h>
@@ -21,15 +21,14 @@ namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename DSIType, template <typename> class ResultType, typename ParticleType>
 class AdvectAlgorithm
 {
 public:
-  AdvectAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                  std::vector<DSIType*>& blocks)
+  AdvectAlgorithm(const vtkm::filter::flow::BoundsMap& bm, std::vector<DSIType*>& blocks)
     : Blocks(blocks)
     , BoundsMap(bm)
     , NumRanks(this->Comm.size())
@@ -90,7 +89,7 @@ public:
   //Advect all the particles.
   virtual void Go()
   {
-    vtkm::filter::particleadvection::ParticleMessenger<ParticleType> messenger(
+    vtkm::filter::flow::ParticleMessenger<ParticleType> messenger(
       this->Comm, this->BoundsMap, 1, 128);
 
     vtkm::Id nLocal = static_cast<vtkm::Id>(this->Active.size() + this->Inactive.size());
@@ -188,10 +187,9 @@ public:
     return !particles.empty();
   }
 
-  virtual void Communicate(
-    vtkm::filter::particleadvection::ParticleMessenger<ParticleType>& messenger,
-    vtkm::Id numLocalTerminations,
-    vtkm::Id& numTermMessages)
+  virtual void Communicate(vtkm::filter::flow::ParticleMessenger<ParticleType>& messenger,
+                           vtkm::Id numLocalTerminations,
+                           vtkm::Id& numTermMessages)
   {
     std::vector<ParticleType> incoming;
     std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> incomingIDs;
@@ -266,7 +264,7 @@ public:
   //Member data
   std::vector<ParticleType> Active;
   std::vector<DSIType*> Blocks;
-  vtkm::filter::particleadvection::BoundsMap BoundsMap;
+  vtkm::filter::flow::BoundsMap BoundsMap;
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
   std::vector<ParticleType> Inactive;
   vtkm::Id NumberOfSteps;
@@ -282,4 +280,4 @@ public:
 }
 }
 
-#endif //vtk_m_filter_AdvectAlgorithm_h
+#endif //vtk_m_filter_flow_AdvectAlgorithm_h
diff --git a/vtkm/filter/flow/AdvectAlgorithmThreaded.h b/vtkm/filter/flow/AdvectAlgorithmThreaded.h
index e23756575..7f2ba375e 100644
--- a/vtkm/filter/flow/AdvectAlgorithmThreaded.h
+++ b/vtkm/filter/flow/AdvectAlgorithmThreaded.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_AdvectAlgorithmThreaded_h
-#define vtk_m_filter_AdvectAlgorithmThreaded_h
+#ifndef vtk_m_filter_flow_AdvectAlgorithmThreaded_h
+#define vtk_m_filter_flow_AdvectAlgorithmThreaded_h
 
 #include <vtkm/cont/PartitionedDataSet.h>
 #include <vtkm/filter/flow/AdvectAlgorithm.h>
@@ -23,15 +23,14 @@ namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename DSIType, template <typename> class ResultType, typename ParticleType>
 class AdvectAlgorithmThreaded : public AdvectAlgorithm<DSIType, ResultType, ParticleType>
 {
 public:
-  AdvectAlgorithmThreaded(const vtkm::filter::particleadvection::BoundsMap& bm,
-                          std::vector<DSIType*>& blocks)
+  AdvectAlgorithmThreaded(const vtkm::filter::flow::BoundsMap& bm, std::vector<DSIType*>& blocks)
     : AdvectAlgorithm<DSIType, ResultType, ParticleType>(bm, blocks)
     , Done(false)
     , WorkerActivate(false)
@@ -131,7 +130,7 @@ protected:
 
   void Manage()
   {
-    vtkm::filter::particleadvection::ParticleMessenger<ParticleType> messenger(
+    vtkm::filter::flow::ParticleMessenger<ParticleType> messenger(
       this->Comm, this->BoundsMap, 1, 128);
 
     while (this->TotalNumTerminatedParticles < this->TotalNumParticles)
@@ -190,4 +189,4 @@ protected:
 }
 }
 
-#endif //vtk_m_filter_AdvectAlgorithmThreaded_h
+#endif //vtk_m_filter_flow_AdvectAlgorithmThreaded_h
diff --git a/vtkm/filter/flow/BoundsMap.h b/vtkm/filter/flow/BoundsMap.h
index 705aba99a..b2b162fa9 100644
--- a/vtkm/filter/flow/BoundsMap.h
+++ b/vtkm/filter/flow/BoundsMap.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_BoundsMap_h
-#define vtk_m_filter_BoundsMap_h
+#ifndef vtk_m_filter_flow_BoundsMap_h
+#define vtk_m_filter_flow_BoundsMap_h
 
 #include <vtkm/Bounds.h>
 #include <vtkm/cont/AssignerPartitionedDataSet.h>
@@ -31,7 +31,7 @@ namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 
 class VTKM_ALWAYS_EXPORT BoundsMap
@@ -176,6 +176,6 @@ private:
 };
 }
 }
-} // namespace vtkm::filter::particleadvection
+} // namespace vtkm::filter::flow
 
-#endif
+#endif //vtk_m_filter_flow_BoundsMap_h
diff --git a/vtkm/filter/flow/DataSetIntegrator.h b/vtkm/filter/flow/DataSetIntegrator.h
index eadda65ae..301a9874f 100644
--- a/vtkm/filter/flow/DataSetIntegrator.h
+++ b/vtkm/filter/flow/DataSetIntegrator.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_DataSetIntegrator_h
-#define vtk_m_filter_particleadvection_DataSetIntegrator_h
+#ifndef vtk_m_filter_flow_DataSetIntegrator_h
+#define vtk_m_filter_flow_DataSetIntegrator_h
 
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
@@ -28,7 +28,7 @@ namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename ParticleType>
@@ -36,7 +36,7 @@ class DSIHelperInfo
 {
 public:
   DSIHelperInfo(const std::vector<ParticleType>& v,
-                const vtkm::filter::particleadvection::BoundsMap& boundsMap,
+                const vtkm::filter::flow::BoundsMap& boundsMap,
                 const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& particleBlockIDsMap)
     : BoundsMap(boundsMap)
     , ParticleBlockIDsMap(particleBlockIDsMap)
@@ -44,7 +44,7 @@ public:
   {
   }
 
-  const vtkm::filter::particleadvection::BoundsMap BoundsMap;
+  const vtkm::filter::flow::BoundsMap BoundsMap;
   const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
 
   std::vector<ParticleType> A, I, V;
@@ -72,9 +72,9 @@ protected:
 public:
   DataSetIntegrator(vtkm::Id id,
                     const FieldNameType& fieldName,
-                    vtkm::filter::particleadvection::IntegrationSolverType solverType,
-                    vtkm::filter::particleadvection::VectorFieldType vecFieldType,
-                    vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
+                    vtkm::filter::flow::IntegrationSolverType solverType,
+                    vtkm::filter::flow::VectorFieldType vecFieldType,
+                    vtkm::filter::flow::FlowResultType resultType)
     : FieldName(fieldName)
     , Id(id)
     , SolverType(solverType)
@@ -118,12 +118,12 @@ protected:
 
   VTKM_CONT bool IsParticleAdvectionResult() const
   {
-    return this->AdvectionResType == ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE;
+    return this->AdvectionResType == FlowResultType::PARTICLE_ADVECT_TYPE;
   }
 
   VTKM_CONT bool IsStreamlineResult() const
   {
-    return this->AdvectionResType == ParticleAdvectionResultType::STREAMLINE_TYPE;
+    return this->AdvectionResType == FlowResultType::STREAMLINE_TYPE;
   }
 
   VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
@@ -142,10 +142,10 @@ protected:
   vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType> FieldName;
 
   vtkm::Id Id;
-  vtkm::filter::particleadvection::IntegrationSolverType SolverType;
-  vtkm::filter::particleadvection::VectorFieldType VecFieldType;
-  vtkm::filter::particleadvection::ParticleAdvectionResultType AdvectionResType =
-    vtkm::filter::particleadvection::ParticleAdvectionResultType::UNKNOWN_TYPE;
+  vtkm::filter::flow::IntegrationSolverType SolverType;
+  vtkm::filter::flow::VectorFieldType VecFieldType;
+  vtkm::filter::flow::FlowResultType AdvectionResType =
+    vtkm::filter::flow::FlowResultType::UNKNOWN_TYPE;
 
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
   vtkm::Id Rank;
@@ -381,4 +381,4 @@ VTKM_CONT bool DataSetIntegrator::GetOutput(vtkm::cont::DataSet& ds) const
 }
 }
 
-#endif //vtk_m_filter_particleadvection_DataSetIntegrator_h
+#endif //vtk_m_filter_flow_DataSetIntegrator_h
diff --git a/vtkm/filter/flow/DataSetIntegratorSteadyState.h b/vtkm/filter/flow/DataSetIntegratorSteadyState.h
index ad674be60..f452122d2 100644
--- a/vtkm/filter/flow/DataSetIntegratorSteadyState.h
+++ b/vtkm/filter/flow/DataSetIntegratorSteadyState.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_h
-#define vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_h
+#ifndef vtk_m_filter_flow_DataSetIntegratorSteadyState_h
+#define vtk_m_filter_flow_DataSetIntegratorSteadyState_h
 
 #include <vtkm/filter/flow/DataSetIntegrator.h>
 
@@ -17,24 +17,19 @@ namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 
-class DataSetIntegratorSteadyState : public vtkm::filter::particleadvection::DataSetIntegrator
+class DataSetIntegratorSteadyState : public vtkm::filter::flow::DataSetIntegrator
 {
 public:
-  DataSetIntegratorSteadyState(
-    const vtkm::cont::DataSet& ds,
-    vtkm::Id id,
-    const FieldNameType& fieldName,
-    vtkm::filter::particleadvection::IntegrationSolverType solverType,
-    vtkm::filter::particleadvection::VectorFieldType vecFieldType,
-    vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
-    : vtkm::filter::particleadvection::DataSetIntegrator(id,
-                                                         fieldName,
-                                                         solverType,
-                                                         vecFieldType,
-                                                         resultType)
+  DataSetIntegratorSteadyState(const vtkm::cont::DataSet& ds,
+                               vtkm::Id id,
+                               const FieldNameType& fieldName,
+                               vtkm::filter::flow::IntegrationSolverType solverType,
+                               vtkm::filter::flow::VectorFieldType vecFieldType,
+                               vtkm::filter::flow::FlowResultType resultType)
+    : vtkm::filter::flow::DataSetIntegrator(id, fieldName, solverType, vecFieldType, resultType)
     , DataSet(ds)
   {
   }
@@ -208,4 +203,4 @@ VTKM_CONT inline void DataSetIntegratorSteadyState::DoAdvect(
 }
 }
 
-#endif //vtk_m_filter_particleadvection_DataSetIntegratorSteadyState_h
+#endif //vtk_m_filter_flow_DataSetIntegratorSteadyState_h
diff --git a/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h b/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
index 384018ac0..0e692ca3d 100644
--- a/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
+++ b/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_h
-#define vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_h
+#ifndef vtk_m_filter_flow_DataSetIntegratorUnsteadyState_h
+#define vtk_m_filter_flow_DataSetIntegratorUnsteadyState_h
 
 #include <vtkm/filter/flow/DataSetIntegrator.h>
 #include <vtkm/worklet/particleadvection/TemporalGridEvaluators.h>
@@ -18,10 +18,10 @@ namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 
-class DataSetIntegratorUnsteadyState : public vtkm::filter::particleadvection::DataSetIntegrator
+class DataSetIntegratorUnsteadyState : public vtkm::filter::flow::DataSetIntegrator
 {
 public:
   DataSetIntegratorUnsteadyState(
@@ -30,15 +30,11 @@ public:
     vtkm::FloatDefault t1,
     vtkm::FloatDefault t2,
     vtkm::Id id,
-    const vtkm::filter::particleadvection::DataSetIntegrator::FieldNameType& fieldName,
-    vtkm::filter::particleadvection::IntegrationSolverType solverType,
-    vtkm::filter::particleadvection::VectorFieldType vecFieldType,
-    vtkm::filter::particleadvection::ParticleAdvectionResultType resultType)
-    : vtkm::filter::particleadvection::DataSetIntegrator(id,
-                                                         fieldName,
-                                                         solverType,
-                                                         vecFieldType,
-                                                         resultType)
+    const vtkm::filter::flow::DataSetIntegrator::FieldNameType& fieldName,
+    vtkm::filter::flow::IntegrationSolverType solverType,
+    vtkm::filter::flow::VectorFieldType vecFieldType,
+    vtkm::filter::flow::FlowResultType resultType)
+    : vtkm::filter::flow::DataSetIntegrator(id, fieldName, solverType, vecFieldType, resultType)
     , DataSet1(ds1)
     , DataSet2(ds2)
     , Time1(t1)
@@ -259,4 +255,4 @@ VTKM_CONT inline void DataSetIntegratorUnsteadyState::DoAdvect(
 }
 }
 
-#endif //vtk_m_filter_particleadvection_DataSetIntegratorUnsteadyState_h
+#endif //vtk_m_filter_flow_DataSetIntegratorUnsteadyState_h
diff --git a/vtkm/filter/flow/Messenger.cxx b/vtkm/filter/flow/Messenger.cxx
index 2dcade5ad..0baa06c17 100644
--- a/vtkm/filter/flow/Messenger.cxx
+++ b/vtkm/filter/flow/Messenger.cxx
@@ -22,7 +22,7 @@ namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 
 VTKM_CONT
@@ -381,4 +381,4 @@ void Messenger::ProcessReceivedBuffers(std::vector<char*>& incomingBuffers,
 #endif
 }
 }
-} // namespace vtkm::filter::particleadvection
+} // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/Messenger.h b/vtkm/filter/flow/Messenger.h
index 8d5bff416..f11cc5833 100644
--- a/vtkm/filter/flow/Messenger.h
+++ b/vtkm/filter/flow/Messenger.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_Messenger_h
-#define vtk_m_filter_Messenger_h
+#ifndef vtk_m_filter_flow_Messenger_h
+#define vtk_m_filter_flow_Messenger_h
 
 #include <vtkm/Types.h>
 #include <vtkm/cont/Serialization.h>
@@ -28,7 +28,7 @@ namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 
 class Messenger
@@ -106,7 +106,7 @@ protected:
 };
 }
 }
-} // namespace vtkm::filter::particleadvection
+} // namespace vtkm::filter::flow
 
 
 #endif
diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index 06089321f..da292c38c 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_NewFilterParticleAdvection_h
-#define vtk_m_filter_NewFilterParticleAdvection_h
+#ifndef vtk_m_filter_flow_NewFilterParticleAdvection_h
+#define vtk_m_filter_flow_NewFilterParticleAdvection_h
 
 #include <vtkm/Particle.h>
 #include <vtkm/filter/NewFilterField.h>
@@ -23,6 +23,9 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
+
 /// \brief base class for advecting particles in a vector field.
 
 /// Takes as input a vector field and seed locations and advects the seeds
@@ -34,14 +37,14 @@ public:
   using SupportedTypes = vtkm::TypeListFieldVec3;
 
   VTKM_CONT
-  NewFilterParticleAdvection(vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
+  NewFilterParticleAdvection(vtkm::filter::flow::FlowResultType rType)
     //    : vtkm::filter::NewFilterField()
     : NumberOfSteps(0)
     , ResultType(rType)
-    , SolverType(vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE)
+    , SolverType(vtkm::filter::flow::IntegrationSolverType::RK4_TYPE)
     , StepSize(0)
     , UseThreadedAlgorithm(false)
-    , VecFieldType(vtkm::filter::particleadvection::VectorFieldType::VELOCITY_FIELD_TYPE)
+    , VecFieldType(vtkm::filter::flow::VectorFieldType::VELOCITY_FIELD_TYPE)
   {
   }
 
@@ -65,14 +68,11 @@ public:
   }
 
   VTKM_CONT
-  void SetSolverRK4()
-  {
-    this->SolverType = vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE;
-  }
+  void SetSolverRK4() { this->SolverType = vtkm::filter::flow::IntegrationSolverType::RK4_TYPE; }
   VTKM_CONT
   void SetSolverEuler()
   {
-    this->SolverType = vtkm::filter::particleadvection::IntegrationSolverType::EULER_TYPE;
+    this->SolverType = vtkm::filter::flow::IntegrationSolverType::EULER_TYPE;
   }
 
   VTKM_CONT
@@ -108,18 +108,18 @@ protected:
   }
 
   vtkm::Id NumberOfSteps;
-  vtkm::filter::particleadvection::ParticleAdvectionResultType ResultType =
-    vtkm::filter::particleadvection::ParticleAdvectionResultType::UNKNOWN_TYPE;
+  vtkm::filter::flow::FlowResultType ResultType = vtkm::filter::flow::FlowResultType::UNKNOWN_TYPE;
   vtkm::cont::UnknownArrayHandle Seeds;
-  vtkm::filter::particleadvection::IntegrationSolverType SolverType;
+  vtkm::filter::flow::IntegrationSolverType SolverType;
   vtkm::FloatDefault StepSize;
   bool UseThreadedAlgorithm;
-  vtkm::filter::particleadvection::VectorFieldType VecFieldType;
+  vtkm::filter::flow::VectorFieldType VecFieldType;
 
 private:
 };
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
 
-#endif // vtk_m_filter_NewFilterParticleAdvection_h
+#endif // vtk_m_filter_flow_NewFilterParticleAdvection_h
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index 317243bfe..02d9682ed 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_NewFilterParticleAdvectionSteadyState_h
-#define vtk_m_filter_NewFilterParticleAdvectionSteadyState_h
+#ifndef vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
+#define vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
 
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
 
@@ -17,22 +17,24 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
+
 class NewFilterParticleAdvectionSteadyState : public NewFilterParticleAdvection
 {
 public:
   VTKM_CONT
-  NewFilterParticleAdvectionSteadyState(
-    vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
+  NewFilterParticleAdvectionSteadyState(vtkm::filter::flow::FlowResultType rType)
     : NewFilterParticleAdvection(rType)
   {
   }
 
 protected:
-  VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegratorSteadyState*>
-  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
-                           const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
+  VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorSteadyState*> CreateDataSetIntegrators(
+    const vtkm::cont::PartitionedDataSet& input,
+    const vtkm::filter::flow::BoundsMap& boundsMap) const
   {
-    using DSIType = vtkm::filter::particleadvection::DataSetIntegratorSteadyState;
+    using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
 
     std::string activeField = this->GetActiveFieldName();
 
@@ -53,6 +55,7 @@ protected:
 };
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
 
-#endif // vtk_m_filter_NewFilterParticleAdvectionSteadyState_h
+#endif // vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index beb507d54..138aaca04 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_NewFilterParticleAdvectionUnsteadyState_h
-#define vtk_m_filter_NewFilterParticleAdvectionUnsteadyState_h
+#ifndef vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
+#define vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
 
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
 
@@ -17,13 +17,14 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
 
 class NewFilterParticleAdvectionUnsteadyState : public NewFilterParticleAdvection
 {
 public:
   VTKM_CONT
-  NewFilterParticleAdvectionUnsteadyState(
-    vtkm::filter::particleadvection::ParticleAdvectionResultType rType)
+  NewFilterParticleAdvectionUnsteadyState(vtkm::filter::flow::FlowResultType rType)
     : NewFilterParticleAdvection(rType)
   {
   }
@@ -44,11 +45,11 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("PreviousTime must be less than NextTime");
   }
 
-  VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState*>
+  VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorUnsteadyState*>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
-                           const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
+                           const vtkm::filter::flow::BoundsMap& boundsMap) const
   {
-    using DSIType = vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState;
+    using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
 
     std::string activeField = this->GetActiveFieldName();
 
@@ -82,6 +83,7 @@ protected:
 };
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
 
-#endif // vtk_m_filter_NewFilterParticleAdvectionUnsteadyState_h
+#endif // vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
diff --git a/vtkm/filter/flow/ParticleAdvection.cxx b/vtkm/filter/flow/ParticleAdvection.cxx
index 88e63ca09..dafa80703 100644
--- a/vtkm/filter/flow/ParticleAdvection.cxx
+++ b/vtkm/filter/flow/ParticleAdvection.cxx
@@ -20,21 +20,24 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
 
 VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  using DSIType = vtkm::filter::particleadvection::DataSetIntegratorSteadyState;
+  using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
   this->ValidateOptions();
 
-  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
+  vtkm::filter::flow::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  vtkm::filter::particleadvection::ParticleAdvector<DSIType> pav(
+  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
 
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/ParticleAdvection.h b/vtkm/filter/flow/ParticleAdvection.h
index b9f4a4c6c..0ef95a9b8 100644
--- a/vtkm/filter/flow/ParticleAdvection.h
+++ b/vtkm/filter/flow/ParticleAdvection.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_ParticleAdvection_h
-#define vtk_m_filter_ParticleAdvection_h
+#ifndef vtk_m_filter_flow_ParticleAdvection_h
+#define vtk_m_filter_flow_ParticleAdvection_h
 
 #include <vtkm/Particle.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
@@ -20,18 +20,21 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
+
 /// \brief Advect particles in a vector field.
 
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
 class VTKM_FILTER_FLOW_EXPORT ParticleAdvection
-  : public vtkm::filter::NewFilterParticleAdvectionSteadyState
+  : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
 public:
   VTKM_CONT ParticleAdvection()
     : NewFilterParticleAdvectionSteadyState(
-        vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+        vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE)
   {
   }
 
@@ -41,6 +44,7 @@ protected:
 };
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
 
-#endif // vtk_m_filter_ParticleAdvection_h
+#endif // vtk_m_filter_flow_ParticleAdvection_h
diff --git a/vtkm/filter/flow/ParticleAdvectionAlgorithm.h b/vtkm/filter/flow/ParticleAdvectionAlgorithm.h
deleted file mode 100644
index c5c0c230e..000000000
--- a/vtkm/filter/flow/ParticleAdvectionAlgorithm.h
+++ /dev/null
@@ -1,149 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_particleadvection_ParticleAdvectionAlgorithm_h
-#define vtk_m_filter_particleadvection_ParticleAdvectionAlgorithm_h
-
-namespace vtkm
-{
-namespace filter
-{
-namespace particleadvection
-{
-
-#if 0
-
-using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
-using TDSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
-
-//-------------------------------------------------------------------------------------------
-//Steady state advection algorithms
-
-//Particle advection
-class VTKM_ALWAYS_EXPORT ParticleAdvectionAlgorithm
-  : public AdvectorBaseAlgorithm<DSIType, vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>>
-{
-public:
-  ParticleAdvectionAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                             const std::vector<DSIType>& blocks)
-    : AdvectorBaseAlgorithm<DSIType, vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>>(bm,
-                                                                                             blocks)
-  {
-  }
-};
-
-//Threaded particle advection
-class VTKM_ALWAYS_EXPORT ParticleAdvectionThreadedAlgorithm
-  : public AdvectorBaseThreadedAlgorithm<DSIType,
-                                         vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>>
-{
-public:
-  ParticleAdvectionThreadedAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                                     const std::vector<DSIType>& blocks)
-    : AdvectorBaseThreadedAlgorithm<DSIType,
-                                    vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>>(bm,
-                                                                                            blocks)
-  {
-  }
-};
-
-//Streamline
-class VTKM_ALWAYS_EXPORT StreamlineAlgorithm
-  : public AdvectorBaseAlgorithm<DSIType, vtkm::worklet::StreamlineResult<vtkm::Particle>>
-{
-public:
-  StreamlineAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                      const std::vector<DSIType>& blocks)
-    : AdvectorBaseAlgorithm<DSIType, vtkm::worklet::StreamlineResult<vtkm::Particle>>(bm, blocks)
-  {
-  }
-};
-
-//Threaded streamline
-
-class VTKM_ALWAYS_EXPORT StreamlineThreadedAlgorithm
-  : public AdvectorBaseThreadedAlgorithm<DSIType, vtkm::worklet::StreamlineResult<vtkm::Particle>>
-{
-public:
-  StreamlineThreadedAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                              const std::vector<DSIType>& blocks)
-    : AdvectorBaseThreadedAlgorithm<DSIType, vtkm::worklet::StreamlineResult<vtkm::Particle>>(
-        bm,
-        blocks)
-  {
-  }
-};
-
-//-------------------------------------------------------------------------------------------
-//Unsteady state advection algorithms
-
-//PathParticle
-class VTKM_ALWAYS_EXPORT PathParticleAlgorithm
-  : public AdvectorBaseAlgorithm<TDSIType, vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>>
-{
-public:
-  PathParticleAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                        const std::vector<TDSIType>& blocks)
-    : AdvectorBaseAlgorithm<TDSIType, vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>>(
-        bm,
-        blocks)
-  {
-  }
-};
-
-
-//Threaded PathParticle
-class VTKM_ALWAYS_EXPORT PathParticleThreadedAlgorithm
-  : public AdvectorBaseThreadedAlgorithm<TDSIType,
-                                         vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>>
-{
-public:
-  PathParticleThreadedAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                                const std::vector<TDSIType>& blocks)
-    : AdvectorBaseThreadedAlgorithm<TDSIType,
-                                    vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>>(bm,
-                                                                                            blocks)
-  {
-  }
-};
-
-//Pathline
-class VTKM_ALWAYS_EXPORT PathlineAlgorithm
-  : public AdvectorBaseAlgorithm<TDSIType, vtkm::worklet::StreamlineResult<vtkm::Particle>>
-{
-public:
-  PathlineAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                    const std::vector<TDSIType>& blocks)
-    : AdvectorBaseAlgorithm<TDSIType, vtkm::worklet::StreamlineResult<vtkm::Particle>>(bm, blocks)
-  {
-  }
-};
-
-//Threaded pathline
-class VTKM_ALWAYS_EXPORT PathlineThreadedAlgorithm
-  : public AdvectorBaseThreadedAlgorithm<TDSIType, vtkm::worklet::StreamlineResult<vtkm::Particle>>
-{
-public:
-  PathlineThreadedAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
-                            const std::vector<TDSIType>& blocks)
-    : AdvectorBaseThreadedAlgorithm<TDSIType, vtkm::worklet::StreamlineResult<vtkm::Particle>>(
-        bm,
-        blocks)
-  {
-  }
-};
-
-#endif
-
-}
-}
-} // namespace vtkm::filter::particleadvection
-
-#endif //vtk_m_filter_particleadvection_ParticleAdvectionAlgorithm_h
diff --git a/vtkm/filter/flow/ParticleAdvectionTypes.h b/vtkm/filter/flow/ParticleAdvectionTypes.h
index e5e8f1428..5d9b97ea7 100644
--- a/vtkm/filter/flow/ParticleAdvectionTypes.h
+++ b/vtkm/filter/flow/ParticleAdvectionTypes.h
@@ -7,14 +7,14 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-#ifndef vtk_m_filter_particleadvection_ParticleAdvectionTypes_h
-#define vtk_m_filter_particleadvection_ParticleAdvectionTypes_h
+#ifndef vtk_m_filter_flow_ParticleAdvectionTypes_h
+#define vtk_m_filter_flow_ParticleAdvectionTypes_h
 
 namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 enum class IntegrationSolverType
 {
@@ -28,7 +28,7 @@ enum class VectorFieldType
   ELECTRO_MAGNETIC_FIELD_TYPE,
 };
 
-enum class ParticleAdvectionResultType
+enum class FlowResultType
 {
   UNKNOWN_TYPE = -1,
   PARTICLE_ADVECT_TYPE,
@@ -40,4 +40,4 @@ enum class ParticleAdvectionResultType
 }
 
 
-#endif // vtk_m_filter_particleadvection_ParticleAdvectionTypes_h
+#endif // vtk_m_filter_flow_ParticleAdvectionTypes_h
diff --git a/vtkm/filter/flow/ParticleAdvector.h b/vtkm/filter/flow/ParticleAdvector.h
index 80fe96c3a..accca6b1c 100644
--- a/vtkm/filter/flow/ParticleAdvector.h
+++ b/vtkm/filter/flow/ParticleAdvector.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_particleadvection_ParticleAdvector_h
-#define vtk_m_filter_particleadvection_ParticleAdvector_h
+#ifndef vtk_m_filter_flow_ParticleAdvector_h
+#define vtk_m_filter_flow_ParticleAdvector_h
 
 #include <vtkm/filter/flow/AdvectAlgorithm.h>
 #include <vtkm/filter/flow/AdvectAlgorithmThreaded.h>
@@ -20,17 +20,17 @@ namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename DSIType>
 class ParticleAdvector
 {
 public:
-  ParticleAdvector(const vtkm::filter::particleadvection::BoundsMap& bm,
+  ParticleAdvector(const vtkm::filter::flow::BoundsMap& bm,
                    const std::vector<DSIType*> blocks,
                    const bool& useThreaded,
-                   const vtkm::filter::particleadvection::ParticleAdvectionResultType& parType)
+                   const vtkm::filter::flow::FlowResultType& parType)
     : Blocks(blocks)
     , BoundsMap(bm)
     , ResultType(parType)
@@ -71,17 +71,16 @@ private:
   {
     if (!this->UseThreadedAlgorithm)
     {
-      if (this->ResultType ==
-          vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+      if (this->ResultType == vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE)
       {
-        using AlgorithmType = vtkm::filter::particleadvection::
+        using AlgorithmType = vtkm::filter::flow::
           AdvectAlgorithm<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
       else
       {
-        using AlgorithmType = vtkm::filter::particleadvection::
+        using AlgorithmType = vtkm::filter::flow::
           AdvectAlgorithm<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
@@ -89,17 +88,16 @@ private:
     }
     else
     {
-      if (this->ResultType ==
-          vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+      if (this->ResultType == vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE)
       {
-        using AlgorithmType = vtkm::filter::particleadvection::
+        using AlgorithmType = vtkm::filter::flow::
           AdvectAlgorithmThreaded<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
       else
       {
-        using AlgorithmType = vtkm::filter::particleadvection::
+        using AlgorithmType = vtkm::filter::flow::
           AdvectAlgorithmThreaded<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
@@ -109,8 +107,8 @@ private:
 
 
   std::vector<DSIType*> Blocks;
-  vtkm::filter::particleadvection::BoundsMap BoundsMap;
-  ParticleAdvectionResultType ResultType;
+  vtkm::filter::flow::BoundsMap BoundsMap;
+  FlowResultType ResultType;
   bool UseThreadedAlgorithm;
 };
 
@@ -119,4 +117,4 @@ private:
 }
 
 
-#endif //vtk_m_filter_particleadvection_ParticleAdvector_h
+#endif //vtk_m_filter_flow_ParticleAdvector_h
diff --git a/vtkm/filter/flow/ParticleMessenger.h b/vtkm/filter/flow/ParticleMessenger.h
index 9c7cf2dcb..260bf442f 100644
--- a/vtkm/filter/flow/ParticleMessenger.h
+++ b/vtkm/filter/flow/ParticleMessenger.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_ParticleMessenger_h
-#define vtk_m_filter_ParticleMessenger_h
+#ifndef vtk_m_filter_flow_ParticleMessenger_h
+#define vtk_m_filter_flow_ParticleMessenger_h
 
 #include <vtkm/Particle.h>
 #include <vtkm/cont/Serialization.h>
@@ -25,11 +25,11 @@ namespace vtkm
 {
 namespace filter
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename ParticleType>
-class ParticleMessenger : public vtkm::filter::particleadvection::Messenger
+class ParticleMessenger : public vtkm::filter::flow::Messenger
 {
   //sendRank, message
   using MsgCommType = std::pair<int, std::vector<int>>;
@@ -42,7 +42,7 @@ class ParticleMessenger : public vtkm::filter::particleadvection::Messenger
 
 public:
   VTKM_CONT ParticleMessenger(vtkmdiy::mpi::communicator& comm,
-                              const vtkm::filter::particleadvection::BoundsMap& bm,
+                              const vtkm::filter::flow::BoundsMap& bm,
                               int msgSz = 1,
                               int numParticles = 128,
                               int numBlockIds = 2);
@@ -88,7 +88,7 @@ protected:
   VTKM_CONT bool RecvAny(std::vector<MsgCommType>* msgs,
                          std::vector<ParticleRecvCommType>* recvParticles,
                          bool blockAndWait);
-  const vtkm::filter::particleadvection::BoundsMap& BoundsMap;
+  const vtkm::filter::flow::BoundsMap& BoundsMap;
 
 #endif
 
@@ -107,12 +107,11 @@ protected:
 
 VTKM_CONT
 template <typename ParticleType>
-ParticleMessenger<ParticleType>::ParticleMessenger(
-  vtkmdiy::mpi::communicator& comm,
-  const vtkm::filter::particleadvection::BoundsMap& boundsMap,
-  int msgSz,
-  int numParticles,
-  int numBlockIds)
+ParticleMessenger<ParticleType>::ParticleMessenger(vtkmdiy::mpi::communicator& comm,
+                                                   const vtkm::filter::flow::BoundsMap& boundsMap,
+                                                   int msgSz,
+                                                   int numParticles,
+                                                   int numBlockIds)
   : Messenger(comm)
 #ifdef VTKM_ENABLE_MPI
   , BoundsMap(boundsMap)
@@ -357,6 +356,6 @@ inline void ParticleMessenger<ParticleType>::SendParticles(
 #endif
 }
 }
-} // namespace vtkm::filter::particleadvection
+} // namespace vtkm::filter::flow
 
 #endif
diff --git a/vtkm/filter/flow/PathParticle.cxx b/vtkm/filter/flow/PathParticle.cxx
index 00456cee4..a0cc6227d 100644
--- a/vtkm/filter/flow/PathParticle.cxx
+++ b/vtkm/filter/flow/PathParticle.cxx
@@ -20,21 +20,24 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
 
 VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  using DSIType = vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState;
+  using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
   this->ValidateOptions();
 
-  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
+  vtkm::filter::flow::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  vtkm::filter::particleadvection::ParticleAdvector<DSIType> pav(
+  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
 
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/PathParticle.h b/vtkm/filter/flow/PathParticle.h
index 51e6b00be..aac9fc757 100644
--- a/vtkm/filter/flow/PathParticle.h
+++ b/vtkm/filter/flow/PathParticle.h
@@ -20,18 +20,21 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
+
 /// \brief Advect particles in a vector field.
 
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
 class VTKM_FILTER_FLOW_EXPORT PathParticle
-  : public vtkm::filter::NewFilterParticleAdvectionUnsteadyState
+  : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
 public:
   VTKM_CONT PathParticle()
     : NewFilterParticleAdvectionUnsteadyState(
-        vtkm::filter::particleadvection::ParticleAdvectionResultType::PARTICLE_ADVECT_TYPE)
+        vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE)
   {
   }
 
@@ -41,6 +44,7 @@ protected:
 };
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
 
 #endif // vtk_m_filter_PathParticle_h
diff --git a/vtkm/filter/flow/Pathline.cxx b/vtkm/filter/flow/Pathline.cxx
index 3369ab2bb..9de866049 100644
--- a/vtkm/filter/flow/Pathline.cxx
+++ b/vtkm/filter/flow/Pathline.cxx
@@ -10,7 +10,6 @@
 
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/flow/BoundsMap.h>
-#include <vtkm/filter/flow/ParticleAdvectionAlgorithm.h>
 #include <vtkm/filter/flow/Pathline.h>
 
 #include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
@@ -21,21 +20,24 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
 
 VTKM_CONT vtkm::cont::PartitionedDataSet Pathline::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  using DSIType = vtkm::filter::particleadvection::DataSetIntegratorUnsteadyState;
+  using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
   this->ValidateOptions();
 
-  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
+  vtkm::filter::flow::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  vtkm::filter::particleadvection::ParticleAdvector<DSIType> pav(
+  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
 
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/Pathline.h b/vtkm/filter/flow/Pathline.h
index fec35a425..8ffe0d755 100644
--- a/vtkm/filter/flow/Pathline.h
+++ b/vtkm/filter/flow/Pathline.h
@@ -20,18 +20,20 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
+
 /// \brief Advect particles in a vector field.
 
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
 class VTKM_FILTER_FLOW_EXPORT Pathline
-  : public vtkm::filter::NewFilterParticleAdvectionUnsteadyState
+  : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
 public:
   VTKM_CONT Pathline()
-    : NewFilterParticleAdvectionUnsteadyState(
-        vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
+    : NewFilterParticleAdvectionUnsteadyState(vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE)
   {
   }
 
@@ -41,6 +43,7 @@ protected:
 };
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
 
 #endif // vtk_m_filter_Pathline_h
diff --git a/vtkm/filter/flow/Streamline.cxx b/vtkm/filter/flow/Streamline.cxx
index 26a7b6308..6664183f9 100644
--- a/vtkm/filter/flow/Streamline.cxx
+++ b/vtkm/filter/flow/Streamline.cxx
@@ -20,21 +20,24 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
 
 VTKM_CONT vtkm::cont::PartitionedDataSet Streamline::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  using DSIType = vtkm::filter::particleadvection::DataSetIntegratorSteadyState;
+  using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
   this->ValidateOptions();
 
-  vtkm::filter::particleadvection::BoundsMap boundsMap(input);
+  vtkm::filter::flow::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
 
-  vtkm::filter::particleadvection::ParticleAdvector<DSIType> pav(
+  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
 
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
 }
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/Streamline.h b/vtkm/filter/flow/Streamline.h
index f94893d6e..2380bb236 100644
--- a/vtkm/filter/flow/Streamline.h
+++ b/vtkm/filter/flow/Streamline.h
@@ -20,18 +20,20 @@ namespace vtkm
 {
 namespace filter
 {
+namespace flow
+{
+
 /// \brief Advect particles in a vector field.
 
 /// Takes as input a vector field and seed locations and generates the
 /// end points for each seed through the vector field.
 
 class VTKM_FILTER_FLOW_EXPORT Streamline
-  : public vtkm::filter::NewFilterParticleAdvectionSteadyState
+  : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
 public:
   VTKM_CONT Streamline()
-    : NewFilterParticleAdvectionSteadyState(
-        vtkm::filter::particleadvection::ParticleAdvectionResultType::STREAMLINE_TYPE)
+    : NewFilterParticleAdvectionSteadyState(vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE)
   {
   }
 
@@ -41,6 +43,7 @@ protected:
 };
 
 }
-} // namespace vtkm::filter
+}
+} // namespace vtkm::filter::flow
 
 #endif // vtk_m_filter_Streamline_h
diff --git a/vtkm/filter/testing/RenderTestStreamline.cxx b/vtkm/filter/testing/RenderTestStreamline.cxx
index 84833f7c5..53f723a4f 100644
--- a/vtkm/filter/testing/RenderTestStreamline.cxx
+++ b/vtkm/filter/testing/RenderTestStreamline.cxx
@@ -34,7 +34,7 @@ void TestStreamline()
                                    vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
                                    vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
 
-  vtkm::filter::Streamline streamline;
+  vtkm::filter::flow::Streamline streamline;
   streamline.SetStepSize(0.1f);
   streamline.SetNumberOfSteps(20);
   streamline.SetSeeds(seedArray);
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index 8e9110453..aa8b545d5 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -64,7 +64,7 @@ void TestStreamline()
                                      vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
                                      vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
 
-    vtkm::filter::Streamline streamline;
+    vtkm::filter::flow::Streamline streamline;
 
     streamline.SetStepSize(0.1f);
     streamline.SetNumberOfSteps(20);
@@ -129,7 +129,7 @@ void TestPathline()
       vtkm::Id numExpectedPoints;
       if (fType == 0)
       {
-        vtkm::filter::Pathline filt;
+        vtkm::filter::flow::Pathline filt;
         filt.SetActiveField(var);
         filt.SetStepSize(stepSize);
         filt.SetNumberOfSteps(numSteps);
@@ -147,7 +147,7 @@ void TestPathline()
       }
       else
       {
-        vtkm::filter::PathParticle filt;
+        vtkm::filter::flow::PathParticle filt;
         filt.SetActiveField(var);
         filt.SetStepSize(stepSize);
         filt.SetNumberOfSteps(numSteps);
@@ -233,7 +233,7 @@ void TestAMRStreamline(bool useSL)
 
     if (useSL)
     {
-      vtkm::filter::Streamline filter;
+      vtkm::filter::flow::Streamline filter;
       filter.SetStepSize(0.1f);
       filter.SetNumberOfSteps(100000);
       filter.SetSeeds(seedArray);
@@ -305,7 +305,7 @@ void TestAMRStreamline(bool useSL)
     }
     else
     {
-      vtkm::filter::ParticleAdvection filter;
+      vtkm::filter::flow::ParticleAdvection filter;
       filter.SetStepSize(0.1f);
       filter.SetNumberOfSteps(100000);
       filter.SetSeeds(seedArray);
@@ -387,7 +387,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
       vtkm::cont::PartitionedDataSet out;
       if (fType == FilterType::STREAMLINE)
       {
-        vtkm::filter::Streamline streamline;
+        vtkm::filter::flow::Streamline streamline;
         streamline.SetStepSize(0.1f);
         streamline.SetNumberOfSteps(100000);
         streamline.SetSeeds(seedArray);
@@ -400,7 +400,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
         auto pds2 = allPDs2[idx];
         AddVectorFields(pds2, fieldName, vecX);
 
-        vtkm::filter::Pathline pathline;
+        vtkm::filter::flow::Pathline pathline;
         pathline.SetPreviousTime(0);
         pathline.SetNextTime(1000);
         pathline.SetNextDataSet(pds2);
@@ -451,7 +451,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
       vtkm::cont::PartitionedDataSet out;
       if (fType == FilterType::PARTICLE_ADVECTION)
       {
-        vtkm::filter::ParticleAdvection particleAdvection;
+        vtkm::filter::flow::ParticleAdvection particleAdvection;
 
         particleAdvection.SetStepSize(0.1f);
         particleAdvection.SetNumberOfSteps(100000);
@@ -465,7 +465,7 @@ void TestPartitionedDataSet(vtkm::Id num, bool useGhost, FilterType fType)
         auto pds2 = allPDs2[idx];
         AddVectorFields(pds2, fieldName, vecX);
 
-        vtkm::filter::PathParticle pathParticle;
+        vtkm::filter::flow::PathParticle pathParticle;
         pathParticle.SetPreviousTime(0);
         pathParticle.SetNextTime(1000);
         pathParticle.SetNextDataSet(pds2);
@@ -555,7 +555,7 @@ void TestStreamlineFile(const std::string& fname,
   vtkm::cont::DataSet output;
   if (useSL)
   {
-    vtkm::filter::Streamline streamline;
+    vtkm::filter::flow::Streamline streamline;
     streamline.SetStepSize(stepSize);
     streamline.SetNumberOfSteps(maxSteps);
     streamline.SetSeeds(seedArray);
@@ -564,7 +564,7 @@ void TestStreamlineFile(const std::string& fname,
   }
   else
   {
-    vtkm::filter::ParticleAdvection particleAdvection;
+    vtkm::filter::flow::ParticleAdvection particleAdvection;
     particleAdvection.SetStepSize(stepSize);
     particleAdvection.SetNumberOfSteps(maxSteps);
     particleAdvection.SetSeeds(seedArray);
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
index a122731ec..c79b24629 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
@@ -149,13 +149,13 @@ void TestAMRStreamline(FilterType fType, bool useThreaded)
 
       if (fType == STREAMLINE)
       {
-        vtkm::filter::Streamline streamline;
+        vtkm::filter::flow::Streamline streamline;
         SetFilter(streamline, stepSize, numSteps, fieldName, seedArray, useThreaded);
         out = streamline.Execute(pds);
       }
       else if (fType == PATHLINE)
       {
-        vtkm::filter::Pathline pathline;
+        vtkm::filter::flow::Pathline pathline;
         SetFilter(pathline, stepSize, numSteps, fieldName, seedArray, useThreaded);
         //Create timestep 2
         auto pds2 = vtkm::cont::PartitionedDataSet(pds);
@@ -239,7 +239,7 @@ void TestAMRStreamline(FilterType fType, bool useThreaded)
     }
     else if (fType == PARTICLE_ADVECTION)
     {
-      vtkm::filter::ParticleAdvection filter;
+      vtkm::filter::flow::ParticleAdvection filter;
       filter.SetUseThreadedAlgorithm(useThreaded);
       filter.SetStepSize(0.1f);
       filter.SetNumberOfSteps(100000);
@@ -394,7 +394,7 @@ void TestPartitionedDataSet(vtkm::Id nPerRank, bool useGhost, FilterType fType,
 
     if (fType == STREAMLINE)
     {
-      vtkm::filter::Streamline streamline;
+      vtkm::filter::flow::Streamline streamline;
       SetFilter(streamline, stepSize, numSteps, fieldName, seedArray, useThreaded);
       auto out = streamline.Execute(pds);
 
@@ -403,7 +403,7 @@ void TestPartitionedDataSet(vtkm::Id nPerRank, bool useGhost, FilterType fType,
     }
     else if (fType == PARTICLE_ADVECTION)
     {
-      vtkm::filter::ParticleAdvection particleAdvection;
+      vtkm::filter::flow::ParticleAdvection particleAdvection;
       SetFilter(particleAdvection, stepSize, numSteps, fieldName, seedArray, useThreaded);
       auto out = particleAdvection.Execute(pds);
 
@@ -421,7 +421,7 @@ void TestPartitionedDataSet(vtkm::Id nPerRank, bool useGhost, FilterType fType,
       auto pds2 = allPDS2[n];
       AddVectorFields(pds2, fieldName, vecX);
 
-      vtkm::filter::Pathline pathline;
+      vtkm::filter::flow::Pathline pathline;
       SetFilter(pathline, stepSize, numSteps, fieldName, seedArray, useThreaded);
 
       pathline.SetPreviousTime(time0);

From 38c4365f47a61f3be201f28b3b6a4cc121e14520 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 22 Jul 2022 13:01:51 -0400
Subject: [PATCH 039/104] Remove deleted header.

---
 vtkm/filter/flow/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index 5226a77e3..fc1d7adda 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -18,7 +18,6 @@ set(flow_headers
   NewFilterParticleAdvection.h
   NewFilterParticleAdvectionSteadyState.h
   NewFilterParticleAdvectionUnsteadyState.h
-  ParticleAdvectionAlgorithm.h
   ParticleAdvectionTypes.h
   ParticleAdvector.h
   ParticleMessenger.h

From 18978c625a110be3079e243cbad00c9f2a0cb1e0 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 22 Jul 2022 13:12:40 -0400
Subject: [PATCH 040/104] Delete old filter base classes.

---
 vtkm/filter/FilterParticleAdvection.h         | 110 ------------------
 vtkm/filter/FilterParticleAdvection.hxx       |  86 --------------
 vtkm/filter/FilterTemporalParticleAdvection.h |  76 ------------
 .../FilterTemporalParticleAdvection.hxx       |  83 -------------
 vtkm/filter/flow/CMakeLists.txt               |   2 +-
 vtkm/filter/flow/DataSetIntegrator.h          |   2 +-
 .../{ParticleAdvectionTypes.h => FlowTypes.h} |   7 +-
 vtkm/filter/flow/NewFilterParticleAdvection.h |   2 +-
 vtkm/filter/flow/ParticleAdvection.cxx        |   1 -
 vtkm/filter/flow/ParticleAdvection.h          |   2 +-
 vtkm/filter/flow/PathParticle.cxx             |   1 -
 vtkm/filter/flow/PathParticle.h               |   2 +-
 vtkm/filter/flow/Pathline.cxx                 |   1 -
 vtkm/filter/flow/Pathline.h                   |   2 +-
 vtkm/filter/flow/Streamline.cxx               |   1 -
 vtkm/filter/flow/Streamline.h                 |   2 +-
 16 files changed, 10 insertions(+), 370 deletions(-)
 delete mode 100644 vtkm/filter/FilterParticleAdvection.h
 delete mode 100644 vtkm/filter/FilterParticleAdvection.hxx
 delete mode 100644 vtkm/filter/FilterTemporalParticleAdvection.h
 delete mode 100644 vtkm/filter/FilterTemporalParticleAdvection.hxx
 rename vtkm/filter/flow/{ParticleAdvectionTypes.h => FlowTypes.h} (83%)

diff --git a/vtkm/filter/FilterParticleAdvection.h b/vtkm/filter/FilterParticleAdvection.h
deleted file mode 100644
index 606175ae1..000000000
--- a/vtkm/filter/FilterParticleAdvection.h
+++ /dev/null
@@ -1,110 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_FilterParticleAdvection_h
-#define vtk_m_filter_FilterParticleAdvection_h
-
-#include <vtkm/Particle.h>
-#include <vtkm/filter/FilterDataSetWithField.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-#include <vtkm/filter/particleadvection/ParticleAdvectionTypes.h>
-
-namespace vtkm
-{
-namespace filter
-{
-/// \brief base class for advecting particles in a vector field.
-
-/// Takes as input a vector field and seed locations and advects the seeds
-/// through the flow field.
-
-template <class Derived, typename ParticleType>
-class FilterParticleAdvection : public vtkm::filter::FilterDataSetWithField<Derived>
-{
-public:
-  using SupportedTypes = vtkm::TypeListFieldVec3;
-
-  VTKM_CONT
-  FilterParticleAdvection();
-
-  VTKM_CONT
-  void SetStepSize(vtkm::FloatDefault s) { this->StepSize = s; }
-
-  VTKM_CONT
-  void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; }
-
-  VTKM_CONT
-  void SetSeeds(const std::vector<ParticleType>& seeds,
-                vtkm::CopyFlag copyFlag = vtkm::CopyFlag::On)
-  {
-    this->Seeds = vtkm::cont::make_ArrayHandle(seeds, copyFlag);
-  }
-
-  VTKM_CONT
-  void SetSolverRK4()
-  {
-    this->SolverType = vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE;
-  }
-  VTKM_CONT
-  void SetSolverEuler()
-  {
-    this->SolverType = vtkm::filter::particleadvection::IntegrationSolverType::EULER_TYPE;
-  }
-
-  VTKM_CONT
-  void SetSeeds(vtkm::cont::ArrayHandle<ParticleType>& seeds) { this->Seeds = seeds; }
-
-  VTKM_CONT
-  bool GetUseThreadedAlgorithm() { return this->UseThreadedAlgorithm; }
-
-  VTKM_CONT
-  void SetUseThreadedAlgorithm(bool val) { this->UseThreadedAlgorithm = val; }
-
-  template <typename DerivedPolicy>
-  VTKM_CONT vtkm::cont::DataSet PrepareForExecution(const vtkm::cont::DataSet& input,
-                                                    vtkm::filter::PolicyBase<DerivedPolicy> policy);
-
-  template <typename DerivedPolicy>
-  VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet&,
-                                    const vtkm::cont::Field&,
-                                    vtkm::filter::PolicyBase<DerivedPolicy>)
-  {
-    return false;
-  }
-
-protected:
-  VTKM_CONT virtual void ValidateOptions() const;
-
-  /*
-  VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegrator>
-  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
-                           const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
-  */
-
-  vtkm::Id NumberOfSteps;
-  vtkm::filter::particleadvection::ParticleAdvectionResultType ResultType =
-    vtkm::filter::particleadvection::ParticleAdvectionResultType::UNKNOWN_TYPE;
-  vtkm::cont::ArrayHandle<ParticleType> Seeds;
-  vtkm::filter::particleadvection::IntegrationSolverType SolverType;
-  vtkm::FloatDefault StepSize;
-  bool UseThreadedAlgorithm;
-  vtkm::filter::particleadvection::VectorFieldType VecFieldType;
-
-private:
-};
-}
-} // namespace vtkm::filter
-
-#ifndef vtk_m_filter_FilterParticleAdvection_hxx
-#include <vtkm/filter/FilterParticleAdvection.hxx>
-#endif
-
-#endif // vtk_m_filter_FilterParticleAdvection_h
diff --git a/vtkm/filter/FilterParticleAdvection.hxx b/vtkm/filter/FilterParticleAdvection.hxx
deleted file mode 100644
index 0cdbf858b..000000000
--- a/vtkm/filter/FilterParticleAdvection.hxx
+++ /dev/null
@@ -1,86 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-#ifndef vtk_m_filter_FilterParticleAdvection_hxx
-#define vtk_m_filter_FilterParticleAdvection_hxx
-
-#include <vtkm/filter/FilterParticleAdvection.h>
-
-namespace vtkm
-{
-namespace filter
-{
-
-//-----------------------------------------------------------------------------
-template <typename Derived, typename ParticleType>
-inline VTKM_CONT FilterParticleAdvection<Derived, ParticleType>::FilterParticleAdvection()
-  : vtkm::filter::FilterDataSetWithField<Derived>()
-  , NumberOfSteps(0)
-  , SolverType(vtkm::filter::particleadvection::IntegrationSolverType::RK4_TYPE)
-  , StepSize(0)
-  , UseThreadedAlgorithm(false)
-{
-}
-
-template <typename Derived, typename ParticleType>
-void FilterParticleAdvection<Derived, ParticleType>::ValidateOptions() const
-{
-  if (this->GetUseCoordinateSystemAsField())
-    throw vtkm::cont::ErrorFilterExecution("Coordinate system as field not supported");
-  if (this->Seeds.GetNumberOfValues() == 0)
-    throw vtkm::cont::ErrorFilterExecution("No seeds provided.");
-  if (this->NumberOfSteps == 0)
-    throw vtkm::cont::ErrorFilterExecution("Number of steps not specified.");
-  if (this->StepSize == 0)
-    throw vtkm::cont::ErrorFilterExecution("Step size not specified.");
-}
-
-/*
-template <typename Derived, typename ParticleType>
-std::vector<vtkm::filter::particleadvection::DataSetIntegrator>
-FilterParticleAdvection<Derived, ParticleType>::CreateDataSetIntegrators(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
-{
-  using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
-
-  std::vector<DSIType> dsi;
-
-  if (boundsMap.GetTotalNumBlocks() == 0)
-    throw vtkm::cont::ErrorFilterExecution("No input datasets.");
-
-  std::string activeField = this->GetActiveFieldName();
-
-  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
-  {
-    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-    auto ds = input.GetPartition(i);
-    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
-      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
-    dsi.push_back(DSIType(ds, blockId, activeField));
-  }
-
-  return dsi;
-}
-  */
-
-//-----------------------------------------------------------------------------
-template <typename Derived, typename ParticleType>
-template <typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::DataSet
-FilterParticleAdvection<Derived, ParticleType>::PrepareForExecution(
-  const vtkm::cont::DataSet& input,
-  vtkm::filter::PolicyBase<DerivedPolicy> policy)
-{
-  return (static_cast<Derived*>(this))->DoExecute(input, policy);
-}
-
-}
-} // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/FilterTemporalParticleAdvection.h b/vtkm/filter/FilterTemporalParticleAdvection.h
deleted file mode 100644
index c75e0e506..000000000
--- a/vtkm/filter/FilterTemporalParticleAdvection.h
+++ /dev/null
@@ -1,76 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_TemporalFilterParticleAdvection_h
-#define vtk_m_filter_TemporalFilterParticleAdvection_h
-
-#include <vtkm/Particle.h>
-#include <vtkm/filter/FilterParticleAdvection.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/DataSetIntegrator.h>
-
-namespace vtkm
-{
-namespace filter
-{
-/// \brief base class for advecting particles in a vector field.
-
-/// Takes as input a vector field and seed locations and advects the seeds
-/// through the flow field.
-
-template <class Derived, typename ParticleType>
-class FilterTemporalParticleAdvection
-  : public vtkm::filter::FilterParticleAdvection<Derived, ParticleType>
-{
-public:
-  VTKM_CONT
-  FilterTemporalParticleAdvection();
-
-  VTKM_CONT
-  void SetPreviousTime(vtkm::FloatDefault t) { this->PreviousTime = t; }
-  VTKM_CONT
-  void SetNextTime(vtkm::FloatDefault t) { this->NextTime = t; }
-
-  VTKM_CONT
-  void SetNextDataSet(const vtkm::cont::DataSet& ds)
-  {
-    this->NextDataSet = vtkm::cont::PartitionedDataSet(ds);
-  }
-
-  VTKM_CONT
-  void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->NextDataSet = pds; }
-
-  template <typename DerivedPolicy>
-  VTKM_CONT vtkm::cont::DataSet PrepareForExecution(const vtkm::cont::DataSet& input,
-                                                    vtkm::filter::PolicyBase<DerivedPolicy> policy);
-
-protected:
-  VTKM_CONT virtual void ValidateOptions(
-    const vtkm::cont::PartitionedDataSet& input) const override;
-  using vtkm::filter::FilterParticleAdvection<Derived, ParticleType>::ValidateOptions;
-
-  VTKM_CONT std::vector<vtkm::filter::particleadvection::TemporalDataSetIntegrator>
-  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
-                           const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
-
-  vtkm::FloatDefault PreviousTime;
-  vtkm::FloatDefault NextTime;
-  vtkm::cont::PartitionedDataSet NextDataSet;
-
-private:
-};
-}
-} // namespace vtkm::filter
-
-#ifndef vtk_m_filter_FilterTemporalParticleAdvection_hxx
-#include <vtkm/filter/FilterTemporalParticleAdvection.hxx>
-#endif
-
-#endif // vtk_m_filter_FilterTemporalParticleAdvection_h
diff --git a/vtkm/filter/FilterTemporalParticleAdvection.hxx b/vtkm/filter/FilterTemporalParticleAdvection.hxx
deleted file mode 100644
index 983d82b3d..000000000
--- a/vtkm/filter/FilterTemporalParticleAdvection.hxx
+++ /dev/null
@@ -1,83 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-#ifndef vtk_m_filter_FilterTemporalParticleAdvection_hxx
-#define vtk_m_filter_FilterTemporalParticleAdvection_hxx
-
-#include <vtkm/filter/FilterTemporalParticleAdvection.h>
-
-namespace vtkm
-{
-namespace filter
-{
-
-//-----------------------------------------------------------------------------
-template <typename Derived, typename ParticleType>
-inline VTKM_CONT
-FilterTemporalParticleAdvection<Derived, ParticleType>::FilterTemporalParticleAdvection()
-  : vtkm::filter::FilterParticleAdvection<Derived, ParticleType>()
-  , PreviousTime(0)
-  , NextTime(0)
-{
-}
-
-template <typename Derived, typename ParticleType>
-void FilterTemporalParticleAdvection<Derived, ParticleType>::ValidateOptions(
-  const vtkm::cont::PartitionedDataSet& input) const override
-{
-  this->vtkm::filter::FilterParticleAdvection<Derived, ParticleType>::ValidateOptions();
-
-  if (this->NextDataSet.GetNumberOfPartitions() != input.GetNumberOfPartitions())
-    throw vtkm::cont::ErrorFilterExecution("Number of partitions do not match");
-  if (!(this->PreviousTime < this->NextTime))
-    throw vtkm::cont::ErrorFilterExecution("Previous time must be less than Next time.");
-}
-
-template <typename Derived, typename ParticleType>
-std::vector<vtkm::filter::particleadvection::TemporalDataSetIntegrator>
-FilterTemporalParticleAdvection<Derived, ParticleType>::CreateDataSetIntegrators(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
-{
-  using DSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
-  std::vector<DSIType> dsi;
-  std::string activeField = this->GetActiveFieldName();
-
-  if (boundsMap.GetTotalNumBlocks() == 0)
-    throw vtkm::cont::ErrorFilterExecution("No input datasets.");
-
-  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
-  {
-    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-    auto dsPrev = input.GetPartition(i);
-    auto dsNext = this->NextDataSet.GetPartition(i);
-    if (!(dsPrev.HasPointField(activeField) || dsPrev.HasCellField(activeField)) ||
-        !(dsNext.HasPointField(activeField) || dsNext.HasCellField(activeField)))
-      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
-    dsi.push_back(
-      DSIType(dsPrev, this->PreviousTime, dsNext, this->NextTime, blockId, activeField));
-  }
-
-  return dsi;
-}
-
-//-----------------------------------------------------------------------------
-template <typename Derived, typename ParticleType>
-template <typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::DataSet
-FilterTemporalParticleAdvection<Derived, ParticleType>::PrepareForExecution(
-  const vtkm::cont::DataSet& input,
-  vtkm::filter::PolicyBase<DerivedPolicy> policy)
-{
-  return (static_cast<Derived*>(this))->DoExecute(input, policy);
-}
-
-}
-} // namespace vtkm::filter
-#endif
diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index fc1d7adda..7197750ad 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -18,7 +18,7 @@ set(flow_headers
   NewFilterParticleAdvection.h
   NewFilterParticleAdvectionSteadyState.h
   NewFilterParticleAdvectionUnsteadyState.h
-  ParticleAdvectionTypes.h
+  FlowTypes.h
   ParticleAdvector.h
   ParticleMessenger.h
   ParticleAdvection.h
diff --git a/vtkm/filter/flow/DataSetIntegrator.h b/vtkm/filter/flow/DataSetIntegrator.h
index 301a9874f..8ef46d06e 100644
--- a/vtkm/filter/flow/DataSetIntegrator.h
+++ b/vtkm/filter/flow/DataSetIntegrator.h
@@ -15,7 +15,7 @@
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/cont/ParticleArrayCopy.h>
 #include <vtkm/filter/flow/BoundsMap.h>
-#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/worklet/ParticleAdvection.h>
 #include <vtkm/worklet/particleadvection/EulerIntegrator.h>
 #include <vtkm/worklet/particleadvection/IntegratorStatus.h>
diff --git a/vtkm/filter/flow/ParticleAdvectionTypes.h b/vtkm/filter/flow/FlowTypes.h
similarity index 83%
rename from vtkm/filter/flow/ParticleAdvectionTypes.h
rename to vtkm/filter/flow/FlowTypes.h
index 5d9b97ea7..1099422ce 100644
--- a/vtkm/filter/flow/ParticleAdvectionTypes.h
+++ b/vtkm/filter/flow/FlowTypes.h
@@ -7,8 +7,8 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-#ifndef vtk_m_filter_flow_ParticleAdvectionTypes_h
-#define vtk_m_filter_flow_ParticleAdvectionTypes_h
+#ifndef vtk_m_filter_flow_FlowTypes_h
+#define vtk_m_filter_flow_FlowTypes_h
 
 namespace vtkm
 {
@@ -39,5 +39,4 @@ enum class FlowResultType
 }
 }
 
-
-#endif // vtk_m_filter_flow_ParticleAdvectionTypes_h
+#endif // vtk_m_filter_flow_FlowTypes_h
diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index da292c38c..cb511d2f1 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -17,7 +17,7 @@
 #include <vtkm/filter/flow/DataSetIntegrator.h>
 #include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
 #include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
+#include <vtkm/filter/flow/FlowTypes.h>
 
 namespace vtkm
 {
diff --git a/vtkm/filter/flow/ParticleAdvection.cxx b/vtkm/filter/flow/ParticleAdvection.cxx
index dafa80703..7f88183ad 100644
--- a/vtkm/filter/flow/ParticleAdvection.cxx
+++ b/vtkm/filter/flow/ParticleAdvection.cxx
@@ -13,7 +13,6 @@
 #include <vtkm/filter/flow/ParticleAdvection.h>
 
 #include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
 #include <vtkm/filter/flow/ParticleAdvector.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/ParticleAdvection.h b/vtkm/filter/flow/ParticleAdvection.h
index 0ef95a9b8..f51e025c8 100644
--- a/vtkm/filter/flow/ParticleAdvection.h
+++ b/vtkm/filter/flow/ParticleAdvection.h
@@ -12,8 +12,8 @@
 #define vtk_m_filter_flow_ParticleAdvection_h
 
 #include <vtkm/Particle.h>
+#include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/PathParticle.cxx b/vtkm/filter/flow/PathParticle.cxx
index a0cc6227d..95b7c9093 100644
--- a/vtkm/filter/flow/PathParticle.cxx
+++ b/vtkm/filter/flow/PathParticle.cxx
@@ -13,7 +13,6 @@
 #include <vtkm/filter/flow/PathParticle.h>
 
 #include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
 #include <vtkm/filter/flow/ParticleAdvector.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/PathParticle.h b/vtkm/filter/flow/PathParticle.h
index aac9fc757..c0c6034f3 100644
--- a/vtkm/filter/flow/PathParticle.h
+++ b/vtkm/filter/flow/PathParticle.h
@@ -12,8 +12,8 @@
 #define vtk_m_filter_PathParticle_h
 
 #include <vtkm/Particle.h>
+#include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/Pathline.cxx b/vtkm/filter/flow/Pathline.cxx
index 9de866049..abf9d7f75 100644
--- a/vtkm/filter/flow/Pathline.cxx
+++ b/vtkm/filter/flow/Pathline.cxx
@@ -13,7 +13,6 @@
 #include <vtkm/filter/flow/Pathline.h>
 
 #include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
 #include <vtkm/filter/flow/ParticleAdvector.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/Pathline.h b/vtkm/filter/flow/Pathline.h
index 8ffe0d755..844e7301a 100644
--- a/vtkm/filter/flow/Pathline.h
+++ b/vtkm/filter/flow/Pathline.h
@@ -12,8 +12,8 @@
 #define vtk_m_filter_Pathline_h
 
 #include <vtkm/Particle.h>
+#include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/Streamline.cxx b/vtkm/filter/flow/Streamline.cxx
index 6664183f9..97ff51f38 100644
--- a/vtkm/filter/flow/Streamline.cxx
+++ b/vtkm/filter/flow/Streamline.cxx
@@ -13,7 +13,6 @@
 #include <vtkm/filter/flow/Streamline.h>
 
 #include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
 #include <vtkm/filter/flow/ParticleAdvector.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/Streamline.h b/vtkm/filter/flow/Streamline.h
index 2380bb236..628a326a9 100644
--- a/vtkm/filter/flow/Streamline.h
+++ b/vtkm/filter/flow/Streamline.h
@@ -12,8 +12,8 @@
 #define vtk_m_filter_Streamline_h
 
 #include <vtkm/Particle.h>
+#include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvectionTypes.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm

From 43f7109f3ee044e2affeb8988f3e4cbf39efbc46 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 22 Jul 2022 13:25:39 -0400
Subject: [PATCH 041/104] Fixes for MPI builds.

---
 vtkm/filter/flow/CMakeLists.txt                      |  3 +++
 vtkm/filter/flow/Messenger.h                         |  6 ++++--
 vtkm/filter/flow/ParticleMessenger.h                 |  2 +-
 vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx | 10 +++++-----
 4 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index 7197750ad..b8a1ba17c 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -44,6 +44,9 @@ vtkm_library(
 
 target_link_libraries(vtkm_filter_flow PUBLIC vtkm_worklet vtkm_filter_core)
 target_link_libraries(vtkm_filter PUBLIC INTERFACE vtkm_filter_flow)
+if (VTKm_ENABLE_MPI)
+  target_link_libraries(vtkm_filter_flow PUBLIC MPI::MPI_CXX)
+endif()
 
 #add_subdirectory(worklet)
 
diff --git a/vtkm/filter/flow/Messenger.h b/vtkm/filter/flow/Messenger.h
index f11cc5833..2d874feec 100644
--- a/vtkm/filter/flow/Messenger.h
+++ b/vtkm/filter/flow/Messenger.h
@@ -13,6 +13,7 @@
 
 #include <vtkm/Types.h>
 #include <vtkm/cont/Serialization.h>
+#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 #include <vtkm/thirdparty/diy/diy.h>
 
 #include <list>
@@ -31,7 +32,7 @@ namespace filter
 namespace flow
 {
 
-class Messenger
+class VTKM_FILTER_FLOW_EXPORT Messenger
 {
 public:
   VTKM_CONT Messenger(vtkmdiy::mpi::communicator& comm);
@@ -104,9 +105,10 @@ protected:
   static constexpr int Rank = 0;
 #endif
 };
+
 }
 }
-} // namespace vtkm::filter::flow
+} // namespace vtk_m_filter_flow_Messenger_h
 
 
 #endif
diff --git a/vtkm/filter/flow/ParticleMessenger.h b/vtkm/filter/flow/ParticleMessenger.h
index 260bf442f..c20729ee8 100644
--- a/vtkm/filter/flow/ParticleMessenger.h
+++ b/vtkm/filter/flow/ParticleMessenger.h
@@ -29,7 +29,7 @@ namespace flow
 {
 
 template <typename ParticleType>
-class ParticleMessenger : public vtkm::filter::flow::Messenger
+class VTKM_FILTER_FLOW_EXPORT ParticleMessenger : public vtkm::filter::flow::Messenger
 {
   //sendRank, message
   using MsgCommType = std::pair<int, std::vector<int>>;
diff --git a/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx b/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx
index c390b7705..1ea6d22a8 100644
--- a/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx
+++ b/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx
@@ -10,7 +10,7 @@
 
 #include <vtkm/cont/Serialization.h>
 #include <vtkm/cont/testing/Testing.h>
-#include <vtkm/filter/particleadvection/ParticleMessenger.h>
+#include <vtkm/filter/flow/ParticleMessenger.h>
 
 #include <vtkm/thirdparty/diy/diy.h>
 
@@ -23,11 +23,11 @@ using MCommType = std::pair<int, std::vector<int>>;
 using PCommType = std::pair<vtkm::Particle, std::vector<vtkm::Id>>;
 using PRecvCommType = std::pair<int, std::vector<PCommType>>;
 
-class TestMessenger : public vtkm::filter::particleadvection::ParticleMessenger<vtkm::Particle>
+class TestMessenger : public vtkm::filter::flow::ParticleMessenger<vtkm::Particle>
 {
 public:
   TestMessenger(vtkmdiy::mpi::communicator& comm,
-                const vtkm::filter::particleadvection::BoundsMap& bm,
+                const vtkm::filter::flow::BoundsMap& bm,
                 int msgSz = 1,
                 int numParticles = 1,
                 int numBlockIds = 1)
@@ -120,7 +120,7 @@ void TestParticleMessenger()
   //Only works for 2 or more ranks.
   if (comm.size() == 1)
     return;
-  vtkm::filter::particleadvection::BoundsMap boundsMap;
+  vtkm::filter::flow::BoundsMap boundsMap;
 
   int maxMsgSz = 100;
   int maxNumParticles = 128;
@@ -244,7 +244,7 @@ void TestBufferSizes()
 {
   //Make sure the buffer sizes are correct.
   auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
-  vtkm::filter::particleadvection::BoundsMap boundsMap;
+  vtkm::filter::flow::BoundsMap boundsMap;
 
   std::vector<int> mSzs = { 1, 2, 3, 4, 5 };
   std::vector<int> numPs = { 1, 2, 3, 4, 5 };

From ed11e447d0f3788fc94850aa6eb2eec24c360069 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 22 Jul 2022 15:31:58 -0400
Subject: [PATCH 042/104] Move the worklets over to filter/flow.

---
 vtkm/Particle.h                               |  28 ++++
 vtkm/filter/Lagrangian.hxx                    |  24 ++--
 vtkm/filter/LagrangianStructures.h            |   6 +-
 vtkm/filter/LagrangianStructures.hxx          |  22 ++--
 vtkm/filter/StreamSurface.h                   |   6 +-
 vtkm/filter/StreamSurface.hxx                 |  22 ++--
 vtkm/filter/flow/CMakeLists.txt               |   2 +-
 vtkm/filter/flow/DataSetIntegrator.h          |  26 ++--
 .../flow/DataSetIntegratorSteadyState.h       |  45 ++++---
 .../flow/DataSetIntegratorUnsteadyState.h     |  54 ++++----
 vtkm/filter/flow/ParticleAdvector.h           |  12 +-
 vtkm/filter/flow/ParticleMessenger.h          |   4 +-
 .../flow/worklet}/CMakeLists.txt              |   1 +
 .../flow/worklet}/CellInterpolationHelper.h   |   6 +-
 .../flow/worklet}/EulerIntegrator.h           |  14 +-
 .../flow/worklet}/Field.h                     |  15 ++-
 .../flow/worklet}/GridEvaluatorStatus.h       |   9 +-
 .../flow/worklet}/GridEvaluators.h            |  20 +--
 .../flow/worklet}/IntegratorStatus.h          |  16 +--
 .../flow}/worklet/ParticleAdvection.h         |  27 ++--
 .../flow/worklet}/ParticleAdvectionWorklets.h |  30 ++---
 .../flow/worklet}/Particles.h                 |  30 +++--
 .../flow/worklet}/RK4Integrator.h             |  14 +-
 .../flow/worklet}/Stepper.h                   |  20 +--
 .../flow/worklet}/TemporalGridEvaluators.h    |  25 ++--
 vtkm/worklet/CMakeLists.txt                   |   2 -
 .../testing/UnitTestParticleAdvection.cxx     | 120 +++++++++---------
 .../testing/UnitTestTemporalAdvection.cxx     |  20 +--
 28 files changed, 326 insertions(+), 294 deletions(-)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/CMakeLists.txt (97%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/CellInterpolationHelper.h (97%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/EulerIntegrator.h (87%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/Field.h (96%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/GridEvaluatorStatus.h (91%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/GridEvaluators.h (94%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/IntegratorStatus.h (91%)
 rename vtkm/{ => filter/flow}/worklet/ParticleAdvection.h (88%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/ParticleAdvectionWorklets.h (90%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/Particles.h (90%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/RK4Integrator.h (92%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/Stepper.h (93%)
 rename vtkm/{worklet/particleadvection => filter/flow/worklet}/TemporalGridEvaluators.h (89%)

diff --git a/vtkm/Particle.h b/vtkm/Particle.h
index 6e545446c..027df2878 100644
--- a/vtkm/Particle.h
+++ b/vtkm/Particle.h
@@ -142,6 +142,17 @@ public:
   vtkm::Id NumSteps = 0;
   vtkm::ParticleStatus Status;
   vtkm::FloatDefault Time = 0;
+
+  static size_t Sizeof()
+  {
+    constexpr std::size_t sz = sizeof(vtkm::Vec3f) // Pos
+      + sizeof(vtkm::Id)                           // ID
+      + sizeof(vtkm::Id)                           // NumSteps
+      + sizeof(vtkm::UInt8)                        // Status
+      + sizeof(vtkm::FloatDefault);                // Time
+
+    return sz;
+  }
 };
 
 class ChargedParticle
@@ -251,6 +262,23 @@ private:
     static_cast<vtkm::FloatDefault>(2.99792458e8);
 
   friend struct mangled_diy_namespace::Serialization<vtkm::ChargedParticle>;
+
+public:
+  static size_t Sizeof()
+  {
+    constexpr std::size_t sz = sizeof(vtkm::Vec3f) // Pos
+      + sizeof(vtkm::Id)                           // ID
+      + sizeof(vtkm::Id)                           // NumSteps
+      + sizeof(vtkm::UInt8)                        // Status
+      + sizeof(vtkm::FloatDefault)                 // Time
+      + sizeof(vtkm::FloatDefault)                 //Mass
+      + sizeof(vtkm::FloatDefault)                 //Charge
+      + sizeof(vtkm::FloatDefault)                 //Weighting
+      + sizeof(vtkm::Vec3f)                        //Momentum
+      + sizeof(vtkm::FloatDefault);                //Speed_of_light
+
+    return sz;
+  }
 };
 
 } //namespace vtkm
diff --git a/vtkm/filter/Lagrangian.hxx b/vtkm/filter/Lagrangian.hxx
index 260b63c7e..f0bd02539 100644
--- a/vtkm/filter/Lagrangian.hxx
+++ b/vtkm/filter/Lagrangian.hxx
@@ -21,13 +21,13 @@
 #include <vtkm/cont/DataSetBuilderRectilinear.h>
 #include <vtkm/cont/DeviceAdapter.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/worklet/ParticleAdvection.h>
+#include <vtkm/filter/flow/worklet/Field.h>
+#include <vtkm/filter/flow/worklet/GridEvaluators.h>
+#include <vtkm/filter/flow/worklet/ParticleAdvection.h>
+#include <vtkm/filter/flow/worklet/Particles.h>
+#include <vtkm/filter/flow/worklet/RK4Integrator.h>
+#include <vtkm/filter/flow/worklet/Stepper.h>
 #include <vtkm/worklet/WorkletMapField.h>
-#include <vtkm/worklet/particleadvection/Field.h>
-#include <vtkm/worklet/particleadvection/GridEvaluators.h>
-#include <vtkm/worklet/particleadvection/Particles.h>
-#include <vtkm/worklet/particleadvection/RK4Integrator.h>
-#include <vtkm/worklet/particleadvection/Stepper.h>
 
 #include <cstring>
 #include <sstream>
@@ -274,13 +274,13 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
   vtkm::Bounds bounds = input.GetCoordinateSystem().GetBounds();
 
   using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>;
-  using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-  using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-  using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-  using Stepper = vtkm::worklet::particleadvection::Stepper<RK4Type, GridEvalType>;
+  using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+  using GridEvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
+  using RK4Type = vtkm::worklet::flow::RK4Integrator<GridEvalType>;
+  using Stepper = vtkm::worklet::flow::Stepper<RK4Type, GridEvalType>;
 
-  vtkm::worklet::ParticleAdvection particleadvection;
-  vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
+  vtkm::worklet::flow::ParticleAdvection particleadvection;
+  vtkm::worklet::flow::ParticleAdvectionResult<vtkm::Particle> res;
 
   FieldType velocities(field, fieldMeta.GetAssociation());
   GridEvalType gridEval(coords, cells, velocities);
diff --git a/vtkm/filter/LagrangianStructures.h b/vtkm/filter/LagrangianStructures.h
index 9d1c2293c..0b7bff84f 100644
--- a/vtkm/filter/LagrangianStructures.h
+++ b/vtkm/filter/LagrangianStructures.h
@@ -15,9 +15,9 @@
 
 #include <vtkm/filter/FilterDataSetWithField.h>
 
-#include <vtkm/worklet/ParticleAdvection.h>
-#include <vtkm/worklet/particleadvection/GridEvaluators.h>
-#include <vtkm/worklet/particleadvection/Stepper.h>
+#include <vtkm/filter/flow/worklet/GridEvaluators.h>
+#include <vtkm/filter/flow/worklet/ParticleAdvection.h>
+#include <vtkm/filter/flow/worklet/Stepper.h>
 
 namespace vtkm
 {
diff --git a/vtkm/filter/LagrangianStructures.hxx b/vtkm/filter/LagrangianStructures.hxx
index ed2cafad8..24f747392 100644
--- a/vtkm/filter/LagrangianStructures.hxx
+++ b/vtkm/filter/LagrangianStructures.hxx
@@ -14,11 +14,11 @@
 #include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/cont/Invoker.h>
-#include <vtkm/worklet/particleadvection/Field.h>
-#include <vtkm/worklet/particleadvection/GridEvaluators.h>
-#include <vtkm/worklet/particleadvection/Particles.h>
-#include <vtkm/worklet/particleadvection/RK4Integrator.h>
-#include <vtkm/worklet/particleadvection/Stepper.h>
+#include <vtkm/filter/flow/worklet/Field.h>
+#include <vtkm/filter/flow/worklet/GridEvaluators.h>
+#include <vtkm/filter/flow/worklet/Particles.h>
+#include <vtkm/filter/flow/worklet/RK4Integrator.h>
+#include <vtkm/filter/flow/worklet/Stepper.h>
 
 #include <vtkm/worklet/LagrangianStructures.h>
 
@@ -79,10 +79,10 @@ inline VTKM_CONT vtkm::cont::DataSet LagrangianStructures::DoExecute(
   using Structured3DType = vtkm::cont::CellSetStructured<3>;
 
   using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>;
-  using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-  using GridEvaluator = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-  using IntegratorType = vtkm::worklet::particleadvection::RK4Integrator<GridEvaluator>;
-  using Stepper = vtkm::worklet::particleadvection::Stepper<IntegratorType, GridEvaluator>;
+  using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+  using GridEvaluator = vtkm::worklet::flow::GridEvaluator<FieldType>;
+  using IntegratorType = vtkm::worklet::flow::RK4Integrator<GridEvaluator>;
+  using Stepper = vtkm::worklet::flow::Stepper<IntegratorType, GridEvaluator>;
 
   vtkm::FloatDefault stepSize = this->GetStepSize();
   vtkm::Id numberOfSteps = this->GetNumberOfSteps();
@@ -135,8 +135,8 @@ inline VTKM_CONT vtkm::cont::DataSet LagrangianStructures::DoExecute(
     FieldType velocities(field, fieldMeta.GetAssociation());
     GridEvaluator evaluator(input.GetCoordinateSystem(), input.GetCellSet(), velocities);
     Stepper integrator(evaluator, stepSize);
-    vtkm::worklet::ParticleAdvection particles;
-    vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> advectionResult;
+    vtkm::worklet::flow::ParticleAdvection particles;
+    vtkm::worklet::flow::ParticleAdvectionResult<vtkm::Particle> advectionResult;
     vtkm::cont::ArrayHandle<vtkm::Particle> advectionPoints;
     invoke(detail::MakeParticles{}, lcsInputPoints, advectionPoints);
     advectionResult = particles.Run(integrator, advectionPoints, numberOfSteps);
diff --git a/vtkm/filter/StreamSurface.h b/vtkm/filter/StreamSurface.h
index bfb2dcdc4..1e3b1491f 100644
--- a/vtkm/filter/StreamSurface.h
+++ b/vtkm/filter/StreamSurface.h
@@ -12,10 +12,10 @@
 #define vtk_m_filter_StreamSurface_h
 
 #include <vtkm/filter/FilterDataSetWithField.h>
-#include <vtkm/worklet/ParticleAdvection.h>
+#include <vtkm/filter/flow/worklet/GridEvaluators.h>
+#include <vtkm/filter/flow/worklet/ParticleAdvection.h>
+#include <vtkm/filter/flow/worklet/Stepper.h>
 #include <vtkm/worklet/StreamSurface.h>
-#include <vtkm/worklet/particleadvection/GridEvaluators.h>
-#include <vtkm/worklet/particleadvection/Stepper.h>
 
 namespace vtkm
 {
diff --git a/vtkm/filter/StreamSurface.hxx b/vtkm/filter/StreamSurface.hxx
index 6e21f6452..05ba2ea6e 100644
--- a/vtkm/filter/StreamSurface.hxx
+++ b/vtkm/filter/StreamSurface.hxx
@@ -16,12 +16,12 @@
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/worklet/ParticleAdvection.h>
-#include <vtkm/worklet/particleadvection/Field.h>
-#include <vtkm/worklet/particleadvection/GridEvaluators.h>
-#include <vtkm/worklet/particleadvection/Particles.h>
-#include <vtkm/worklet/particleadvection/RK4Integrator.h>
-#include <vtkm/worklet/particleadvection/Stepper.h>
+#include <vtkm/filter/flow/worklet/Field.h>
+#include <vtkm/filter/flow/worklet/GridEvaluators.h>
+#include <vtkm/filter/flow/worklet/ParticleAdvection.h>
+#include <vtkm/filter/flow/worklet/Particles.h>
+#include <vtkm/filter/flow/worklet/RK4Integrator.h>
+#include <vtkm/filter/flow/worklet/Stepper.h>
 
 namespace vtkm
 {
@@ -52,17 +52,17 @@ inline VTKM_CONT vtkm::cont::DataSet StreamSurface::DoExecute(
     input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex());
 
   using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>;
-  using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-  using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-  using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-  using Stepper = vtkm::worklet::particleadvection::Stepper<RK4Type, GridEvalType>;
+  using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+  using GridEvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
+  using RK4Type = vtkm::worklet::flow::RK4Integrator<GridEvalType>;
+  using Stepper = vtkm::worklet::flow::Stepper<RK4Type, GridEvalType>;
 
   //compute streamlines
   FieldType velocities(field, fieldMeta.GetAssociation());
   GridEvalType eval(coords, cells, velocities);
   Stepper rk4(eval, this->StepSize);
 
-  vtkm::worklet::Streamline streamline;
+  vtkm::worklet::flow::Streamline streamline;
 
   vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
   vtkm::cont::ArrayCopy(this->Seeds, seedArray);
diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index b8a1ba17c..3106cd8e1 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -48,7 +48,7 @@ if (VTKm_ENABLE_MPI)
   target_link_libraries(vtkm_filter_flow PUBLIC MPI::MPI_CXX)
 endif()
 
-#add_subdirectory(worklet)
+add_subdirectory(worklet)
 
 #-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
 #if (VTKm_ENABLE_TESTING)
diff --git a/vtkm/filter/flow/DataSetIntegrator.h b/vtkm/filter/flow/DataSetIntegrator.h
index 8ef46d06e..36c78cf11 100644
--- a/vtkm/filter/flow/DataSetIntegrator.h
+++ b/vtkm/filter/flow/DataSetIntegrator.h
@@ -16,11 +16,11 @@
 #include <vtkm/cont/ParticleArrayCopy.h>
 #include <vtkm/filter/flow/BoundsMap.h>
 #include <vtkm/filter/flow/FlowTypes.h>
-#include <vtkm/worklet/ParticleAdvection.h>
-#include <vtkm/worklet/particleadvection/EulerIntegrator.h>
-#include <vtkm/worklet/particleadvection/IntegratorStatus.h>
-#include <vtkm/worklet/particleadvection/RK4Integrator.h>
-#include <vtkm/worklet/particleadvection/Stepper.h>
+#include <vtkm/filter/flow/worklet/EulerIntegrator.h>
+#include <vtkm/filter/flow/worklet/IntegratorStatus.h>
+#include <vtkm/filter/flow/worklet/ParticleAdvection.h>
+#include <vtkm/filter/flow/worklet/RK4Integrator.h>
+#include <vtkm/filter/flow/worklet/Stepper.h>
 
 #include <vtkm/cont/internal/Variant.h>
 
@@ -63,11 +63,11 @@ protected:
   using FieldNameType =
     vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType>;
 
-  using RType =
-    vtkm::cont::internal::Variant<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>,
-                                  vtkm::worklet::ParticleAdvectionResult<vtkm::ChargedParticle>,
-                                  vtkm::worklet::StreamlineResult<vtkm::Particle>,
-                                  vtkm::worklet::StreamlineResult<vtkm::ChargedParticle>>;
+  using RType = vtkm::cont::internal::Variant<
+    vtkm::worklet::flow::ParticleAdvectionResult<vtkm::Particle>,
+    vtkm::worklet::flow::ParticleAdvectionResult<vtkm::ChargedParticle>,
+    vtkm::worklet::flow::StreamlineResult<vtkm::Particle>,
+    vtkm::worklet::flow::StreamlineResult<vtkm::ChargedParticle>>;
 
 public:
   DataSetIntegrator(vtkm::Id id,
@@ -250,7 +250,7 @@ VTKM_CONT void DataSetIntegrator::UpdateResult(const ResultType<ParticleType>& r
     if (dsiInfo.TermIdx.empty())
       return;
 
-    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+    using ResType = vtkm::worklet::flow::ParticleAdvectionResult<ParticleType>;
     auto indicesAH = vtkm::cont::make_ArrayHandle(dsiInfo.TermIdx, vtkm::CopyFlag::Off);
     auto termPerm = vtkm::cont::make_ArrayHandlePermutation(indicesAH, result.Particles);
 
@@ -273,7 +273,7 @@ VTKM_CONT bool DataSetIntegrator::GetOutput(vtkm::cont::DataSet& ds) const
 
   if (this->IsParticleAdvectionResult())
   {
-    using ResType = vtkm::worklet::ParticleAdvectionResult<ParticleType>;
+    using ResType = vtkm::worklet::flow::ParticleAdvectionResult<ParticleType>;
 
     std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
     allParticles.reserve(nResults);
@@ -300,7 +300,7 @@ VTKM_CONT bool DataSetIntegrator::GetOutput(vtkm::cont::DataSet& ds) const
   }
   else if (this->IsStreamlineResult())
   {
-    using ResType = vtkm::worklet::StreamlineResult<ParticleType>;
+    using ResType = vtkm::worklet::flow::StreamlineResult<ParticleType>;
 
     //Easy case with one result.
     if (nResults == 1)
diff --git a/vtkm/filter/flow/DataSetIntegratorSteadyState.h b/vtkm/filter/flow/DataSetIntegratorSteadyState.h
index f452122d2..4583667ce 100644
--- a/vtkm/filter/flow/DataSetIntegratorSteadyState.h
+++ b/vtkm/filter/flow/DataSetIntegratorSteadyState.h
@@ -45,7 +45,7 @@ public:
 protected:
   template <typename ArrayType>
   VTKM_CONT void GetVelocityField(
-    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField) const
+    vtkm::worklet::flow::VelocityField<ArrayType>& velocityField) const
   {
     if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<VelocityFieldNameType>())
     {
@@ -54,7 +54,7 @@ protected:
       ArrayType arr;
       vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet.GetField(fieldNm).GetData(), arr);
 
-      velocityField = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr, assoc);
+      velocityField = vtkm::worklet::flow::VelocityField<ArrayType>(arr, assoc);
     }
     else
       throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
@@ -68,8 +68,8 @@ private:
 namespace internal
 {
 using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-using SteadyStateGridEvalType = vtkm::worklet::particleadvection::GridEvaluator<VelocityFieldType>;
+using VelocityFieldType = vtkm::worklet::flow::VelocityField<ArrayType>;
+using SteadyStateGridEvalType = vtkm::worklet::flow::GridEvaluator<VelocityFieldType>;
 
 template <typename GridEvalType, typename ParticleType>
 class AdvectHelper;
@@ -84,20 +84,20 @@ public:
                      vtkm::FloatDefault stepSize,
                      vtkm::Id maxSteps,
                      const IntegrationSolverType& solverType,
-                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
+                     vtkm::worklet::flow::ParticleAdvectionResult<ParticleType>& result)
   {
     if (solverType == IntegrationSolverType::RK4_TYPE)
     {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
+      DoAdvect<vtkm::worklet::flow::ParticleAdvection,
+               vtkm::worklet::flow::ParticleAdvectionResult,
+               vtkm::worklet::flow::RK4Integrator>(
         velField, ds, seedArray, stepSize, maxSteps, result);
     }
     else if (solverType == IntegrationSolverType::EULER_TYPE)
     {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
+      DoAdvect<vtkm::worklet::flow::ParticleAdvection,
+               vtkm::worklet::flow::ParticleAdvectionResult,
+               vtkm::worklet::flow::EulerIntegrator>(
         velField, ds, seedArray, stepSize, maxSteps, result);
     }
     else
@@ -110,20 +110,20 @@ public:
                      vtkm::FloatDefault stepSize,
                      vtkm::Id maxSteps,
                      const IntegrationSolverType& solverType,
-                     vtkm::worklet::StreamlineResult<ParticleType>& result)
+                     vtkm::worklet::flow::StreamlineResult<ParticleType>& result)
   {
     if (solverType == IntegrationSolverType::RK4_TYPE)
     {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
+      DoAdvect<vtkm::worklet::flow::Streamline,
+               vtkm::worklet::flow::StreamlineResult,
+               vtkm::worklet::flow::RK4Integrator>(
         velField, ds, seedArray, stepSize, maxSteps, result);
     }
     else if (solverType == IntegrationSolverType::EULER_TYPE)
     {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
+      DoAdvect<vtkm::worklet::flow::Streamline,
+               vtkm::worklet::flow::StreamlineResult,
+               vtkm::worklet::flow::EulerIntegrator>(
         velField, ds, seedArray, stepSize, maxSteps, result);
     }
     else
@@ -143,8 +143,7 @@ public:
                        ResultType<ParticleType>& result)
   {
     using StepperType =
-      vtkm::worklet::particleadvection::Stepper<SolverType<SteadyStateGridEvalType>,
-                                                SteadyStateGridEvalType>;
+      vtkm::worklet::flow::Stepper<SolverType<SteadyStateGridEvalType>, SteadyStateGridEvalType>;
 
     WorkletType worklet;
     SteadyStateGridEvalType eval(ds, velField);
@@ -165,7 +164,7 @@ VTKM_CONT inline void DataSetIntegratorSteadyState::DoAdvect(DSIHelperInfo<vtkm:
 
   if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
   {
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+    using FieldType = vtkm::worklet::flow::VelocityField<ArrayType>;
     FieldType velField;
     this->GetVelocityField(velField);
 
@@ -173,14 +172,14 @@ VTKM_CONT inline void DataSetIntegratorSteadyState::DoAdvect(DSIHelperInfo<vtkm:
 
     if (this->IsParticleAdvectionResult())
     {
-      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
+      vtkm::worklet::flow::ParticleAdvectionResult<vtkm::Particle> result;
       AHType::Advect(
         velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
       this->UpdateResult(result, b);
     }
     else if (this->IsStreamlineResult())
     {
-      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
+      vtkm::worklet::flow::StreamlineResult<vtkm::Particle> result;
       AHType::Advect(
         velField, this->DataSet, seedArray, stepSize, maxSteps, this->SolverType, result);
       this->UpdateResult(result, b);
diff --git a/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h b/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
index 0e692ca3d..46a7a44a8 100644
--- a/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
+++ b/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
@@ -12,7 +12,7 @@
 #define vtk_m_filter_flow_DataSetIntegratorUnsteadyState_h
 
 #include <vtkm/filter/flow/DataSetIntegrator.h>
-#include <vtkm/worklet/particleadvection/TemporalGridEvaluators.h>
+#include <vtkm/filter/flow/worklet/TemporalGridEvaluators.h>
 
 namespace vtkm
 {
@@ -53,8 +53,8 @@ public:
 protected:
   template <typename ArrayType>
   VTKM_CONT void GetVelocityFields(
-    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField1,
-    vtkm::worklet::particleadvection::VelocityField<ArrayType>& velocityField2) const
+    vtkm::worklet::flow::VelocityField<ArrayType>& velocityField1,
+    vtkm::worklet::flow::VelocityField<ArrayType>& velocityField2) const
   {
     if (this->FieldName.GetIndex() == this->FieldName.GetIndexOf<VelocityFieldNameType>())
     {
@@ -68,8 +68,8 @@ protected:
       vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet1.GetField(fieldNm).GetData(), arr1);
       vtkm::cont::ArrayCopyShallowIfPossible(this->DataSet2.GetField(fieldNm).GetData(), arr2);
 
-      velocityField1 = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr1, assoc);
-      velocityField2 = vtkm::worklet::particleadvection::VelocityField<ArrayType>(arr2, assoc);
+      velocityField1 = vtkm::worklet::flow::VelocityField<ArrayType>(arr1, assoc);
+      velocityField2 = vtkm::worklet::flow::VelocityField<ArrayType>(arr2, assoc);
     }
     else
       throw vtkm::cont::ErrorFilterExecution("Velocity field vector type not available");
@@ -87,9 +87,8 @@ private:
 namespace internal
 {
 using ArrayType = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-using VelocityFieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
-using UnsteadyStateGridEvalType =
-  vtkm::worklet::particleadvection::TemporalGridEvaluator<VelocityFieldType>;
+using VelocityFieldType = vtkm::worklet::flow::VelocityField<ArrayType>;
+using UnsteadyStateGridEvalType = vtkm::worklet::flow::TemporalGridEvaluator<VelocityFieldType>;
 
 template <typename GridEvalType, typename ParticleType>
 class AdvectHelper;
@@ -108,20 +107,20 @@ public:
                      vtkm::FloatDefault stepSize,
                      vtkm::Id maxSteps,
                      const IntegrationSolverType& solverType,
-                     vtkm::worklet::ParticleAdvectionResult<ParticleType>& result)
+                     vtkm::worklet::flow::ParticleAdvectionResult<ParticleType>& result)
   {
     if (solverType == IntegrationSolverType::RK4_TYPE)
     {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
+      DoAdvect<vtkm::worklet::flow::ParticleAdvection,
+               vtkm::worklet::flow::ParticleAdvectionResult,
+               vtkm::worklet::flow::RK4Integrator>(
         velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
     }
     else if (solverType == IntegrationSolverType::EULER_TYPE)
     {
-      DoAdvect<vtkm::worklet::ParticleAdvection,
-               vtkm::worklet::ParticleAdvectionResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
+      DoAdvect<vtkm::worklet::flow::ParticleAdvection,
+               vtkm::worklet::flow::ParticleAdvectionResult,
+               vtkm::worklet::flow::EulerIntegrator>(
         velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
     }
     else
@@ -138,20 +137,20 @@ public:
                      vtkm::FloatDefault stepSize,
                      vtkm::Id maxSteps,
                      const IntegrationSolverType& solverType,
-                     vtkm::worklet::StreamlineResult<ParticleType>& result)
+                     vtkm::worklet::flow::StreamlineResult<ParticleType>& result)
   {
     if (solverType == IntegrationSolverType::RK4_TYPE)
     {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::RK4Integrator>(
+      DoAdvect<vtkm::worklet::flow::Streamline,
+               vtkm::worklet::flow::StreamlineResult,
+               vtkm::worklet::flow::RK4Integrator>(
         velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
     }
     else if (solverType == IntegrationSolverType::EULER_TYPE)
     {
-      DoAdvect<vtkm::worklet::Streamline,
-               vtkm::worklet::StreamlineResult,
-               vtkm::worklet::particleadvection::EulerIntegrator>(
+      DoAdvect<vtkm::worklet::flow::Streamline,
+               vtkm::worklet::flow::StreamlineResult,
+               vtkm::worklet::flow::EulerIntegrator>(
         velField1, ds1, t1, velField2, ds2, t2, seedArray, stepSize, maxSteps, result);
     }
     else
@@ -174,9 +173,8 @@ public:
                        vtkm::Id maxSteps,
                        ResultType<ParticleType>& result)
   {
-    using StepperType =
-      vtkm::worklet::particleadvection::Stepper<SolverType<UnsteadyStateGridEvalType>,
-                                                UnsteadyStateGridEvalType>;
+    using StepperType = vtkm::worklet::flow::Stepper<SolverType<UnsteadyStateGridEvalType>,
+                                                     UnsteadyStateGridEvalType>;
 
     WorkletType worklet;
     UnsteadyStateGridEvalType eval(ds1, t1, velField1, ds2, t2, velField2);
@@ -200,13 +198,13 @@ VTKM_CONT inline void DataSetIntegratorUnsteadyState::DoAdvect(DSIHelperInfo<vtk
 
   if (this->VecFieldType == VectorFieldType::VELOCITY_FIELD_TYPE)
   {
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<ArrayType>;
+    using FieldType = vtkm::worklet::flow::VelocityField<ArrayType>;
     FieldType velField1, velField2;
     this->GetVelocityFields(velField1, velField2);
 
     if (this->IsParticleAdvectionResult())
     {
-      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> result;
+      vtkm::worklet::flow::ParticleAdvectionResult<vtkm::Particle> result;
       AHType::Advect(velField1,
                      this->DataSet1,
                      this->Time1,
@@ -222,7 +220,7 @@ VTKM_CONT inline void DataSetIntegratorUnsteadyState::DoAdvect(DSIHelperInfo<vtk
     }
     else if (this->IsStreamlineResult())
     {
-      vtkm::worklet::StreamlineResult<vtkm::Particle> result;
+      vtkm::worklet::flow::StreamlineResult<vtkm::Particle> result;
       AHType::Advect(velField1,
                      this->DataSet1,
                      this->Time1,
diff --git a/vtkm/filter/flow/ParticleAdvector.h b/vtkm/filter/flow/ParticleAdvector.h
index accca6b1c..84c53f678 100644
--- a/vtkm/filter/flow/ParticleAdvector.h
+++ b/vtkm/filter/flow/ParticleAdvector.h
@@ -74,14 +74,14 @@ private:
       if (this->ResultType == vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE)
       {
         using AlgorithmType = vtkm::filter::flow::
-          AdvectAlgorithm<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
+          AdvectAlgorithm<DSIType, vtkm::worklet::flow::ParticleAdvectionResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
       else
       {
         using AlgorithmType = vtkm::filter::flow::
-          AdvectAlgorithm<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
+          AdvectAlgorithm<DSIType, vtkm::worklet::flow::StreamlineResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
@@ -90,15 +90,17 @@ private:
     {
       if (this->ResultType == vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE)
       {
-        using AlgorithmType = vtkm::filter::flow::
-          AdvectAlgorithmThreaded<DSIType, vtkm::worklet::ParticleAdvectionResult, ParticleType>;
+        using AlgorithmType =
+          vtkm::filter::flow::AdvectAlgorithmThreaded<DSIType,
+                                                      vtkm::worklet::flow::ParticleAdvectionResult,
+                                                      ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
       else
       {
         using AlgorithmType = vtkm::filter::flow::
-          AdvectAlgorithmThreaded<DSIType, vtkm::worklet::StreamlineResult, ParticleType>;
+          AdvectAlgorithmThreaded<DSIType, vtkm::worklet::flow::StreamlineResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
diff --git a/vtkm/filter/flow/ParticleMessenger.h b/vtkm/filter/flow/ParticleMessenger.h
index c20729ee8..aa45b143e 100644
--- a/vtkm/filter/flow/ParticleMessenger.h
+++ b/vtkm/filter/flow/ParticleMessenger.h
@@ -131,7 +131,8 @@ template <typename ParticleType>
 std::size_t ParticleMessenger<ParticleType>::CalcParticleBufferSize(std::size_t nParticles,
                                                                     std::size_t nBlockIds)
 {
-  std::size_t pSize = sizeof(ParticleType);
+  ParticleType pTmp;
+  std::size_t pSize = ParticleType::Sizeof();
 
 #ifndef NDEBUG
   vtkmdiy::MemoryBuffer buff;
@@ -139,6 +140,7 @@ std::size_t ParticleMessenger<ParticleType>::CalcParticleBufferSize(std::size_t
   vtkmdiy::save(buff, p);
 
   //Make sure the buffer size is correct.
+  //If this fires, then the size of the class has changed.
   VTKM_ASSERT(pSize == buff.size());
 #endif
 
diff --git a/vtkm/worklet/particleadvection/CMakeLists.txt b/vtkm/filter/flow/worklet/CMakeLists.txt
similarity index 97%
rename from vtkm/worklet/particleadvection/CMakeLists.txt
rename to vtkm/filter/flow/worklet/CMakeLists.txt
index 9afc70707..c52ad4eff 100644
--- a/vtkm/worklet/particleadvection/CMakeLists.txt
+++ b/vtkm/filter/flow/worklet/CMakeLists.txt
@@ -9,6 +9,7 @@
 ##============================================================================
 
 set(headers
+  ParticleAdvection.h
   CellInterpolationHelper.h
   EulerIntegrator.h
   Field.h
diff --git a/vtkm/worklet/particleadvection/CellInterpolationHelper.h b/vtkm/filter/flow/worklet/CellInterpolationHelper.h
similarity index 97%
rename from vtkm/worklet/particleadvection/CellInterpolationHelper.h
rename to vtkm/filter/flow/worklet/CellInterpolationHelper.h
index 52534afbc..1cc507a99 100644
--- a/vtkm/worklet/particleadvection/CellInterpolationHelper.h
+++ b/vtkm/filter/flow/worklet/CellInterpolationHelper.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_worklet_particle_advection_cell_interpolation_helper
-#define vtk_m_worklet_particle_advection_cell_interpolation_helper
+#ifndef vtk_m_filter_flow_worklet_CellInterpolationHelper_h
+#define vtk_m_filter_flow_worklet_CellInterpolationHelper_h
 
 #include <vtkm/CellShape.h>
 #include <vtkm/Types.h>
@@ -282,4 +282,4 @@ private:
 } //namespace cont
 } //namespace vtkm
 
-#endif //vtk_m_worklet_particle_advection_cell_interpolation_helper
+#endif //vtk_m_filter_flow_worklet_CellInterpolationHelper_h
diff --git a/vtkm/worklet/particleadvection/EulerIntegrator.h b/vtkm/filter/flow/worklet/EulerIntegrator.h
similarity index 87%
rename from vtkm/worklet/particleadvection/EulerIntegrator.h
rename to vtkm/filter/flow/worklet/EulerIntegrator.h
index 9653765da..dbcd60158 100644
--- a/vtkm/worklet/particleadvection/EulerIntegrator.h
+++ b/vtkm/filter/flow/worklet/EulerIntegrator.h
@@ -10,14 +10,14 @@
 //
 //=============================================================================
 
-#ifndef vtk_m_worklet_particleadvection_EulerIntegrator_h
-#define vtk_m_worklet_particleadvection_EulerIntegrator_h
+#ifndef vtk_m_filter_flow_worklet_EulerIntegrator_h
+#define vtk_m_filter_flow_worklet_EulerIntegrator_h
 
 namespace vtkm
 {
 namespace worklet
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename EvaluatorType>
@@ -73,8 +73,8 @@ public:
   }
 }; //EulerIntegrator
 
-} //namespace particleadvection
-} //namespace worklet
-} //namespace vtkm
+}
+}
+} //vtkm::worklet::flow
 
-#endif // vtk_m_worklet_particleadvection_EulerIntegrator_h
+#endif // vtk_m_filter_flow_worklet_EulerIntegrator_h
diff --git a/vtkm/worklet/particleadvection/Field.h b/vtkm/filter/flow/worklet/Field.h
similarity index 96%
rename from vtkm/worklet/particleadvection/Field.h
rename to vtkm/filter/flow/worklet/Field.h
index 3a2a5aae3..3d3124800 100644
--- a/vtkm/worklet/particleadvection/Field.h
+++ b/vtkm/filter/flow/worklet/Field.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtkm_woklet_particleadvection_field_h
-#define vtkm_woklet_particleadvection_field_h
+#ifndef vtkm_filter_flow_worklet_Field_h
+#define vtkm_filter_flow_worklet_Field_h
 
 #include <vtkm/Types.h>
 
@@ -22,7 +22,7 @@ namespace vtkm
 {
 namespace worklet
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename FieldArrayType>
@@ -209,7 +209,8 @@ private:
   Association Assoc;
 };
 
-} // namespace particleadvection
-} // namespace worklet
-} // namespace
-#endif //vtkm_woklet_particleadvection_field_h
+}
+}
+} //vtkm::worklet::flow
+
+#endif //vtkm_filter_flow_worklet_Field_h
diff --git a/vtkm/worklet/particleadvection/GridEvaluatorStatus.h b/vtkm/filter/flow/worklet/GridEvaluatorStatus.h
similarity index 91%
rename from vtkm/worklet/particleadvection/GridEvaluatorStatus.h
rename to vtkm/filter/flow/worklet/GridEvaluatorStatus.h
index 44182cec1..671a69f7f 100644
--- a/vtkm/worklet/particleadvection/GridEvaluatorStatus.h
+++ b/vtkm/filter/flow/worklet/GridEvaluatorStatus.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_worklet_particleadvection_GridEvaluatorStatus_h
-#define vtk_m_worklet_particleadvection_GridEvaluatorStatus_h
+#ifndef vtk_m_filter_flow_worklet_GridEvaluatorStatus_h
+#define vtk_m_filter_flow_worklet_GridEvaluatorStatus_h
 
 #include <vtkm/Bitset.h>
 #include <vtkm/Types.h>
@@ -26,7 +26,7 @@ namespace vtkm
 {
 namespace worklet
 {
-namespace particleadvection
+namespace flow
 {
 
 class GridEvaluatorStatus : public vtkm::Bitset<vtkm::UInt8>
@@ -62,8 +62,9 @@ private:
   static constexpr vtkm::Id TEMPORAL_BOUNDS_BIT = 2;
   static constexpr vtkm::Id IN_GHOST_CELL_BIT = 3;
 };
+
 }
 }
 }
 
-#endif // vtk_m_worklet_particleadvection_GridEvaluatorStatus_h
+#endif // vtk_m_filter_flow_worklet_GridEvaluatorStatus_h
diff --git a/vtkm/worklet/particleadvection/GridEvaluators.h b/vtkm/filter/flow/worklet/GridEvaluators.h
similarity index 94%
rename from vtkm/worklet/particleadvection/GridEvaluators.h
rename to vtkm/filter/flow/worklet/GridEvaluators.h
index 70fe9b398..7e1dfa88f 100644
--- a/vtkm/worklet/particleadvection/GridEvaluators.h
+++ b/vtkm/filter/flow/worklet/GridEvaluators.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_worklet_particleadvection_GridEvaluators_h
-#define vtk_m_worklet_particleadvection_GridEvaluators_h
+#ifndef vtk_m_filter_flow_worklet_GridEvaluators_h
+#define vtk_m_filter_flow_worklet_GridEvaluators_h
 
 #include <vtkm/Bitset.h>
 #include <vtkm/CellClassification.h>
@@ -24,15 +24,15 @@
 #include <vtkm/cont/CellSetStructured.h>
 #include <vtkm/cont/DataSet.h>
 
-#include <vtkm/worklet/particleadvection/CellInterpolationHelper.h>
-#include <vtkm/worklet/particleadvection/Field.h>
-#include <vtkm/worklet/particleadvection/GridEvaluatorStatus.h>
+#include <vtkm/filter/flow/worklet/CellInterpolationHelper.h>
+#include <vtkm/filter/flow/worklet/Field.h>
+#include <vtkm/filter/flow/worklet/GridEvaluatorStatus.h>
 
 namespace vtkm
 {
 namespace worklet
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename FieldType>
@@ -232,8 +232,8 @@ private:
   vtkm::cont::CellLocatorGeneral Locator;
 };
 
-} //namespace particleadvection
-} //namespace worklet
-} //namespace vtkm
+}
+}
+} //vtkm::worklet::flow
 
-#endif // vtk_m_worklet_particleadvection_GridEvaluators_h
+#endif // vtk_m_filter_flow_worklet_GridEvaluators_h
diff --git a/vtkm/worklet/particleadvection/IntegratorStatus.h b/vtkm/filter/flow/worklet/IntegratorStatus.h
similarity index 91%
rename from vtkm/worklet/particleadvection/IntegratorStatus.h
rename to vtkm/filter/flow/worklet/IntegratorStatus.h
index a7985e847..ff0657afe 100644
--- a/vtkm/worklet/particleadvection/IntegratorStatus.h
+++ b/vtkm/filter/flow/worklet/IntegratorStatus.h
@@ -10,8 +10,8 @@
 //
 //=============================================================================
 
-#ifndef vtk_m_worklet_particleadvection_Integrator_Status_h
-#define vtk_m_worklet_particleadvection_Integrator_Status_h
+#ifndef vtk_m_filter_flow_worklet_IntegratorStatus_h
+#define vtk_m_filter_flow_worklet_IntegratorStatus_h
 
 #include <iomanip>
 #include <limits>
@@ -21,13 +21,13 @@
 #include <vtkm/Types.h>
 #include <vtkm/VectorAnalysis.h>
 
-#include <vtkm/worklet/particleadvection/GridEvaluatorStatus.h>
+#include <vtkm/filter/flow/worklet/GridEvaluatorStatus.h>
 
 namespace vtkm
 {
 namespace worklet
 {
-namespace particleadvection
+namespace flow
 {
 
 class IntegratorStatus : public vtkm::Bitset<vtkm::UInt8>
@@ -82,9 +82,9 @@ inline VTKM_CONT std::ostream& operator<<(std::ostream& s, const IntegratorStatu
     << " tm= " << status.CheckTemporalBounds() << " gc= " << status.CheckInGhostCell() << "]";
   return s;
 }
-}
-}
-}
 
+}
+}
+} //vtkm::worklet::flow
 
-#endif // vtk_m_worklet_particleadvection_IntegratorStatus_h
+#endif // vtk_m_filter_flow_worklet_IntegratorStatus_h
diff --git a/vtkm/worklet/ParticleAdvection.h b/vtkm/filter/flow/worklet/ParticleAdvection.h
similarity index 88%
rename from vtkm/worklet/ParticleAdvection.h
rename to vtkm/filter/flow/worklet/ParticleAdvection.h
index 4c2896ff2..4e59d1add 100644
--- a/vtkm/worklet/ParticleAdvection.h
+++ b/vtkm/filter/flow/worklet/ParticleAdvection.h
@@ -8,19 +8,21 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_worklet_ParticleAdvection_h
-#define vtk_m_worklet_ParticleAdvection_h
+#ifndef vtk_m_filter_flow_worklet_ParticleAdvection_h
+#define vtk_m_filter_flow_worklet_ParticleAdvection_h
 
 #include <vtkm/Types.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ArrayHandle.h>
 #include <vtkm/cont/Invoker.h>
-#include <vtkm/worklet/particleadvection/ParticleAdvectionWorklets.h>
+#include <vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h>
 
 namespace vtkm
 {
 namespace worklet
 {
+namespace flow
+{
 
 namespace detail
 {
@@ -76,8 +78,7 @@ public:
             vtkm::Id MaxSteps,
             ParticleAdvectionResult<ParticleType>& result)
   {
-    vtkm::worklet::particleadvection::ParticleAdvectionWorklet<IntegratorType, ParticleType>
-      worklet;
+    vtkm::worklet::flow::ParticleAdvectionWorklet<IntegratorType, ParticleType> worklet;
 
     worklet.Run(it, particles, MaxSteps);
     result = ParticleAdvectionResult<ParticleType>(particles);
@@ -89,8 +90,7 @@ public:
     vtkm::cont::ArrayHandle<ParticleType, ParticleStorage>& particles,
     vtkm::Id MaxSteps)
   {
-    vtkm::worklet::particleadvection::ParticleAdvectionWorklet<IntegratorType, ParticleType>
-      worklet;
+    vtkm::worklet::flow::ParticleAdvectionWorklet<IntegratorType, ParticleType> worklet;
 
     worklet.Run(it, particles, MaxSteps);
     return ParticleAdvectionResult<ParticleType>(particles);
@@ -102,8 +102,7 @@ public:
     const vtkm::cont::ArrayHandle<vtkm::Vec3f, PointStorage>& points,
     vtkm::Id MaxSteps)
   {
-    vtkm::worklet::particleadvection::ParticleAdvectionWorklet<IntegratorType, ParticleType>
-      worklet;
+    vtkm::worklet::flow::ParticleAdvectionWorklet<IntegratorType, ParticleType> worklet;
 
     vtkm::cont::ArrayHandle<ParticleType> particles;
     vtkm::cont::ArrayHandle<vtkm::Id> step, ids;
@@ -161,7 +160,7 @@ public:
     vtkm::cont::ArrayHandle<ParticleType, ParticleStorage>& particles,
     vtkm::Id MaxSteps)
   {
-    vtkm::worklet::particleadvection::StreamlineWorklet<IntegratorType, ParticleType> worklet;
+    vtkm::worklet::flow::StreamlineWorklet<IntegratorType, ParticleType> worklet;
 
     vtkm::cont::ArrayHandle<vtkm::Vec3f> positions;
     vtkm::cont::CellSetExplicit<> polyLines;
@@ -171,7 +170,9 @@ public:
     return StreamlineResult<ParticleType>(particles, positions, polyLines);
   }
 };
-}
-}
 
-#endif // vtk_m_worklet_ParticleAdvection_h
+}
+}
+} // vtkm::worklet::flow
+
+#endif // vtk_m_filter_flow_worklet_ParticleAdvection_h
diff --git a/vtkm/worklet/particleadvection/ParticleAdvectionWorklets.h b/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
similarity index 90%
rename from vtkm/worklet/particleadvection/ParticleAdvectionWorklets.h
rename to vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
index 8fda04b7f..b5cf2664e 100644
--- a/vtkm/worklet/particleadvection/ParticleAdvectionWorklets.h
+++ b/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_worklet_particleadvection_ParticleAdvectionWorklets_h
-#define vtk_m_worklet_particleadvection_ParticleAdvectionWorklets_h
+#ifndef vtk_m_filter_flow_worklet_ParticleAdvectionWorklets_h
+#define vtk_m_filter_flow_worklet_ParticleAdvectionWorklets_h
 
 #include <vtkm/Types.h>
 #include <vtkm/cont/Algorithm.h>
@@ -22,9 +22,9 @@
 #include <vtkm/cont/ExecutionObjectBase.h>
 
 #include <vtkm/Particle.h>
+#include <vtkm/filter/flow/worklet/Particles.h>
+#include <vtkm/filter/flow/worklet/Stepper.h>
 #include <vtkm/worklet/WorkletMapField.h>
-#include <vtkm/worklet/particleadvection/Particles.h>
-#include <vtkm/worklet/particleadvection/Stepper.h>
 
 #ifdef VTKM_CUDA
 #include <vtkm/cont/cuda/internal/ScopedCudaStackSize.h>
@@ -34,7 +34,7 @@ namespace vtkm
 {
 namespace worklet
 {
-namespace particleadvection
+namespace flow
 {
 
 class ParticleAdvectWorklet : public vtkm::worklet::WorkletMapField
@@ -106,10 +106,10 @@ public:
            vtkm::Id& MaxSteps)
   {
 
-    using ParticleAdvectWorkletType = vtkm::worklet::particleadvection::ParticleAdvectWorklet;
+    using ParticleAdvectWorkletType = vtkm::worklet::flow::ParticleAdvectWorklet;
     using ParticleWorkletDispatchType =
       typename vtkm::worklet::DispatcherMapField<ParticleAdvectWorkletType>;
-    using ParticleArrayType = vtkm::worklet::particleadvection::Particles<ParticleType>;
+    using ParticleArrayType = vtkm::worklet::flow::Particles<ParticleType>;
 
     vtkm::Id numSeeds = static_cast<vtkm::Id>(particles.GetNumberOfValues());
     //Create and invoke the particle advection.
@@ -186,10 +186,9 @@ public:
            vtkm::cont::CellSetExplicit<>& polyLines)
   {
 
-    using ParticleWorkletDispatchType = typename vtkm::worklet::DispatcherMapField<
-      vtkm::worklet::particleadvection::ParticleAdvectWorklet>;
-    using StreamlineArrayType =
-      vtkm::worklet::particleadvection::StateRecordingParticles<ParticleType>;
+    using ParticleWorkletDispatchType =
+      typename vtkm::worklet::DispatcherMapField<vtkm::worklet::flow::ParticleAdvectWorklet>;
+    using StreamlineArrayType = vtkm::worklet::flow::StateRecordingParticles<ParticleType>;
 
     vtkm::cont::ArrayHandle<vtkm::Id> initialStepsTaken;
 
@@ -238,8 +237,9 @@ public:
     polyLines.Fill(positions.GetNumberOfValues(), cellTypes, connectivity, offsets);
   }
 };
-}
-}
-} // namespace vtkm::worklet::particleadvection
 
-#endif // vtk_m_worklet_particleadvection_ParticleAdvectionWorklets_h
+}
+}
+} // namespace vtkm::worklet::flow
+
+#endif // vtk_m_filter_flow_worklet_ParticleAdvectionWorklets_h
diff --git a/vtkm/worklet/particleadvection/Particles.h b/vtkm/filter/flow/worklet/Particles.h
similarity index 90%
rename from vtkm/worklet/particleadvection/Particles.h
rename to vtkm/filter/flow/worklet/Particles.h
index 0d7fde155..132dcb3f1 100644
--- a/vtkm/worklet/particleadvection/Particles.h
+++ b/vtkm/filter/flow/worklet/Particles.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_worklet_particleadvection_Particles_h
-#define vtk_m_worklet_particleadvection_Particles_h
+#ifndef vtk_m_filter_flow_worklet_Particles_h
+#define vtk_m_filter_flow_worklet_Particles_h
 
 #include <vtkm/Particle.h>
 #include <vtkm/Types.h>
@@ -17,14 +17,15 @@
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ArrayHandleConstant.h>
 #include <vtkm/cont/ExecutionObjectBase.h>
-#include <vtkm/worklet/particleadvection/IntegratorStatus.h>
+#include <vtkm/filter/flow/worklet/IntegratorStatus.h>
 
 namespace vtkm
 {
 namespace worklet
 {
-namespace particleadvection
+namespace flow
 {
+
 template <typename ParticleType>
 class ParticleExecutionObject
 {
@@ -66,7 +67,7 @@ public:
 
   VTKM_EXEC
   void StatusUpdate(const vtkm::Id& idx,
-                    const vtkm::worklet::particleadvection::IntegratorStatus& status,
+                    const vtkm::worklet::flow::IntegratorStatus& status,
                     vtkm::Id maxSteps)
   {
     ParticleType p(this->GetParticle(idx));
@@ -116,10 +117,11 @@ template <typename ParticleType>
 class Particles : public vtkm::cont::ExecutionObjectBase
 {
 public:
-  VTKM_CONT vtkm::worklet::particleadvection::ParticleExecutionObject<ParticleType>
-  PrepareForExecution(vtkm::cont::DeviceAdapterId device, vtkm::cont::Token& token) const
+  VTKM_CONT vtkm::worklet::flow::ParticleExecutionObject<ParticleType> PrepareForExecution(
+    vtkm::cont::DeviceAdapterId device,
+    vtkm::cont::Token& token) const
   {
-    return vtkm::worklet::particleadvection::ParticleExecutionObject<ParticleType>(
+    return vtkm::worklet::flow::ParticleExecutionObject<ParticleType>(
       this->ParticleArray, this->MaxSteps, device, token);
   }
 
@@ -221,10 +223,10 @@ public:
   };
 
 
-  VTKM_CONT vtkm::worklet::particleadvection::StateRecordingParticleExecutionObject<ParticleType>
+  VTKM_CONT vtkm::worklet::flow::StateRecordingParticleExecutionObject<ParticleType>
   PrepareForExecution(vtkm::cont::DeviceAdapterId device, vtkm::cont::Token& token) const
   {
-    return vtkm::worklet::particleadvection::StateRecordingParticleExecutionObject<ParticleType>(
+    return vtkm::worklet::flow::StateRecordingParticleExecutionObject<ParticleType>(
       this->ParticleArray,
       this->HistoryArray,
       this->ValidPointArray,
@@ -276,9 +278,9 @@ protected:
 };
 
 
-} //namespace particleadvection
-} //namespace worklet
-} //namespace vtkm
+}
+}
+} //vtkm::worklet::flow
 
-#endif // vtk_m_worklet_particleadvection_Particles_h
+#endif // vtk_m_filter_flow_worklet_Particles_h
 //============================================================================
diff --git a/vtkm/worklet/particleadvection/RK4Integrator.h b/vtkm/filter/flow/worklet/RK4Integrator.h
similarity index 92%
rename from vtkm/worklet/particleadvection/RK4Integrator.h
rename to vtkm/filter/flow/worklet/RK4Integrator.h
index e6398c093..72d96ce36 100644
--- a/vtkm/worklet/particleadvection/RK4Integrator.h
+++ b/vtkm/filter/flow/worklet/RK4Integrator.h
@@ -10,14 +10,14 @@
 //
 //=============================================================================
 
-#ifndef vtk_m_worklet_particleadvection_RK4Integrator_h
-#define vtk_m_worklet_particleadvection_RK4Integrator_h
+#ifndef vtk_m_filter_flow_worklet_RK4Integrator_h
+#define vtk_m_filter_flow_worklet_RK4Integrator_h
 
 namespace vtkm
 {
 namespace worklet
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename ExecEvaluatorType>
@@ -112,8 +112,8 @@ public:
   }
 };
 
-} //namespace particleadvection
-} //namespace worklet
-} //namespace vtkm
+}
+}
+} //vtkm::worklet::flow
 
-#endif // vtk_m_worklet_particleadvection_RK4Integrator_h
+#endif // vtk_m_filter_flow_worklet_RK4Integrator_h
diff --git a/vtkm/worklet/particleadvection/Stepper.h b/vtkm/filter/flow/worklet/Stepper.h
similarity index 93%
rename from vtkm/worklet/particleadvection/Stepper.h
rename to vtkm/filter/flow/worklet/Stepper.h
index 5cc6bf91f..273a3444d 100644
--- a/vtkm/worklet/particleadvection/Stepper.h
+++ b/vtkm/filter/flow/worklet/Stepper.h
@@ -10,8 +10,8 @@
 //
 //=============================================================================
 
-#ifndef vtk_m_worklet_particleadvection_Stepper_h
-#define vtk_m_worklet_particleadvection_Stepper_h
+#ifndef vtk_m_filter_flow_worklet_Stepper_h
+#define vtk_m_filter_flow_worklet_Stepper_h
 
 #include <limits>
 
@@ -22,15 +22,15 @@
 
 #include <vtkm/cont/DataSet.h>
 
-#include <vtkm/worklet/particleadvection/GridEvaluators.h>
-#include <vtkm/worklet/particleadvection/IntegratorStatus.h>
-#include <vtkm/worklet/particleadvection/Particles.h>
+#include <vtkm/filter/flow/worklet/GridEvaluators.h>
+#include <vtkm/filter/flow/worklet/IntegratorStatus.h>
+#include <vtkm/filter/flow/worklet/Particles.h>
 
 namespace vtkm
 {
 namespace worklet
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename ExecIntegratorType, typename ExecEvaluatorType>
@@ -194,8 +194,8 @@ public:
   }
 };
 
-} //namespace particleadvection
-} //namespace worklet
-} //namespace vtkm
+}
+}
+} //vtkm::worklet::flow
 
-#endif // vtk_m_worklet_particleadvection_Stepper_h
+#endif // vtk_m_filter_flow_worklet_Stepper_h
diff --git a/vtkm/worklet/particleadvection/TemporalGridEvaluators.h b/vtkm/filter/flow/worklet/TemporalGridEvaluators.h
similarity index 89%
rename from vtkm/worklet/particleadvection/TemporalGridEvaluators.h
rename to vtkm/filter/flow/worklet/TemporalGridEvaluators.h
index 62c44ce11..521b3ebb9 100644
--- a/vtkm/worklet/particleadvection/TemporalGridEvaluators.h
+++ b/vtkm/filter/flow/worklet/TemporalGridEvaluators.h
@@ -8,26 +8,25 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_worklet_particleadvection_TemporalGridEvaluators_h
-#define vtk_m_worklet_particleadvection_TemporalGridEvaluators_h
+#ifndef vtk_m_filter_flow_worklet_TemporalGridEvaluators_h
+#define vtk_m_filter_flow_worklet_TemporalGridEvaluators_h
 
-#include <vtkm/worklet/particleadvection/GridEvaluatorStatus.h>
-#include <vtkm/worklet/particleadvection/GridEvaluators.h>
+#include <vtkm/filter/flow/worklet/GridEvaluatorStatus.h>
+#include <vtkm/filter/flow/worklet/GridEvaluators.h>
 
 namespace vtkm
 {
 namespace worklet
 {
-namespace particleadvection
+namespace flow
 {
 
 template <typename FieldType>
 class ExecutionTemporalGridEvaluator
 {
 private:
-  using GridEvaluator = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-  using ExecutionGridEvaluator =
-    vtkm::worklet::particleadvection::ExecutionGridEvaluator<FieldType>;
+  using GridEvaluator = vtkm::worklet::flow::GridEvaluator<FieldType>;
+  using ExecutionGridEvaluator = vtkm::worklet::flow::ExecutionGridEvaluator<FieldType>;
 
 public:
   VTKM_CONT
@@ -117,7 +116,7 @@ template <typename FieldType>
 class TemporalGridEvaluator : public vtkm::cont::ExecutionObjectBase
 {
 private:
-  using GridEvaluator = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+  using GridEvaluator = vtkm::worklet::flow::GridEvaluator<FieldType>;
 
 public:
   VTKM_CONT TemporalGridEvaluator() = default;
@@ -178,8 +177,8 @@ private:
   vtkm::FloatDefault TimeTwo;
 };
 
-} // namespace particleadvection
-} // namespace worklet
-} // namespace vtkm
+}
+}
+} //vtkm::worklet::flow
 
-#endif
+#endif // vtk_m_filter_flow_worklet_TemporalGridEvaluators_h
diff --git a/vtkm/worklet/CMakeLists.txt b/vtkm/worklet/CMakeLists.txt
index 0f7b6458c..1a1f16eaa 100644
--- a/vtkm/worklet/CMakeLists.txt
+++ b/vtkm/worklet/CMakeLists.txt
@@ -32,7 +32,6 @@ set(headers
   MIR.h
   NDimsHistMarginalization.h
   Normalize.h
-  ParticleAdvection.h
   ScalarsToColors.h
   ScatterCounting.h
   ScatterIdentity.h
@@ -86,7 +85,6 @@ add_subdirectory(mir)
 add_subdirectory(splatkernels)
 add_subdirectory(spatialstructure)
 add_subdirectory(wavelets)
-add_subdirectory(particleadvection)
 
 vtkm_library(
   NAME vtkm_worklet
diff --git a/vtkm/worklet/testing/UnitTestParticleAdvection.cxx b/vtkm/worklet/testing/UnitTestParticleAdvection.cxx
index 82cdea921..1de934ec2 100644
--- a/vtkm/worklet/testing/UnitTestParticleAdvection.cxx
+++ b/vtkm/worklet/testing/UnitTestParticleAdvection.cxx
@@ -13,15 +13,15 @@
 #include <vtkm/cont/ArrayHandle.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/testing/Testing.h>
+#include <vtkm/filter/flow/worklet/EulerIntegrator.h>
+#include <vtkm/filter/flow/worklet/Field.h>
+#include <vtkm/filter/flow/worklet/GridEvaluators.h>
+#include <vtkm/filter/flow/worklet/ParticleAdvection.h>
+#include <vtkm/filter/flow/worklet/Particles.h>
+#include <vtkm/filter/flow/worklet/RK4Integrator.h>
+#include <vtkm/filter/flow/worklet/Stepper.h>
 #include <vtkm/filter/mesh_info/GhostCellClassify.h>
 #include <vtkm/io/VTKDataSetReader.h>
-#include <vtkm/worklet/ParticleAdvection.h>
-#include <vtkm/worklet/particleadvection/EulerIntegrator.h>
-#include <vtkm/worklet/particleadvection/Field.h>
-#include <vtkm/worklet/particleadvection/GridEvaluators.h>
-#include <vtkm/worklet/particleadvection/Particles.h>
-#include <vtkm/worklet/particleadvection/RK4Integrator.h>
-#include <vtkm/worklet/particleadvection/Stepper.h>
 #include <vtkm/worklet/testing/GenerateTestDataSets.h>
 
 #include <random>
@@ -142,7 +142,7 @@ public:
   template <typename EvaluatorType>
   VTKM_EXEC void operator()(vtkm::Particle& pointIn,
                             const EvaluatorType& evaluator,
-                            vtkm::worklet::particleadvection::GridEvaluatorStatus& status,
+                            vtkm::worklet::flow::GridEvaluatorStatus& status,
                             vtkm::Vec3f& pointOut) const
   {
     vtkm::VecVariable<vtkm::Vec3f, 2> values;
@@ -159,7 +159,7 @@ void ValidateEvaluator(const EvalType& eval,
 {
   using EvalTester = TestEvaluatorWorklet;
   using EvalTesterDispatcher = vtkm::worklet::DispatcherMapField<EvalTester>;
-  using Status = vtkm::worklet::particleadvection::GridEvaluatorStatus;
+  using Status = vtkm::worklet::flow::GridEvaluatorStatus;
   EvalTester evalTester;
   EvalTesterDispatcher evalTesterDispatcher(evalTester);
   vtkm::cont::ArrayHandle<vtkm::Particle> pointsHandle =
@@ -192,7 +192,7 @@ public:
   template <typename Particle, typename IntegratorType>
   VTKM_EXEC void operator()(Particle& pointIn,
                             const IntegratorType integrator,
-                            vtkm::worklet::particleadvection::IntegratorStatus& status,
+                            vtkm::worklet::flow::IntegratorStatus& status,
                             vtkm::Vec3f& pointOut) const
   {
     vtkm::FloatDefault time = 0;
@@ -211,7 +211,7 @@ void ValidateIntegrator(const IntegratorType& integrator,
 {
   using IntegratorTester = TestIntegratorWorklet;
   using IntegratorTesterDispatcher = vtkm::worklet::DispatcherMapField<IntegratorTester>;
-  using Status = vtkm::worklet::particleadvection::IntegratorStatus;
+  using Status = vtkm::worklet::flow::IntegratorStatus;
   IntegratorTesterDispatcher integratorTesterDispatcher;
   auto pointsHandle = vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off);
   vtkm::Id numPoints = pointsHandle.GetNumberOfValues();
@@ -243,7 +243,7 @@ void ValidateIntegratorForBoundary(const vtkm::Bounds& bounds,
 {
   using IntegratorTester = TestIntegratorWorklet;
   using IntegratorTesterDispatcher = vtkm::worklet::DispatcherMapField<IntegratorTester>;
-  using Status = vtkm::worklet::particleadvection::IntegratorStatus;
+  using Status = vtkm::worklet::flow::IntegratorStatus;
 
   IntegratorTesterDispatcher integratorTesterDispatcher;
   auto pointsHandle = vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off);
@@ -269,10 +269,10 @@ void ValidateIntegratorForBoundary(const vtkm::Bounds& bounds,
 void TestEvaluators()
 {
   using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-  using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-  using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-  using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-  using Stepper = vtkm::worklet::particleadvection::Stepper<RK4Type, GridEvalType>;
+  using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+  using GridEvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
+  using RK4Type = vtkm::worklet::flow::RK4Integrator<GridEvalType>;
+  using Stepper = vtkm::worklet::flow::Stepper<RK4Type, GridEvalType>;
 
   std::vector<vtkm::Vec3f> vecs;
   vtkm::FloatDefault vals[3] = { -1., 0., 1. };
@@ -364,10 +364,10 @@ void TestEvaluators()
 void TestGhostCellEvaluators()
 {
   using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-  using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-  using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-  using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-  using Stepper = vtkm::worklet::particleadvection::Stepper<RK4Type, GridEvalType>;
+  using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+  using GridEvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
+  using RK4Type = vtkm::worklet::flow::RK4Integrator<GridEvalType>;
+  using Stepper = vtkm::worklet::flow::Stepper<RK4Type, GridEvalType>;
 
   constexpr vtkm::Id nX = 6;
   constexpr vtkm::Id nY = 6;
@@ -395,7 +395,7 @@ void TestGhostCellEvaluators()
     vtkm::FloatDefault stepSize = static_cast<vtkm::FloatDefault>(0.1);
     Stepper rk4(gridEval, stepSize);
 
-    vtkm::worklet::ParticleAdvection pa;
+    vtkm::worklet::flow::ParticleAdvection pa;
     std::vector<vtkm::Particle> seeds;
     //Points in a ghost cell.
     seeds.push_back(vtkm::Particle(vtkm::Vec3f(.5, .5, .5), 0));
@@ -426,7 +426,7 @@ void TestGhostCellEvaluators()
 }
 
 void ValidateParticleAdvectionResult(
-  const vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>& res,
+  const vtkm::worklet::flow::ParticleAdvectionResult<vtkm::Particle>& res,
   vtkm::Id nSeeds,
   vtkm::Id maxSteps)
 {
@@ -446,7 +446,7 @@ void ValidateParticleAdvectionResult(
   }
 }
 
-void ValidateStreamlineResult(const vtkm::worklet::StreamlineResult<vtkm::Particle>& res,
+void ValidateStreamlineResult(const vtkm::worklet::flow::StreamlineResult<vtkm::Particle>& res,
                               vtkm::Id nSeeds,
                               vtkm::Id maxSteps)
 {
@@ -465,8 +465,8 @@ void ValidateStreamlineResult(const vtkm::worklet::StreamlineResult<vtkm::Partic
 void TestIntegrators()
 {
   using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-  using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-  using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
+  using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+  using GridEvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
 
   const vtkm::Id3 dims(5, 5, 5);
   const vtkm::Bounds bounds(0., 1., 0., 1., .0, .1);
@@ -491,20 +491,20 @@ void TestIntegrators()
     std::vector<vtkm::Particle> points;
     GenerateRandomParticles(points, 3, bounds);
 
-    vtkm::worklet::ParticleAdvection pa;
-    vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
+    vtkm::worklet::flow::ParticleAdvection pa;
+    vtkm::worklet::flow::ParticleAdvectionResult<vtkm::Particle> res;
     {
       auto seeds = vtkm::cont::make_ArrayHandle(points, vtkm::CopyFlag::On);
-      using IntegratorType = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-      using Stepper = vtkm::worklet::particleadvection::Stepper<IntegratorType, GridEvalType>;
+      using IntegratorType = vtkm::worklet::flow::RK4Integrator<GridEvalType>;
+      using Stepper = vtkm::worklet::flow::Stepper<IntegratorType, GridEvalType>;
       Stepper rk4(eval, stepSize);
       res = pa.Run(rk4, seeds, maxSteps);
       ValidateParticleAdvectionResult(res, nSeeds, maxSteps);
     }
     {
       auto seeds = vtkm::cont::make_ArrayHandle(points, vtkm::CopyFlag::On);
-      using IntegratorType = vtkm::worklet::particleadvection::EulerIntegrator<GridEvalType>;
-      using Stepper = vtkm::worklet::particleadvection::Stepper<IntegratorType, GridEvalType>;
+      using IntegratorType = vtkm::worklet::flow::EulerIntegrator<GridEvalType>;
+      using Stepper = vtkm::worklet::flow::Stepper<IntegratorType, GridEvalType>;
       Stepper euler(eval, stepSize);
       res = pa.Run(euler, seeds, maxSteps);
       ValidateParticleAdvectionResult(res, nSeeds, maxSteps);
@@ -515,10 +515,10 @@ void TestIntegrators()
 void TestParticleWorkletsWithDataSetTypes()
 {
   using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-  using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-  using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-  using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-  using Stepper = vtkm::worklet::particleadvection::Stepper<RK4Type, GridEvalType>;
+  using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+  using GridEvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
+  using RK4Type = vtkm::worklet::flow::RK4Integrator<GridEvalType>;
+  using Stepper = vtkm::worklet::flow::Stepper<RK4Type, GridEvalType>;
   vtkm::FloatDefault stepSize = 0.01f;
 
   const vtkm::Id3 dims(5, 5, 5);
@@ -569,8 +569,8 @@ void TestParticleWorkletsWithDataSetTypes()
       {
         if (i < 2)
         {
-          vtkm::worklet::ParticleAdvection pa;
-          vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
+          vtkm::worklet::flow::ParticleAdvection pa;
+          vtkm::worklet::flow::ParticleAdvectionResult<vtkm::Particle> res;
           if (i == 0)
           {
             auto seeds = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On);
@@ -585,8 +585,8 @@ void TestParticleWorkletsWithDataSetTypes()
         }
         else
         {
-          vtkm::worklet::Streamline s;
-          vtkm::worklet::StreamlineResult<vtkm::Particle> res;
+          vtkm::worklet::flow::Streamline s;
+          vtkm::worklet::flow::StreamlineResult<vtkm::Particle> res;
           if (i == 2)
           {
             auto seeds = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On);
@@ -618,10 +618,10 @@ void TestParticleStatus()
   auto dataSets = vtkm::worklet::testing::CreateAllDataSets(bounds, dims, false);
   for (auto& ds : dataSets)
   {
-    using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-    using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-    using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-    using Stepper = vtkm::worklet::particleadvection::Stepper<RK4Type, GridEvalType>;
+    using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+    using GridEvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
+    using RK4Type = vtkm::worklet::flow::RK4Integrator<GridEvalType>;
+    using Stepper = vtkm::worklet::flow::Stepper<RK4Type, GridEvalType>;
 
     vtkm::Id maxSteps = 1000;
     vtkm::FloatDefault stepSize = 0.01f;
@@ -631,7 +631,7 @@ void TestParticleStatus()
     GridEvalType eval(ds, velocities);
     Stepper rk4(eval, stepSize);
 
-    vtkm::worklet::ParticleAdvection pa;
+    vtkm::worklet::flow::ParticleAdvection pa;
     std::vector<vtkm::Particle> pts;
     pts.push_back(vtkm::Particle(vtkm::Vec3f(.5, .5, .5), 0));
     pts.push_back(vtkm::Particle(vtkm::Vec3f(-1, -1, -1), 1));
@@ -649,10 +649,10 @@ void TestParticleStatus()
 void TestWorkletsBasic()
 {
   using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-  using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-  using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-  using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-  using Stepper = vtkm::worklet::particleadvection::Stepper<RK4Type, GridEvalType>;
+  using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+  using GridEvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
+  using RK4Type = vtkm::worklet::flow::RK4Integrator<GridEvalType>;
+  using Stepper = vtkm::worklet::flow::Stepper<RK4Type, GridEvalType>;
   vtkm::FloatDefault stepSize = 0.01f;
 
   const vtkm::Id3 dims(5, 5, 5);
@@ -711,8 +711,8 @@ void TestWorkletsBasic()
 
       if (w == "particleAdvection")
       {
-        vtkm::worklet::ParticleAdvection pa;
-        vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
+        vtkm::worklet::flow::ParticleAdvection pa;
+        vtkm::worklet::flow::ParticleAdvectionResult<vtkm::Particle> res;
 
         res = pa.Run(rk4, seedsArray, maxSteps);
 
@@ -735,8 +735,8 @@ void TestWorkletsBasic()
       }
       else if (w == "streamline")
       {
-        vtkm::worklet::Streamline s;
-        vtkm::worklet::StreamlineResult<vtkm::Particle> res;
+        vtkm::worklet::flow::Streamline s;
+        vtkm::worklet::flow::StreamlineResult<vtkm::Particle> res;
 
         res = s.Run(rk4, seedsArray, maxSteps);
 
@@ -830,10 +830,10 @@ void TestParticleAdvectionFile(const std::string& fname,
   }
 
   using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
-  using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-  using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-  using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
-  using Stepper = vtkm::worklet::particleadvection::Stepper<RK4Type, GridEvalType>;
+  using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+  using GridEvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
+  using RK4Type = vtkm::worklet::flow::RK4Integrator<GridEvalType>;
+  using Stepper = vtkm::worklet::flow::Stepper<RK4Type, GridEvalType>;
 
   VTKM_TEST_ASSERT(ds.HasField("vec"), "Data set missing a field named 'vec'");
   vtkm::cont::Field& field = ds.GetField("vec");
@@ -862,16 +862,16 @@ void TestParticleAdvectionFile(const std::string& fname,
 
     if (i == 0)
     {
-      vtkm::worklet::ParticleAdvection pa;
-      vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
+      vtkm::worklet::flow::ParticleAdvection pa;
+      vtkm::worklet::flow::ParticleAdvectionResult<vtkm::Particle> res;
 
       res = pa.Run(rk4, seedArray, maxSteps);
       ValidateResult(res, maxSteps, endPts);
     }
     else if (i == 1)
     {
-      vtkm::worklet::Streamline s;
-      vtkm::worklet::StreamlineResult<vtkm::Particle> res;
+      vtkm::worklet::flow::Streamline s;
+      vtkm::worklet::flow::StreamlineResult<vtkm::Particle> res;
 
       res = s.Run(rk4, seedArray, maxSteps);
       ValidateResult(res, maxSteps, endPts);
diff --git a/vtkm/worklet/testing/UnitTestTemporalAdvection.cxx b/vtkm/worklet/testing/UnitTestTemporalAdvection.cxx
index f1a470aa5..19ba7550e 100644
--- a/vtkm/worklet/testing/UnitTestTemporalAdvection.cxx
+++ b/vtkm/worklet/testing/UnitTestTemporalAdvection.cxx
@@ -17,11 +17,11 @@
 #include <vtkm/cont/DataSetBuilderRectilinear.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
-#include <vtkm/worklet/ParticleAdvection.h>
-#include <vtkm/worklet/particleadvection/Field.h>
-#include <vtkm/worklet/particleadvection/Particles.h>
-#include <vtkm/worklet/particleadvection/Stepper.h>
-#include <vtkm/worklet/particleadvection/TemporalGridEvaluators.h>
+#include <vtkm/filter/flow/worklet/Field.h>
+#include <vtkm/filter/flow/worklet/ParticleAdvection.h>
+#include <vtkm/filter/flow/worklet/Particles.h>
+#include <vtkm/filter/flow/worklet/Stepper.h>
+#include <vtkm/filter/flow/worklet/TemporalGridEvaluators.h>
 
 template <typename ScalarType>
 vtkm::cont::DataSet CreateUniformDataSet(const vtkm::Bounds& bounds, const vtkm::Id3& dims)
@@ -52,7 +52,7 @@ public:
   template <typename EvaluatorType>
   VTKM_EXEC void operator()(vtkm::Particle& pointIn,
                             const EvaluatorType& evaluator,
-                            vtkm::worklet::particleadvection::GridEvaluatorStatus& status,
+                            vtkm::worklet::flow::GridEvaluatorStatus& status,
                             vtkm::Vec3f& pointOut) const
   {
     vtkm::VecVariable<vtkm::Vec3f, 2> values;
@@ -70,7 +70,7 @@ void ValidateEvaluator(const EvalType& eval,
 {
   using EvalTester = TestEvaluatorWorklet;
   using EvalTesterDispatcher = vtkm::worklet::DispatcherMapField<EvalTester>;
-  using Status = vtkm::worklet::particleadvection::GridEvaluatorStatus;
+  using Status = vtkm::worklet::flow::GridEvaluatorStatus;
 
   EvalTester evalTester;
   EvalTesterDispatcher evalTesterDispatcher(evalTester);
@@ -149,9 +149,9 @@ void TestTemporalEvaluators()
   using ScalarType = vtkm::FloatDefault;
   using PointType = vtkm::Vec<ScalarType, 3>;
   using FieldHandle = vtkm::cont::ArrayHandle<PointType>;
-  using FieldType = vtkm::worklet::particleadvection::VelocityField<FieldHandle>;
-  using EvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
-  using TemporalEvalType = vtkm::worklet::particleadvection::TemporalGridEvaluator<FieldType>;
+  using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
+  using EvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
+  using TemporalEvalType = vtkm::worklet::flow::TemporalGridEvaluator<FieldType>;
 
   // Create Datasets
   vtkm::Id3 dims(5, 5, 5);

From e786874a7790c06a4f26526ab9cd46c2343f36b8 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 22 Jul 2022 15:46:59 -0400
Subject: [PATCH 043/104] Move tests into flow/testing

---
 vtkm/filter/flow/CMakeLists.txt               |  6 +--
 vtkm/filter/flow/testing/CMakeLists.txt       | 40 +++++++++++++++++++
 .../testing/UnitTestParticleMessengerMPI.cxx  |  0
 .../testing/UnitTestStreamlineFilter.cxx      |  0
 .../testing/UnitTestStreamlineFilterMPI.cxx   |  0
 .../UnitTestWorkletParticleAdvection.cxx}     |  2 +-
 .../UnitTestWorkletTemporalAdvection.cxx}     |  2 +-
 vtkm/filter/testing/CMakeLists.txt            |  3 --
 vtkm/worklet/testing/CMakeLists.txt           |  2 -
 9 files changed, 45 insertions(+), 10 deletions(-)
 create mode 100644 vtkm/filter/flow/testing/CMakeLists.txt
 rename vtkm/filter/{ => flow}/testing/UnitTestParticleMessengerMPI.cxx (100%)
 rename vtkm/filter/{ => flow}/testing/UnitTestStreamlineFilter.cxx (100%)
 rename vtkm/filter/{ => flow}/testing/UnitTestStreamlineFilterMPI.cxx (100%)
 rename vtkm/{worklet/testing/UnitTestParticleAdvection.cxx => filter/flow/testing/UnitTestWorkletParticleAdvection.cxx} (99%)
 rename vtkm/{worklet/testing/UnitTestTemporalAdvection.cxx => filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx} (99%)

diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index 3106cd8e1..153a346c5 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -51,6 +51,6 @@ endif()
 add_subdirectory(worklet)
 
 #-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
-#if (VTKm_ENABLE_TESTING)
-#  add_subdirectory(testing)
-#endif ()
+if (VTKm_ENABLE_TESTING)
+  add_subdirectory(testing)
+endif ()
diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
new file mode 100644
index 000000000..80caed482
--- /dev/null
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -0,0 +1,40 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##============================================================================
+
+set(unit_tests
+UnitTestStreamlineFilter.cxx
+UnitTestWorkletParticleAdvection.cxx
+UnitTestWorkletTemporalAdvection.cxx
+  )
+
+set(libraries
+  vtkm_filter_flow
+  )
+
+vtkm_unit_tests(
+  SOURCES ${unit_tests}
+  LIBRARIES ${libraries} vtkm_filter vtkm_io
+  USE_VTKM_JOB_POOL
+)
+
+#add distributed tests i.e.test to run with MPI
+#if MPI is enabled.
+if (VTKm_ENABLE_MPI)
+  set(mpi_unit_tests
+    UnitTestParticleMessengerMPI.cxx
+    UnitTestStreamlineFilterMPI.cxx
+  )
+  vtkm_unit_tests(
+    MPI SOURCES ${mpi_unit_tests}
+    LIBRARIES vtkm_filter vtkm_source vtkm_io
+    ALL_BACKENDS
+    USE_VTKM_JOB_POOL
+  )
+endif()
diff --git a/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx b/vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx
similarity index 100%
rename from vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx
rename to vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
similarity index 100%
rename from vtkm/filter/testing/UnitTestStreamlineFilter.cxx
rename to vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
similarity index 100%
rename from vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
rename to vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
diff --git a/vtkm/worklet/testing/UnitTestParticleAdvection.cxx b/vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx
similarity index 99%
rename from vtkm/worklet/testing/UnitTestParticleAdvection.cxx
rename to vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx
index 1de934ec2..5d5f5f023 100644
--- a/vtkm/worklet/testing/UnitTestParticleAdvection.cxx
+++ b/vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx
@@ -917,7 +917,7 @@ void TestParticleAdvection()
   TestParticleAdvectionFile(fishFile, fishPts, fishStep, 100, fishEndPts);
 }
 
-int UnitTestParticleAdvection(int argc, char* argv[])
+int UnitTestWorkletParticleAdvection(int argc, char* argv[])
 {
   return vtkm::cont::testing::Testing::Run(TestParticleAdvection, argc, argv);
 }
diff --git a/vtkm/worklet/testing/UnitTestTemporalAdvection.cxx b/vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx
similarity index 99%
rename from vtkm/worklet/testing/UnitTestTemporalAdvection.cxx
rename to vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx
index 19ba7550e..a3ad7b1e1 100644
--- a/vtkm/worklet/testing/UnitTestTemporalAdvection.cxx
+++ b/vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx
@@ -189,7 +189,7 @@ void TestTemporalAdvection()
   TestTemporalEvaluators();
 }
 
-int UnitTestTemporalAdvection(int argc, char* argv[])
+int UnitTestWorkletTemporalAdvection(int argc, char* argv[])
 {
   return vtkm::cont::testing::Testing::Run(TestTemporalAdvection, argc, argv);
 }
diff --git a/vtkm/filter/testing/CMakeLists.txt b/vtkm/filter/testing/CMakeLists.txt
index 711b40086..59014cec6 100644
--- a/vtkm/filter/testing/CMakeLists.txt
+++ b/vtkm/filter/testing/CMakeLists.txt
@@ -25,7 +25,6 @@ set(unit_tests
   UnitTestMIRFilter.cxx
   UnitTestMultiBlockFilter.cxx
   UnitTestPartitionedDataSetFilters.cxx
-  UnitTestStreamlineFilter.cxx
   UnitTestStreamSurfaceFilter.cxx
 )
 
@@ -75,8 +74,6 @@ vtkm_unit_tests(
 if (VTKm_ENABLE_MPI)
   set(mpi_unit_tests
     UnitTestContourTreeUniformDistributedFilterMPI.cxx
-    UnitTestParticleMessengerMPI.cxx
-    UnitTestStreamlineFilterMPI.cxx
   )
   vtkm_unit_tests(
     MPI SOURCES ${mpi_unit_tests}
diff --git a/vtkm/worklet/testing/CMakeLists.txt b/vtkm/worklet/testing/CMakeLists.txt
index 013332198..051fc27fd 100644
--- a/vtkm/worklet/testing/CMakeLists.txt
+++ b/vtkm/worklet/testing/CMakeLists.txt
@@ -28,7 +28,6 @@ set(unit_tests
   UnitTestMaskSelect.cxx
   UnitTestNormalize.cxx
   UnitTestNDimsHistMarginalization.cxx
-  UnitTestParticleAdvection.cxx
   UnitTestScalarsToColors.cxx
   UnitTestScatterAndMask.cxx
   UnitTestScatterCounting.cxx
@@ -37,7 +36,6 @@ set(unit_tests
   UnitTestScatterAndMaskWithTopology.cxx
   UnitTestStreamLineUniformGrid.cxx
   UnitTestStreamSurface.cxx
-  UnitTestTemporalAdvection.cxx
   UnitTestTriangleWinding.cxx
   UnitTestWholeCellSetIn.cxx
   UnitTestWorkletMapField.cxx

From 6a934167c25ed2c022f421e0f438b8f4e1879f9f Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 09:09:59 -0400
Subject: [PATCH 044/104] Move streamsurface into flow

---
 vtkm/filter/StreamSurface.h                   | 70 -------------------
 vtkm/filter/flow/CMakeLists.txt               |  2 +
 .../StreamSurface.cxx}                        | 52 +++++---------
 vtkm/filter/flow/StreamSurface.h              | 48 +++++++++++++
 vtkm/filter/flow/Streamline.h                 |  6 +-
 vtkm/filter/flow/testing/CMakeLists.txt       |  2 +
 .../testing/UnitTestStreamSurfaceFilter.cxx   |  4 +-
 .../testing/UnitTestStreamSurfaceWorklet.cxx} | 12 ++--
 vtkm/filter/flow/worklet/CMakeLists.txt       |  1 +
 .../{ => filter/flow}/worklet/StreamSurface.h | 14 ++--
 vtkm/filter/testing/CMakeLists.txt            |  3 -
 vtkm/worklet/CMakeLists.txt                   |  1 -
 vtkm/worklet/testing/CMakeLists.txt           |  1 -
 13 files changed, 91 insertions(+), 125 deletions(-)
 delete mode 100644 vtkm/filter/StreamSurface.h
 rename vtkm/filter/{StreamSurface.hxx => flow/StreamSurface.cxx} (56%)
 create mode 100644 vtkm/filter/flow/StreamSurface.h
 rename vtkm/filter/{ => flow}/testing/UnitTestStreamSurfaceFilter.cxx (96%)
 rename vtkm/{worklet/testing/UnitTestStreamSurface.cxx => filter/flow/testing/UnitTestStreamSurfaceWorklet.cxx} (92%)
 rename vtkm/{ => filter/flow}/worklet/StreamSurface.h (98%)

diff --git a/vtkm/filter/StreamSurface.h b/vtkm/filter/StreamSurface.h
deleted file mode 100644
index 1e3b1491f..000000000
--- a/vtkm/filter/StreamSurface.h
+++ /dev/null
@@ -1,70 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-
-#ifndef vtk_m_filter_StreamSurface_h
-#define vtk_m_filter_StreamSurface_h
-
-#include <vtkm/filter/FilterDataSetWithField.h>
-#include <vtkm/filter/flow/worklet/GridEvaluators.h>
-#include <vtkm/filter/flow/worklet/ParticleAdvection.h>
-#include <vtkm/filter/flow/worklet/Stepper.h>
-#include <vtkm/worklet/StreamSurface.h>
-
-namespace vtkm
-{
-namespace filter
-{
-/// \brief generate streamlines from a vector field.
-
-/// Takes as input a vector field and seed locations and generates the
-/// paths taken by the seeds through the vector field.
-class StreamSurface : public vtkm::filter::FilterDataSetWithField<StreamSurface>
-{
-public:
-  using SupportedTypes = vtkm::TypeListFieldVec3;
-
-  VTKM_CONT
-  StreamSurface();
-
-  VTKM_CONT
-  void SetStepSize(vtkm::FloatDefault s) { this->StepSize = s; }
-
-  VTKM_CONT
-  void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; }
-
-  VTKM_CONT
-  void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds) { this->Seeds = seeds; }
-
-  template <typename T, typename StorageType, typename DerivedPolicy>
-  VTKM_CONT vtkm::cont::DataSet DoExecute(
-    const vtkm::cont::DataSet& input,
-    const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
-    const vtkm::filter::FieldMetadata& fieldMeta,
-    const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
-
-  template <typename DerivedPolicy>
-  VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
-                                    const vtkm::cont::Field& field,
-                                    vtkm::filter::PolicyBase<DerivedPolicy> policy);
-
-private:
-  vtkm::Id NumberOfSteps;
-  vtkm::cont::ArrayHandle<vtkm::Particle> Seeds;
-  vtkm::FloatDefault StepSize;
-  vtkm::worklet::StreamSurface Worklet;
-};
-}
-} // namespace vtkm::filter
-
-#ifndef vtk_m_filter_StreamSurface_hxx
-#include <vtkm/filter/StreamSurface.hxx>
-#endif
-
-#endif // vtk_m_filter_StreamSurface_h
diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index 153a346c5..c6c641a35 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -25,6 +25,7 @@ set(flow_headers
   Pathline.h
   PathParticle.h
   Streamline.h
+  StreamSurface.h
   )
 
 set(flow_sources
@@ -33,6 +34,7 @@ set(flow_sources
   Pathline.cxx
   PathParticle.cxx
   Streamline.cxx
+  StreamSurface.cxx
   )
 
 vtkm_library(
diff --git a/vtkm/filter/StreamSurface.hxx b/vtkm/filter/flow/StreamSurface.cxx
similarity index 56%
rename from vtkm/filter/StreamSurface.hxx
rename to vtkm/filter/flow/StreamSurface.cxx
index 05ba2ea6e..06b09849a 100644
--- a/vtkm/filter/StreamSurface.hxx
+++ b/vtkm/filter/flow/StreamSurface.cxx
@@ -8,13 +8,9 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_StreamSurface_hxx
-#define vtk_m_filter_StreamSurface_hxx
-
-#include <vtkm/filter/StreamSurface.h>
+#include <vtkm/filter/flow/StreamSurface.h>
 
 #include <vtkm/cont/ArrayCopy.h>
-#include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/flow/worklet/Field.h>
 #include <vtkm/filter/flow/worklet/GridEvaluators.h>
@@ -22,57 +18,53 @@
 #include <vtkm/filter/flow/worklet/Particles.h>
 #include <vtkm/filter/flow/worklet/RK4Integrator.h>
 #include <vtkm/filter/flow/worklet/Stepper.h>
+#include <vtkm/filter/flow/worklet/StreamSurface.h>
 
 namespace vtkm
 {
 namespace filter
 {
-
-//-----------------------------------------------------------------------------
-inline VTKM_CONT StreamSurface::StreamSurface()
-  : vtkm::filter::FilterDataSetWithField<StreamSurface>()
-  , Worklet()
+namespace flow
 {
-}
 
-//-----------------------------------------------------------------------------
-template <typename T, typename StorageType, typename DerivedPolicy>
-inline VTKM_CONT vtkm::cont::DataSet StreamSurface::DoExecute(
-  const vtkm::cont::DataSet& input,
-  const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
-  const vtkm::filter::FieldMetadata& fieldMeta,
-  const vtkm::filter::PolicyBase<DerivedPolicy>&)
+VTKM_CONT vtkm::cont::DataSet StreamSurface::DoExecute(const vtkm::cont::DataSet& input)
 {
-  //Check for some basics.
-  if (this->Seeds.GetNumberOfValues() == 0)
-    throw vtkm::cont::ErrorFilterExecution("No seeds provided.");
+  this->ValidateOptions();
+
+  if (!this->Seeds.IsBaseComponentType<vtkm::Particle>())
+    throw vtkm::cont::ErrorFilterExecution("Unsupported seed type in StreamSurface filter.");
 
   const vtkm::cont::UnknownCellSet& cells = input.GetCellSet();
   const vtkm::cont::CoordinateSystem& coords =
     input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex());
 
-  using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>;
+  using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec3f>;
   using FieldType = vtkm::worklet::flow::VelocityField<FieldHandle>;
   using GridEvalType = vtkm::worklet::flow::GridEvaluator<FieldType>;
   using RK4Type = vtkm::worklet::flow::RK4Integrator<GridEvalType>;
   using Stepper = vtkm::worklet::flow::Stepper<RK4Type, GridEvalType>;
 
   //compute streamlines
-  FieldType velocities(field, fieldMeta.GetAssociation());
+  const auto& field = input.GetField(this->GetActiveFieldName());
+  FieldHandle arr;
+  vtkm::cont::ArrayCopyShallowIfPossible(field.GetData(), arr);
+  FieldType velocities(arr, field.GetAssociation());
   GridEvalType eval(coords, cells, velocities);
   Stepper rk4(eval, this->StepSize);
 
   vtkm::worklet::flow::Streamline streamline;
 
+  using ParticleArray = vtkm::cont::ArrayHandle<vtkm::Particle>;
   vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
-  vtkm::cont::ArrayCopy(this->Seeds, seedArray);
+  vtkm::cont::ArrayCopy(this->Seeds.AsArrayHandle<ParticleArray>(), seedArray);
   auto res = streamline.Run(rk4, seedArray, this->NumberOfSteps);
 
   //compute surface from streamlines
+  vtkm::worklet::flow::StreamSurface streamSurface;
   vtkm::cont::ArrayHandle<vtkm::Vec3f> srfPoints;
   vtkm::cont::CellSetSingleType<> srfCells;
   vtkm::cont::CoordinateSystem slCoords("coordinates", res.Positions);
-  this->Worklet.Run(slCoords, res.PolyLines, srfPoints, srfCells);
+  streamSurface.Run(slCoords, res.PolyLines, srfPoints, srfCells);
 
   vtkm::cont::DataSet outData;
   vtkm::cont::CoordinateSystem outputCoords("coordinates", srfPoints);
@@ -82,14 +74,6 @@ inline VTKM_CONT vtkm::cont::DataSet StreamSurface::DoExecute(
   return outData;
 }
 
-//-----------------------------------------------------------------------------
-template <typename DerivedPolicy>
-inline VTKM_CONT bool StreamSurface::MapFieldOntoOutput(vtkm::cont::DataSet&,
-                                                        const vtkm::cont::Field&,
-                                                        vtkm::filter::PolicyBase<DerivedPolicy>)
-{
-  return false;
 }
 }
-} // namespace vtkm::filter
-#endif
+} // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/StreamSurface.h b/vtkm/filter/flow/StreamSurface.h
new file mode 100644
index 000000000..c477c87e0
--- /dev/null
+++ b/vtkm/filter/flow/StreamSurface.h
@@ -0,0 +1,48 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#ifndef vtk_m_filter_flow_StreamSurface_h
+#define vtk_m_filter_flow_StreamSurface_h
+
+#include <vtkm/Particle.h>
+#include <vtkm/filter/flow/FlowTypes.h>
+#include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
+#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
+
+namespace vtkm
+{
+namespace filter
+{
+namespace flow
+{
+
+/// \brief generate streamlines from a vector field.
+
+/// Takes as input a vector field and seed locations and generates the
+/// paths taken by the seeds through the vector field.
+
+class VTKM_FILTER_FLOW_EXPORT StreamSurface
+  : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
+{
+public:
+  VTKM_CONT StreamSurface()
+    : NewFilterParticleAdvectionSteadyState(vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE)
+  {
+  }
+
+protected:
+  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
+};
+
+}
+}
+} // namespace vtkm::filter::flow
+
+#endif // vtk_m_filter_flow_StreamSurface_h
diff --git a/vtkm/filter/flow/Streamline.h b/vtkm/filter/flow/Streamline.h
index 628a326a9..84a2eef00 100644
--- a/vtkm/filter/flow/Streamline.h
+++ b/vtkm/filter/flow/Streamline.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_Streamline_h
-#define vtk_m_filter_Streamline_h
+#ifndef vtk_m_filter_flow_Streamline_h
+#define vtk_m_filter_flow_Streamline_h
 
 #include <vtkm/Particle.h>
 #include <vtkm/filter/flow/FlowTypes.h>
@@ -46,4 +46,4 @@ protected:
 }
 } // namespace vtkm::filter::flow
 
-#endif // vtk_m_filter_Streamline_h
+#endif // vtk_m_filter_flow_Streamline_h
diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index 80caed482..c9579b246 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -12,6 +12,8 @@ set(unit_tests
 UnitTestStreamlineFilter.cxx
 UnitTestWorkletParticleAdvection.cxx
 UnitTestWorkletTemporalAdvection.cxx
+UnitTestStreamSurfaceFilter.cxx
+UnitTestStreamSurfaceWorklet.cxx
   )
 
 set(libraries
diff --git a/vtkm/filter/testing/UnitTestStreamSurfaceFilter.cxx b/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
similarity index 96%
rename from vtkm/filter/testing/UnitTestStreamSurfaceFilter.cxx
rename to vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
index ed085eb82..ca4ea34c1 100644
--- a/vtkm/filter/testing/UnitTestStreamSurfaceFilter.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
@@ -10,7 +10,7 @@
 
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
-#include <vtkm/filter/StreamSurface.h>
+#include <vtkm/filter/flow/StreamSurface.h>
 
 namespace
 {
@@ -44,7 +44,7 @@ void TestStreamSurface()
                                    vtkm::Particle(vtkm::Vec3f(.1f, 3.0f, .3f), 2),
                                    vtkm::Particle(vtkm::Vec3f(.1f, 3.5f, .2f), 3) });
 
-  vtkm::filter::StreamSurface streamSrf;
+  vtkm::filter::flow::StreamSurface streamSrf;
 
   streamSrf.SetStepSize(0.1f);
   streamSrf.SetNumberOfSteps(20);
diff --git a/vtkm/worklet/testing/UnitTestStreamSurface.cxx b/vtkm/filter/flow/testing/UnitTestStreamSurfaceWorklet.cxx
similarity index 92%
rename from vtkm/worklet/testing/UnitTestStreamSurface.cxx
rename to vtkm/filter/flow/testing/UnitTestStreamSurfaceWorklet.cxx
index 23f611794..07848da0c 100644
--- a/vtkm/worklet/testing/UnitTestStreamSurface.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamSurfaceWorklet.cxx
@@ -10,9 +10,9 @@
 
 #include <vtkm/cont/DataSetBuilderExplicit.h>
 #include <vtkm/cont/testing/Testing.h>
+#include <vtkm/filter/flow/worklet/StreamSurface.h>
 #include <vtkm/io/VTKDataSetWriter.h>
 #include <vtkm/worklet/DispatcherMapField.h>
-#include <vtkm/worklet/StreamSurface.h>
 
 namespace
 {
@@ -53,7 +53,7 @@ void TestSameNumPolylines()
   dsb.AddCell(vtkm::CELL_SHAPE_POLY_LINE, ids);
 
   vtkm::cont::DataSet ds = dsb.Create();
-  vtkm::worklet::StreamSurface streamSurfaceWorklet;
+  vtkm::worklet::flow::StreamSurface streamSurfaceWorklet;
   vtkm::cont::ArrayHandle<vtkm::Vec3f> newPoints;
   vtkm::cont::CellSetSingleType<> newCells;
   streamSurfaceWorklet.Run(ds.GetCoordinateSystem(0), ds.GetCellSet(), newPoints, newCells);
@@ -111,7 +111,7 @@ void TestUnequalNumPolylines(int unequalType)
   dsb.AddCell(vtkm::CELL_SHAPE_POLY_LINE, ids);
 
   vtkm::cont::DataSet ds = dsb.Create();
-  vtkm::worklet::StreamSurface streamSurfaceWorklet;
+  vtkm::worklet::flow::StreamSurface streamSurfaceWorklet;
   vtkm::cont::ArrayHandle<vtkm::Vec3f> newPoints;
   vtkm::cont::CellSetSingleType<> newCells;
   streamSurfaceWorklet.Run(ds.GetCoordinateSystem(0), ds.GetCellSet(), newPoints, newCells);
@@ -124,7 +124,7 @@ void TestUnequalNumPolylines(int unequalType)
                    "Wrong number of cells in StreamSurface worklet");
 }
 
-void TestStreamSurface()
+void TestStreamSurfaceWorklet()
 {
   std::cout << "Testing Stream Surface Worklet" << std::endl;
   TestSameNumPolylines();
@@ -134,7 +134,7 @@ void TestStreamSurface()
 }
 }
 
-int UnitTestStreamSurface(int argc, char* argv[])
+int UnitTestStreamSurfaceWorklet(int argc, char* argv[])
 {
-  return vtkm::cont::testing::Testing::Run(TestStreamSurface, argc, argv);
+  return vtkm::cont::testing::Testing::Run(TestStreamSurfaceWorklet, argc, argv);
 }
diff --git a/vtkm/filter/flow/worklet/CMakeLists.txt b/vtkm/filter/flow/worklet/CMakeLists.txt
index c52ad4eff..1d5116a6c 100644
--- a/vtkm/filter/flow/worklet/CMakeLists.txt
+++ b/vtkm/filter/flow/worklet/CMakeLists.txt
@@ -21,6 +21,7 @@ set(headers
   ParticleAdvectionWorklets.h
   RK4Integrator.h
   TemporalGridEvaluators.h
+  StreamSurface.h
   )
 
 #-----------------------------------------------------------------------------
diff --git a/vtkm/worklet/StreamSurface.h b/vtkm/filter/flow/worklet/StreamSurface.h
similarity index 98%
rename from vtkm/worklet/StreamSurface.h
rename to vtkm/filter/flow/worklet/StreamSurface.h
index a7fef872f..33389bba7 100644
--- a/vtkm/worklet/StreamSurface.h
+++ b/vtkm/filter/flow/worklet/StreamSurface.h
@@ -7,8 +7,8 @@
 //  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
-#ifndef vtk_m_worklet_streamsurface_h
-#define vtk_m_worklet_streamsurface_h
+#ifndef vtk_m_filter_flow_worklet_streamsurface_h
+#define vtk_m_filter_flow_worklet_streamsurface_h
 
 #include <typeinfo>
 #include <vtkm/VectorAnalysis.h>
@@ -24,6 +24,8 @@ namespace vtkm
 {
 namespace worklet
 {
+namespace flow
+{
 
 class StreamSurface
 {
@@ -276,7 +278,9 @@ public:
 
 private:
 };
-}
-}
 
-#endif //  vtk_m_worklet_streamsurface_h
+}
+}
+} //vtkm::worklet::flow
+
+#endif //  vtk_m_filter_flow_worklet_streamsurface_h
diff --git a/vtkm/filter/testing/CMakeLists.txt b/vtkm/filter/testing/CMakeLists.txt
index 59014cec6..5580e99f7 100644
--- a/vtkm/filter/testing/CMakeLists.txt
+++ b/vtkm/filter/testing/CMakeLists.txt
@@ -25,7 +25,6 @@ set(unit_tests
   UnitTestMIRFilter.cxx
   UnitTestMultiBlockFilter.cxx
   UnitTestPartitionedDataSetFilters.cxx
-  UnitTestStreamSurfaceFilter.cxx
 )
 
 set(libraries
@@ -54,8 +53,6 @@ if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
   set(large_kernel_sources
     RegressionTestStreamline.cxx
     UnitTestLagrangianFilter.cxx
-    UnitTestStreamlineFilter.cxx
-    UnitTestStreamSurfaceFilter.cxx
     )
   set_source_files_properties(${large_kernel_sources} PROPERTIES
     COMPILE_OPTIONS "-Xptxas;--disable-optimizer-constants"
diff --git a/vtkm/worklet/CMakeLists.txt b/vtkm/worklet/CMakeLists.txt
index 1a1f16eaa..fd7d8c1ae 100644
--- a/vtkm/worklet/CMakeLists.txt
+++ b/vtkm/worklet/CMakeLists.txt
@@ -40,7 +40,6 @@ set(headers
   StableSortIndices.h
   DescriptiveStatistics.h
   StreamLineUniformGrid.h
-  StreamSurface.h
   TriangleWinding.h
   WaveletCompressor.h
   WorkletMapField.h
diff --git a/vtkm/worklet/testing/CMakeLists.txt b/vtkm/worklet/testing/CMakeLists.txt
index 051fc27fd..d4a94be33 100644
--- a/vtkm/worklet/testing/CMakeLists.txt
+++ b/vtkm/worklet/testing/CMakeLists.txt
@@ -35,7 +35,6 @@ set(unit_tests
   UnitTestSplatKernels.cxx
   UnitTestScatterAndMaskWithTopology.cxx
   UnitTestStreamLineUniformGrid.cxx
-  UnitTestStreamSurface.cxx
   UnitTestTriangleWinding.cxx
   UnitTestWholeCellSetIn.cxx
   UnitTestWorkletMapField.cxx

From 6b668b9fe87c09ee9bc4dd0c5e3aec710d7cf0fa Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 09:56:22 -0400
Subject: [PATCH 045/104] More cleanup of classes.

---
 vtkm/filter/flow/FlowTypes.h                  |  2 +-
 vtkm/filter/flow/NewFilterParticleAdvection.h | 24 +++++++------------
 .../NewFilterParticleAdvectionSteadyState.h   | 12 ++++------
 .../NewFilterParticleAdvectionUnsteadyState.h | 10 ++++----
 vtkm/filter/flow/ParticleAdvection.cxx        |  2 +-
 vtkm/filter/flow/ParticleAdvection.h          | 10 ++++----
 vtkm/filter/flow/PathParticle.cxx             |  5 +++-
 vtkm/filter/flow/PathParticle.h               | 10 ++++----
 vtkm/filter/flow/Pathline.cxx                 |  2 +-
 vtkm/filter/flow/Pathline.h                   |  9 +++----
 vtkm/filter/flow/StreamSurface.h              |  5 +---
 vtkm/filter/flow/Streamline.cxx               |  2 +-
 vtkm/filter/flow/Streamline.h                 |  9 +++----
 13 files changed, 46 insertions(+), 56 deletions(-)

diff --git a/vtkm/filter/flow/FlowTypes.h b/vtkm/filter/flow/FlowTypes.h
index 1099422ce..237f32fb4 100644
--- a/vtkm/filter/flow/FlowTypes.h
+++ b/vtkm/filter/flow/FlowTypes.h
@@ -28,7 +28,7 @@ enum class VectorFieldType
   ELECTRO_MAGNETIC_FIELD_TYPE,
 };
 
-enum class FlowResultType
+enum FlowResultType
 {
   UNKNOWN_TYPE = -1,
   PARTICLE_ADVECT_TYPE,
diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index cb511d2f1..9299fbbb0 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -37,16 +37,7 @@ public:
   using SupportedTypes = vtkm::TypeListFieldVec3;
 
   VTKM_CONT
-  NewFilterParticleAdvection(vtkm::filter::flow::FlowResultType rType)
-    //    : vtkm::filter::NewFilterField()
-    : NumberOfSteps(0)
-    , ResultType(rType)
-    , SolverType(vtkm::filter::flow::IntegrationSolverType::RK4_TYPE)
-    , StepSize(0)
-    , UseThreadedAlgorithm(false)
-    , VecFieldType(vtkm::filter::flow::VectorFieldType::VELOCITY_FIELD_TYPE)
-  {
-  }
+  NewFilterParticleAdvection() {}
 
   VTKM_CONT
   void SetStepSize(vtkm::FloatDefault s) { this->StepSize = s; }
@@ -107,13 +98,14 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("StepSize cannot be negative");
   }
 
-  vtkm::Id NumberOfSteps;
-  vtkm::filter::flow::FlowResultType ResultType = vtkm::filter::flow::FlowResultType::UNKNOWN_TYPE;
+  vtkm::Id NumberOfSteps = 0;
   vtkm::cont::UnknownArrayHandle Seeds;
-  vtkm::filter::flow::IntegrationSolverType SolverType;
-  vtkm::FloatDefault StepSize;
-  bool UseThreadedAlgorithm;
-  vtkm::filter::flow::VectorFieldType VecFieldType;
+  vtkm::filter::flow::IntegrationSolverType SolverType =
+    vtkm::filter::flow::IntegrationSolverType::RK4_TYPE;
+  vtkm::FloatDefault StepSize = 0;
+  bool UseThreadedAlgorithm = false;
+  vtkm::filter::flow::VectorFieldType VecFieldType =
+    vtkm::filter::flow::VectorFieldType::VELOCITY_FIELD_TYPE;
 
 private:
 };
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index 02d9682ed..a7d11eea0 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -24,15 +24,13 @@ class NewFilterParticleAdvectionSteadyState : public NewFilterParticleAdvection
 {
 public:
   VTKM_CONT
-  NewFilterParticleAdvectionSteadyState(vtkm::filter::flow::FlowResultType rType)
-    : NewFilterParticleAdvection(rType)
-  {
-  }
+  NewFilterParticleAdvectionSteadyState() {}
 
 protected:
   VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorSteadyState*> CreateDataSetIntegrators(
     const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::flow::BoundsMap& boundsMap) const
+    const vtkm::filter::flow::BoundsMap& boundsMap,
+    const vtkm::filter::flow::FlowResultType& resultType) const
   {
     using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
 
@@ -46,8 +44,8 @@ protected:
       if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-      dsi.push_back(new DSIType(
-        ds, blockId, activeField, this->SolverType, this->VecFieldType, this->ResultType));
+      dsi.push_back(
+        new DSIType(ds, blockId, activeField, this->SolverType, this->VecFieldType, resultType));
     }
 
     return dsi;
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index 138aaca04..06eaa7b48 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -24,10 +24,7 @@ class NewFilterParticleAdvectionUnsteadyState : public NewFilterParticleAdvectio
 {
 public:
   VTKM_CONT
-  NewFilterParticleAdvectionUnsteadyState(vtkm::filter::flow::FlowResultType rType)
-    : NewFilterParticleAdvection(rType)
-  {
-  }
+  NewFilterParticleAdvectionUnsteadyState() {}
 
   VTKM_CONT void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
 
@@ -47,7 +44,8 @@ protected:
 
   VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorUnsteadyState*>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
-                           const vtkm::filter::flow::BoundsMap& boundsMap) const
+                           const vtkm::filter::flow::BoundsMap& boundsMap,
+                           const vtkm::filter::flow::FlowResultType& resultType) const
   {
     using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
 
@@ -71,7 +69,7 @@ protected:
                                 activeField,
                                 this->SolverType,
                                 this->VecFieldType,
-                                this->ResultType));
+                                resultType));
     }
 
     return dsi;
diff --git a/vtkm/filter/flow/ParticleAdvection.cxx b/vtkm/filter/flow/ParticleAdvection.cxx
index 7f88183ad..0f5573692 100644
--- a/vtkm/filter/flow/ParticleAdvection.cxx
+++ b/vtkm/filter/flow/ParticleAdvection.cxx
@@ -29,7 +29,7 @@ VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection::DoExecutePartitions(
   this->ValidateOptions();
 
   vtkm::filter::flow::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->ResultType);
 
   vtkm::filter::flow::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
diff --git a/vtkm/filter/flow/ParticleAdvection.h b/vtkm/filter/flow/ParticleAdvection.h
index f51e025c8..0b53fb50d 100644
--- a/vtkm/filter/flow/ParticleAdvection.h
+++ b/vtkm/filter/flow/ParticleAdvection.h
@@ -32,15 +32,15 @@ class VTKM_FILTER_FLOW_EXPORT ParticleAdvection
   : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
 public:
-  VTKM_CONT ParticleAdvection()
-    : NewFilterParticleAdvectionSteadyState(
-        vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE)
-  {
-  }
+  VTKM_CONT ParticleAdvection() {}
 
 protected:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
+
+private:
+  const vtkm::filter::flow::FlowResultType ResultType =
+    vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
 };
 
 }
diff --git a/vtkm/filter/flow/PathParticle.cxx b/vtkm/filter/flow/PathParticle.cxx
index 95b7c9093..19cb81cd3 100644
--- a/vtkm/filter/flow/PathParticle.cxx
+++ b/vtkm/filter/flow/PathParticle.cxx
@@ -22,6 +22,9 @@ namespace filter
 namespace flow
 {
 
+//vtkm::filter::flow::FlowResultType PathParticle::ResultType = vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
+
+
 VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
@@ -29,7 +32,7 @@ VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle::DoExecutePartitions(
   this->ValidateOptions();
 
   vtkm::filter::flow::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->ResultType);
 
   vtkm::filter::flow::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
diff --git a/vtkm/filter/flow/PathParticle.h b/vtkm/filter/flow/PathParticle.h
index c0c6034f3..e0d78d743 100644
--- a/vtkm/filter/flow/PathParticle.h
+++ b/vtkm/filter/flow/PathParticle.h
@@ -32,15 +32,15 @@ class VTKM_FILTER_FLOW_EXPORT PathParticle
   : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
 public:
-  VTKM_CONT PathParticle()
-    : NewFilterParticleAdvectionUnsteadyState(
-        vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE)
-  {
-  }
+  VTKM_CONT PathParticle() {}
 
 protected:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
+
+private:
+  const vtkm::filter::flow::FlowResultType ResultType =
+    vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
 };
 
 }
diff --git a/vtkm/filter/flow/Pathline.cxx b/vtkm/filter/flow/Pathline.cxx
index abf9d7f75..e4ae6118a 100644
--- a/vtkm/filter/flow/Pathline.cxx
+++ b/vtkm/filter/flow/Pathline.cxx
@@ -29,7 +29,7 @@ VTKM_CONT vtkm::cont::PartitionedDataSet Pathline::DoExecutePartitions(
   this->ValidateOptions();
 
   vtkm::filter::flow::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->ResultType);
 
   vtkm::filter::flow::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
diff --git a/vtkm/filter/flow/Pathline.h b/vtkm/filter/flow/Pathline.h
index 844e7301a..27979dfa2 100644
--- a/vtkm/filter/flow/Pathline.h
+++ b/vtkm/filter/flow/Pathline.h
@@ -32,14 +32,15 @@ class VTKM_FILTER_FLOW_EXPORT Pathline
   : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
 public:
-  VTKM_CONT Pathline()
-    : NewFilterParticleAdvectionUnsteadyState(vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE)
-  {
-  }
+  VTKM_CONT Pathline() {}
 
 protected:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
+
+private:
+  const vtkm::filter::flow::FlowResultType ResultType =
+    vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
 };
 
 }
diff --git a/vtkm/filter/flow/StreamSurface.h b/vtkm/filter/flow/StreamSurface.h
index c477c87e0..3a5cad7be 100644
--- a/vtkm/filter/flow/StreamSurface.h
+++ b/vtkm/filter/flow/StreamSurface.h
@@ -32,10 +32,7 @@ class VTKM_FILTER_FLOW_EXPORT StreamSurface
   : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
 public:
-  VTKM_CONT StreamSurface()
-    : NewFilterParticleAdvectionSteadyState(vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE)
-  {
-  }
+  VTKM_CONT StreamSurface() {}
 
 protected:
   VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
diff --git a/vtkm/filter/flow/Streamline.cxx b/vtkm/filter/flow/Streamline.cxx
index 97ff51f38..9324afc6f 100644
--- a/vtkm/filter/flow/Streamline.cxx
+++ b/vtkm/filter/flow/Streamline.cxx
@@ -29,7 +29,7 @@ VTKM_CONT vtkm::cont::PartitionedDataSet Streamline::DoExecutePartitions(
   this->ValidateOptions();
 
   vtkm::filter::flow::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->ResultType);
 
   vtkm::filter::flow::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
diff --git a/vtkm/filter/flow/Streamline.h b/vtkm/filter/flow/Streamline.h
index 84a2eef00..1fe45f88d 100644
--- a/vtkm/filter/flow/Streamline.h
+++ b/vtkm/filter/flow/Streamline.h
@@ -32,14 +32,15 @@ class VTKM_FILTER_FLOW_EXPORT Streamline
   : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
 public:
-  VTKM_CONT Streamline()
-    : NewFilterParticleAdvectionSteadyState(vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE)
-  {
-  }
+  VTKM_CONT Streamline() {}
 
 protected:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
+
+private:
+  const vtkm::filter::flow::FlowResultType ResultType =
+    vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
 };
 
 }

From 9b0379722a5627c97f66464fef51f19351893f83 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 10:01:13 -0400
Subject: [PATCH 046/104] Fix example code.

---
 examples/particle_advection/ParticleAdvection.cxx | 4 ++--
 examples/streamline_mpi/StreamlineMPI.cxx         | 9 ++++-----
 examples/temporal_advection/TemporalAdvection.cxx | 4 ++--
 3 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/examples/particle_advection/ParticleAdvection.cxx b/examples/particle_advection/ParticleAdvection.cxx
index e2e4a1695..eff3b1224 100644
--- a/examples/particle_advection/ParticleAdvection.cxx
+++ b/examples/particle_advection/ParticleAdvection.cxx
@@ -10,7 +10,7 @@
 
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/Initialize.h>
-#include <vtkm/filter/Streamline.h>
+#include <vtkm/filter/flow/Streamline.h>
 #include <vtkm/io/VTKDataSetReader.h>
 #include <vtkm/io/VTKDataSetWriter.h>
 
@@ -74,7 +74,7 @@ int main(int argc, char** argv)
   auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off);
 
   //compute streamlines
-  vtkm::filter::Streamline streamline;
+  vtkm::filter::flow::Streamline streamline;
 
   streamline.SetStepSize(stepSize);
   streamline.SetNumberOfSteps(numSteps);
diff --git a/examples/streamline_mpi/StreamlineMPI.cxx b/examples/streamline_mpi/StreamlineMPI.cxx
index 2cc2ffe8a..ac204800f 100644
--- a/examples/streamline_mpi/StreamlineMPI.cxx
+++ b/examples/streamline_mpi/StreamlineMPI.cxx
@@ -14,7 +14,6 @@
 #include <vtkm/cont/Field.h>
 #include <vtkm/cont/Initialize.h>
 #include <vtkm/cont/PartitionedDataSet.h>
-#include <vtkm/filter/Streamline.h>
 #include <vtkm/io/VTKDataSetReader.h>
 #include <vtkm/io/VTKDataSetWriter.h>
 #include <vtkm/io/reader/VTKDataSetReader.h>
@@ -24,9 +23,9 @@
 #include <vtkm/thirdparty/diy/mpi-cast.h>
 
 
-#include <vtkm/filter/ParticleAdvection.h>
-#include <vtkm/filter/particleadvection/BoundsMap.h>
-#include <vtkm/filter/particleadvection/ParticleMessenger.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/ParticleAdvection.h>
+#include <vtkm/filter/flow/ParticleMessenger.h>
 
 
 void LoadData(std::string& fname, std::vector<vtkm::cont::DataSet>& dataSets, int rank, int nRanks)
@@ -99,7 +98,7 @@ int main(int argc, char** argv)
   std::vector<vtkm::cont::DataSet> dataSets;
   LoadData(dataFile, dataSets, rank, size);
 
-  vtkm::filter::ParticleAdvection pa;
+  vtkm::filter::flow::ParticleAdvection pa;
 
   vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
   seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.1f, .1f, .9f), 0),
diff --git a/examples/temporal_advection/TemporalAdvection.cxx b/examples/temporal_advection/TemporalAdvection.cxx
index d4501f475..7f99698a3 100644
--- a/examples/temporal_advection/TemporalAdvection.cxx
+++ b/examples/temporal_advection/TemporalAdvection.cxx
@@ -16,7 +16,7 @@
 #include <vtkm/cont/Initialize.h>
 #include <vtkm/cont/Timer.h>
 
-#include <vtkm/filter/Pathline.h>
+#include <vtkm/filter/flow/Pathline.h>
 
 #include <vtkm/io/VTKDataSetReader.h>
 #include <vtkm/io/VTKDataSetWriter.h>
@@ -91,7 +91,7 @@ int main(int argc, char** argv)
 
   // Instantiate the filter by providing necessary parameters.
   // Necessary parameters are :
-  vtkm::filter::Pathline pathlineFilter;
+  vtkm::filter::flow::Pathline pathlineFilter;
   pathlineFilter.SetActiveField(fieldName);
   // 1. The current and next time slice. The current time slice is passed
   //    through the parameter to the Execute method.

From cdcc083d4c956dda6ad34427c2beb20540cfba0c Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 10:16:05 -0400
Subject: [PATCH 047/104] Fix benchmarks, windows builds?

---
 benchmarking/BenchmarkInSitu.cxx                           | 6 +++---
 benchmarking/BenchmarkODEIntegrators.cxx                   | 7 ++-----
 vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h   | 3 ---
 vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h | 3 ---
 vtkm/filter/flow/ParticleAdvection.h                       | 2 --
 vtkm/filter/flow/PathParticle.h                            | 2 --
 vtkm/filter/flow/Pathline.h                                | 2 --
 vtkm/filter/flow/Streamline.h                              | 2 --
 8 files changed, 5 insertions(+), 22 deletions(-)

diff --git a/benchmarking/BenchmarkInSitu.cxx b/benchmarking/BenchmarkInSitu.cxx
index 6118db06c..6146ccb6b 100644
--- a/benchmarking/BenchmarkInSitu.cxx
+++ b/benchmarking/BenchmarkInSitu.cxx
@@ -25,9 +25,9 @@
 
 #include <vtkm/cont/internal/OptionParser.h>
 
-#include <vtkm/filter/Streamline.h>
 #include <vtkm/filter/contour/Contour.h>
 #include <vtkm/filter/contour/Slice.h>
+#include <vtkm/filter/flow/Streamline.h>
 #include <vtkm/filter/geometry_refinement/Tetrahedralize.h>
 #include <vtkm/filter/geometry_refinement/Tube.h>
 #include <vtkm/filter/vector_analysis/Gradient.h>
@@ -423,7 +423,7 @@ void AddField(vtkm::cont::PartitionedDataSet& input,
 }
 
 template <typename DataSetType>
-DataSetType RunStreamlinesHelper(vtkm::filter::Streamline& filter, const DataSetType& input)
+DataSetType RunStreamlinesHelper(vtkm::filter::flow::Streamline& filter, const DataSetType& input)
 {
   auto dataSetBounds = vtkm::cont::BoundsCompute(input);
   vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
@@ -457,7 +457,7 @@ void BenchStreamlines(::benchmark::State& state)
   BuildInputDataSet(cycle, isStructured, isMultiBlock, DataSetDim);
   inputGenTimer.Stop();
 
-  vtkm::filter::Streamline streamline;
+  vtkm::filter::flow::Streamline streamline;
   streamline.SetStepSize(0.1f);
   streamline.SetNumberOfSteps(1000);
   streamline.SetActiveField(PointVectorsName);
diff --git a/benchmarking/BenchmarkODEIntegrators.cxx b/benchmarking/BenchmarkODEIntegrators.cxx
index 87d9c6ddb..fb267968c 100644
--- a/benchmarking/BenchmarkODEIntegrators.cxx
+++ b/benchmarking/BenchmarkODEIntegrators.cxx
@@ -17,10 +17,7 @@
 #include <vtkm/cont/RuntimeDeviceTracker.h>
 #include <vtkm/cont/Timer.h>
 #include <vtkm/cont/internal/OptionParser.h>
-#include <vtkm/filter/ParticleAdvection.h>
-#include <vtkm/worklet/particleadvection/EulerIntegrator.h>
-#include <vtkm/worklet/particleadvection/RK4Integrator.h>
-
+#include <vtkm/filter/flow/ParticleAdvection.h>
 
 namespace
 {
@@ -50,7 +47,7 @@ void BenchParticleAdvection(::benchmark::State& state)
                                    vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
                                    vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
 
-  vtkm::filter::ParticleAdvection particleAdvection;
+  vtkm::filter::flow::ParticleAdvection particleAdvection;
 
   particleAdvection.SetStepSize(vtkm::FloatDefault(1) / state.range(0));
   particleAdvection.SetNumberOfSteps(static_cast<vtkm::Id>(state.range(0)));
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index a7d11eea0..4c894e5de 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -23,9 +23,6 @@ namespace flow
 class NewFilterParticleAdvectionSteadyState : public NewFilterParticleAdvection
 {
 public:
-  VTKM_CONT
-  NewFilterParticleAdvectionSteadyState() {}
-
 protected:
   VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorSteadyState*> CreateDataSetIntegrators(
     const vtkm::cont::PartitionedDataSet& input,
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index 06eaa7b48..8de031238 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -23,9 +23,6 @@ namespace flow
 class NewFilterParticleAdvectionUnsteadyState : public NewFilterParticleAdvection
 {
 public:
-  VTKM_CONT
-  NewFilterParticleAdvectionUnsteadyState() {}
-
   VTKM_CONT void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
 
   VTKM_CONT void SetNextTime(vtkm::FloatDefault t2) { this->Time2 = t2; }
diff --git a/vtkm/filter/flow/ParticleAdvection.h b/vtkm/filter/flow/ParticleAdvection.h
index 0b53fb50d..dc0caddfe 100644
--- a/vtkm/filter/flow/ParticleAdvection.h
+++ b/vtkm/filter/flow/ParticleAdvection.h
@@ -32,8 +32,6 @@ class VTKM_FILTER_FLOW_EXPORT ParticleAdvection
   : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
 public:
-  VTKM_CONT ParticleAdvection() {}
-
 protected:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
diff --git a/vtkm/filter/flow/PathParticle.h b/vtkm/filter/flow/PathParticle.h
index e0d78d743..9dc59cd8c 100644
--- a/vtkm/filter/flow/PathParticle.h
+++ b/vtkm/filter/flow/PathParticle.h
@@ -32,8 +32,6 @@ class VTKM_FILTER_FLOW_EXPORT PathParticle
   : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
 public:
-  VTKM_CONT PathParticle() {}
-
 protected:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
diff --git a/vtkm/filter/flow/Pathline.h b/vtkm/filter/flow/Pathline.h
index 27979dfa2..7a8ba3c89 100644
--- a/vtkm/filter/flow/Pathline.h
+++ b/vtkm/filter/flow/Pathline.h
@@ -32,8 +32,6 @@ class VTKM_FILTER_FLOW_EXPORT Pathline
   : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
 public:
-  VTKM_CONT Pathline() {}
-
 protected:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
diff --git a/vtkm/filter/flow/Streamline.h b/vtkm/filter/flow/Streamline.h
index 1fe45f88d..5f08adc5a 100644
--- a/vtkm/filter/flow/Streamline.h
+++ b/vtkm/filter/flow/Streamline.h
@@ -32,8 +32,6 @@ class VTKM_FILTER_FLOW_EXPORT Streamline
   : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
 public:
-  VTKM_CONT Streamline() {}
-
 protected:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;

From 0d6591d7a385e116c41f1308d815c5fd8405cf27 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 10:52:15 -0400
Subject: [PATCH 048/104] Fix compile errors on dashboards.

---
 vtkm/filter/CMakeLists.txt                 | 2 --
 vtkm/filter/flow/worklet/EulerIntegrator.h | 3 +++
 vtkm/filter/flow/worklet/RK4Integrator.h   | 3 +++
 3 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index 274cc72d5..573d6e25a 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -100,7 +100,6 @@ set(extra_headers
   Lagrangian.h
   LagrangianStructures.h
   MIRFilter.h
-  StreamSurface.h
   )
 
 set(extra_header_template_sources
@@ -111,7 +110,6 @@ set(extra_header_template_sources
   Lagrangian.hxx
   LagrangianStructures.hxx
   MIRFilter.hxx
-  StreamSurface.hxx
   )
 
 set(core_headers
diff --git a/vtkm/filter/flow/worklet/EulerIntegrator.h b/vtkm/filter/flow/worklet/EulerIntegrator.h
index dbcd60158..8d2b074bd 100644
--- a/vtkm/filter/flow/worklet/EulerIntegrator.h
+++ b/vtkm/filter/flow/worklet/EulerIntegrator.h
@@ -13,6 +13,9 @@
 #ifndef vtk_m_filter_flow_worklet_EulerIntegrator_h
 #define vtk_m_filter_flow_worklet_EulerIntegrator_h
 
+#include <vtkm/filter/flow/worklet/GridEvaluatorStatus.h>
+#include <vtkm/filter/flow/worklet/IntegratorStatus.h>
+
 namespace vtkm
 {
 namespace worklet
diff --git a/vtkm/filter/flow/worklet/RK4Integrator.h b/vtkm/filter/flow/worklet/RK4Integrator.h
index 72d96ce36..ffeab255b 100644
--- a/vtkm/filter/flow/worklet/RK4Integrator.h
+++ b/vtkm/filter/flow/worklet/RK4Integrator.h
@@ -13,6 +13,9 @@
 #ifndef vtk_m_filter_flow_worklet_RK4Integrator_h
 #define vtk_m_filter_flow_worklet_RK4Integrator_h
 
+#include <vtkm/filter/flow/worklet/GridEvaluatorStatus.h>
+#include <vtkm/filter/flow/worklet/IntegratorStatus.h>
+
 namespace vtkm
 {
 namespace worklet

From 9cbf9719a979bb26366397090fdfa73ae109047b Mon Sep 17 00:00:00 2001
From: Li-Ta Lo <ollie@lanl.gov>
Date: Mon, 25 Jul 2022 11:06:35 -0400
Subject: [PATCH 049/104] lower case InvalidValue

---
 vtkm/filter/resampling/Probe.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/vtkm/filter/resampling/Probe.cxx b/vtkm/filter/resampling/Probe.cxx
index 7fc1c1dd9..7ede251c4 100644
--- a/vtkm/filter/resampling/Probe.cxx
+++ b/vtkm/filter/resampling/Probe.cxx
@@ -26,14 +26,14 @@ namespace
 bool DoMapField(vtkm::cont::DataSet& result,
                 const vtkm::cont::Field& field,
                 const vtkm::worklet::Probe& worklet,
-                vtkm::Float64 InvalidValue)
+                vtkm::Float64 invalidValue)
 {
   if (field.IsFieldPoint())
   {
     auto resolve = [&](const auto& concrete) {
       using T = typename std::decay_t<decltype(concrete)>::ValueType;
       vtkm::cont::ArrayHandle<T> outputArray = worklet.ProcessPointField(
-        concrete, vtkm::cont::internal::CastInvalidValue<T>(InvalidValue));
+        concrete, vtkm::cont::internal::CastInvalidValue<T>(invalidValue));
       result.AddPointField(field.GetName(), outputArray);
     };
     field.GetData()
@@ -44,7 +44,7 @@ bool DoMapField(vtkm::cont::DataSet& result,
   else if (field.IsFieldCell())
   {
     vtkm::cont::Field outField;
-    if (vtkm::filter::MapFieldPermutation(field, worklet.GetCellIds(), outField, InvalidValue))
+    if (vtkm::filter::MapFieldPermutation(field, worklet.GetCellIds(), outField, invalidValue))
     {
       // output field should be associated with points
       outField = vtkm::cont::Field(

From ecb3e1e459282fd581dcd118b6cc2bbb3f3363eb Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 11:16:47 -0400
Subject: [PATCH 050/104] more code cleanup.

---
 vtkm/filter/flow/DataSetIntegrator.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/vtkm/filter/flow/DataSetIntegrator.h b/vtkm/filter/flow/DataSetIntegrator.h
index 36c78cf11..aa06f3ec9 100644
--- a/vtkm/filter/flow/DataSetIntegrator.h
+++ b/vtkm/filter/flow/DataSetIntegrator.h
@@ -104,7 +104,8 @@ public:
       this->DoAdvect(bb, stepSize, maxSteps);
     }
 
-    //b.CastAndCall([&] (auto& concrete) { this->DoAdvect(concrete, stepSize, maxSteps); });
+    //Cast the DSIHelperInfo<ParticleType> to the concrete type and call DoAdvect.
+    b.CastAndCall([&](auto& concrete) { this->DoAdvect(concrete, stepSize, maxSteps); });
   }
 
   template <typename ParticleType>

From f798d2470dcdb78b12d94faee8e6e41cd55b47c5 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 11:39:52 -0400
Subject: [PATCH 051/104] comment out CastAndCall for now.

---
 vtkm/filter/flow/DataSetIntegrator.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vtkm/filter/flow/DataSetIntegrator.h b/vtkm/filter/flow/DataSetIntegrator.h
index aa06f3ec9..3680f60ad 100644
--- a/vtkm/filter/flow/DataSetIntegrator.h
+++ b/vtkm/filter/flow/DataSetIntegrator.h
@@ -105,7 +105,7 @@ public:
     }
 
     //Cast the DSIHelperInfo<ParticleType> to the concrete type and call DoAdvect.
-    b.CastAndCall([&](auto& concrete) { this->DoAdvect(concrete, stepSize, maxSteps); });
+    //b.CastAndCall([&](auto& concrete) { this->DoAdvect(concrete, stepSize, maxSteps); });
   }
 
   template <typename ParticleType>

From ed9f6fd4a79e90702dff266fda51d8ba1149d979 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 11:55:36 -0400
Subject: [PATCH 052/104] Remove debugging code.

---
 vtkm/cont/ArrayHandle.h | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/vtkm/cont/ArrayHandle.h b/vtkm/cont/ArrayHandle.h
index 54469ad3f..c8fb07cb9 100644
--- a/vtkm/cont/ArrayHandle.h
+++ b/vtkm/cont/ArrayHandle.h
@@ -364,10 +364,7 @@ public:
   /// with CUDA), then the automatically generated destructor could be
   /// created for all devices, and it would not be valid for all devices.
   ///
-  VTKM_CONT ~ArrayHandle()
-  {
-    //    std::cout<<"ArrayHandle dtor: "<<(void*)this<<std::endl;
-  }
+  VTKM_CONT ~ArrayHandle() {}
 
   /// \brief Copies an ArrayHandle
   ///

From 3ec9fc8580fd326e1cc02c06a959420538a74069 Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <morelandkd@ornl.gov>
Date: Mon, 25 Jul 2022 10:07:22 -0600
Subject: [PATCH 053/104] Fix issue with Variant::CastAndCall with non-const
 reference

There was a typo in the declaration of the `CastAndCall` for a non-const
`Variant`. When determining the `noexcept` status of the function being
called, it was passing in a const reference instead of a regular
reference, which is what is actually passed to the function. This
potentially causes the function call to not match and fail to compile.
---
 vtkm/exec/internal/testing/UnitTestVariant.cxx | 15 +++++++++++++++
 vtkm/internal/VariantImpl.h                    |  5 +++--
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/vtkm/exec/internal/testing/UnitTestVariant.cxx b/vtkm/exec/internal/testing/UnitTestVariant.cxx
index f6e5c9dd4..25dcfd32a 100644
--- a/vtkm/exec/internal/testing/UnitTestVariant.cxx
+++ b/vtkm/exec/internal/testing/UnitTestVariant.cxx
@@ -21,6 +21,7 @@ namespace test_variant
 template <vtkm::IdComponent Index>
 struct TypePlaceholder
 {
+  vtkm::IdComponent Value = Index;
 };
 
 // A class that is trivially copiable but not totally trivial.
@@ -313,6 +314,17 @@ struct TestFunctor
   }
 };
 
+struct TestFunctorModify
+{
+  template <vtkm::IdComponent Index>
+  void operator()(TypePlaceholder<Index>& object, vtkm::Id expectedValue)
+  {
+    VTKM_TEST_ASSERT(Index == expectedValue, "Index = ", Index, ", expected = ", expectedValue);
+    VTKM_TEST_ASSERT(object.Value == expectedValue);
+    ++object.Value;
+  }
+};
+
 void TestGet()
 {
   std::cout << "Test Get" << std::endl;
@@ -429,6 +441,9 @@ void TestCastAndCall()
   VariantType variant26{ TypePlaceholder<26>{} };
   result = variant26.CastAndCall(TestFunctor(), 26);
   VTKM_TEST_ASSERT(test_equal(result, TestValue(26, vtkm::FloatDefault{})));
+
+  variant1.CastAndCall(TestFunctorModify{}, 1);
+  VTKM_TEST_ASSERT(variant1.Get<1>().Value == 2, "Variant object not updated.");
 }
 
 void TestCopyInvalid()
diff --git a/vtkm/internal/VariantImpl.h b/vtkm/internal/VariantImpl.h
index e11926865..5533477cc 100644
--- a/vtkm/internal/VariantImpl.h
+++ b/vtkm/internal/VariantImpl.h
@@ -518,8 +518,9 @@ public:
   }
 
   template <typename Functor, typename... Args>
-  VTK_M_DEVICE auto CastAndCall(Functor&& f, Args&&... args) noexcept(
-    noexcept(f(std::declval<const TypeAt<0>&>(), args...)))
+  VTK_M_DEVICE auto CastAndCall(Functor&& f,
+                                Args&&... args) noexcept(noexcept(f(std::declval<TypeAt<0>&>(),
+                                                                    args...)))
     -> decltype(f(std::declval<TypeAt<0>&>(), args...))
   {
     VTKM_ASSERT(this->IsValid());

From 0b2fdea810a3db4a15acfdb6697b21d6919aa519 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 13:34:32 -0400
Subject: [PATCH 054/104] Fixes for Lagrangian

---
 vtkm/filter/CMakeLists.txt         | 18 ++++++++++++++++++
 vtkm/filter/LagrangianDummy.cxx    |  9 +++++++++
 vtkm/filter/testing/CMakeLists.txt |  1 +
 3 files changed, 28 insertions(+)
 create mode 100644 vtkm/filter/LagrangianDummy.cxx

diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index c40209e13..b995b6b65 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -107,6 +107,10 @@ set(extra_header_template_sources
   LagrangianStructures.hxx
   )
 
+set(extra_sources_device
+  LagrangianDummy.cxx
+  )
+
 set(core_headers
   FieldSelection.h
   NewFilter.h
@@ -134,16 +138,30 @@ vtkm_library(
 
 add_library(vtkm_filter INTERFACE)
 
+vtkm_library(
+  NAME vtkm_filter_extra
+  TEMPLATE_SOURCES ${extra_header_template_sources}
+  HEADERS ${extra_headers}
+  DEVICE_SOURCES ${extra_sources_device}
+  USE_VTKM_JOB_POOL
+)
+
 set_target_properties(
   vtkm_filter_core
+  vtkm_filter_extra
   PROPERTIES
   UNITY_BUILD ON
   UNITY_BUILD_MODE BATCH
 )
 
 target_link_libraries(vtkm_filter_core PUBLIC vtkm_cont vtkm_worklet)
+target_link_libraries(vtkm_filter_extra PUBLIC vtkm_cont vtkm_worklet)
+if (VTKm_ENABLE_MPI)
+  target_link_libraries(vtkm_filter_extra PUBLIC MPI::MPI_CXX)
+endif()
 
 target_link_libraries(vtkm_filter PUBLIC INTERFACE
+  vtkm_filter_extra
   vtkm_filter_core
   )
 
diff --git a/vtkm/filter/LagrangianDummy.cxx b/vtkm/filter/LagrangianDummy.cxx
new file mode 100644
index 000000000..f7ff44da2
--- /dev/null
+++ b/vtkm/filter/LagrangianDummy.cxx
@@ -0,0 +1,9 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
diff --git a/vtkm/filter/testing/CMakeLists.txt b/vtkm/filter/testing/CMakeLists.txt
index 0bdda3c83..d80813f23 100644
--- a/vtkm/filter/testing/CMakeLists.txt
+++ b/vtkm/filter/testing/CMakeLists.txt
@@ -21,6 +21,7 @@ set(unit_tests
 
 set(libraries
   vtkm_filter
+  vtkm_filter_extra
   vtkm_io
   vtkm_source
 )

From fab1b9362898f2660cce279168261c16fdc60e02 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 15:33:46 -0400
Subject: [PATCH 055/104] Bug fix for threaded algorithm. Init counter.

---
 vtkm/filter/flow/AdvectAlgorithm.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/vtkm/filter/flow/AdvectAlgorithm.h b/vtkm/filter/flow/AdvectAlgorithm.h
index 99f5e76b9..47d7c78b8 100644
--- a/vtkm/filter/flow/AdvectAlgorithm.h
+++ b/vtkm/filter/flow/AdvectAlgorithm.h
@@ -94,7 +94,6 @@ public:
 
     vtkm::Id nLocal = static_cast<vtkm::Id>(this->Active.size() + this->Inactive.size());
     this->ComputeTotalNumParticles(nLocal);
-    this->TotalNumTerminatedParticles = 0;
 
     while (this->TotalNumTerminatedParticles < this->TotalNumParticles)
     {
@@ -272,8 +271,8 @@ public:
   std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
   vtkm::Id Rank;
   vtkm::FloatDefault StepSize;
-  vtkm::Id TotalNumParticles;
-  vtkm::Id TotalNumTerminatedParticles;
+  vtkm::Id TotalNumParticles = 0;
+  vtkm::Id TotalNumTerminatedParticles = 0;
 };
 
 }

From 5e45d4c8b7712317a8e5b114001f402bc0d8e51f Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 25 Jul 2022 15:44:44 -0400
Subject: [PATCH 056/104] Move Lagrangian into common lib

---
 vtkm/filter/CMakeLists.txt         | 30 +++---------------------------
 vtkm/filter/testing/CMakeLists.txt |  1 -
 2 files changed, 3 insertions(+), 28 deletions(-)

diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt
index b995b6b65..3f09fe818 100644
--- a/vtkm/filter/CMakeLists.txt
+++ b/vtkm/filter/CMakeLists.txt
@@ -84,6 +84,8 @@ set(common_headers
   FilterTraits.h
   PolicyBase.h
   PolicyDefault.h
+  Lagrangian.h
+  LagrangianStructures.h
   )
 
 vtkm_declare_headers(${common_headers})
@@ -93,23 +95,11 @@ set(common_header_template_sources
   FilterDataSetWithField.hxx
   FilterField.hxx
   Filter.hxx
-  )
-
-vtkm_declare_headers(${common_header_template_sources})
-
-set(extra_headers
-  Lagrangian.h
-  LagrangianStructures.h
-  )
-
-set(extra_header_template_sources
   Lagrangian.hxx
   LagrangianStructures.hxx
   )
 
-set(extra_sources_device
-  LagrangianDummy.cxx
-  )
+vtkm_declare_headers(${common_header_template_sources})
 
 set(core_headers
   FieldSelection.h
@@ -138,30 +128,16 @@ vtkm_library(
 
 add_library(vtkm_filter INTERFACE)
 
-vtkm_library(
-  NAME vtkm_filter_extra
-  TEMPLATE_SOURCES ${extra_header_template_sources}
-  HEADERS ${extra_headers}
-  DEVICE_SOURCES ${extra_sources_device}
-  USE_VTKM_JOB_POOL
-)
-
 set_target_properties(
   vtkm_filter_core
-  vtkm_filter_extra
   PROPERTIES
   UNITY_BUILD ON
   UNITY_BUILD_MODE BATCH
 )
 
 target_link_libraries(vtkm_filter_core PUBLIC vtkm_cont vtkm_worklet)
-target_link_libraries(vtkm_filter_extra PUBLIC vtkm_cont vtkm_worklet)
-if (VTKm_ENABLE_MPI)
-  target_link_libraries(vtkm_filter_extra PUBLIC MPI::MPI_CXX)
-endif()
 
 target_link_libraries(vtkm_filter PUBLIC INTERFACE
-  vtkm_filter_extra
   vtkm_filter_core
   )
 
diff --git a/vtkm/filter/testing/CMakeLists.txt b/vtkm/filter/testing/CMakeLists.txt
index d80813f23..0bdda3c83 100644
--- a/vtkm/filter/testing/CMakeLists.txt
+++ b/vtkm/filter/testing/CMakeLists.txt
@@ -21,7 +21,6 @@ set(unit_tests
 
 set(libraries
   vtkm_filter
-  vtkm_filter_extra
   vtkm_io
   vtkm_source
 )

From 5a3e871e579ceeee81eb1521abbea8ce6e3dd106 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 26 Jul 2022 13:49:42 -0400
Subject: [PATCH 057/104] Replace cuda compiler info for advection

---
 vtkm/filter/flow/testing/CMakeLists.txt | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index c9579b246..c914d1327 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -20,6 +20,26 @@ set(libraries
   vtkm_filter_flow
   )
 
+
+if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
+#CUDA architecture has a limited amount of memory available for constants.The CUDA
+#compiler uses this space to hold constants for some optimizations.However, for large
+#kernels, the number of constants needed might be larger than the constant space
+#available.For these conditions, you have to disable this form of optimization with
+#the - Xptxas-- disable - optimizer - constants flags.
+#TODO : Find a more elegant way to do this.Either figure out a way around this problem
+# or add more general flags to vtkm_library / vtkm_unit_tests for sources with "large" kernels.
+  set(large_kernel_sources
+    UnitTestStreamlineFilter.cxx
+    UnitTestStreamSurfaceFilter.cxx
+    UnitTestWorkletParticleAdvection.cxx
+    UnitTestWorkletTemporalAdvection.cxx
+    )
+  set_source_files_properties(${large_kernel_sources} PROPERTIES
+    COMPILE_OPTIONS "-Xptxas;--disable-optimizer-constants"
+    )
+endif()
+
 vtkm_unit_tests(
   SOURCES ${unit_tests}
   LIBRARIES ${libraries} vtkm_filter vtkm_io

From 8ec3cdd199faa9ec453bece4aaa386ab018a6d07 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 26 Jul 2022 14:36:12 -0400
Subject: [PATCH 058/104] Fix warnings for windows builds.

---
 vtkm/filter/flow/NewFilterParticleAdvection.h              | 3 ++-
 vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h   | 4 +++-
 vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h | 4 +++-
 3 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index 9299fbbb0..07fc28d48 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -18,6 +18,7 @@
 #include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
 #include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
 #include <vtkm/filter/flow/FlowTypes.h>
+#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
 {
@@ -31,7 +32,7 @@ namespace flow
 /// Takes as input a vector field and seed locations and advects the seeds
 /// through the flow field.
 
-class NewFilterParticleAdvection : public vtkm::filter::NewFilterField
+class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvection : public vtkm::filter::NewFilterField
 {
 public:
   using SupportedTypes = vtkm::TypeListFieldVec3;
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index 4c894e5de..09ce23f36 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -12,6 +12,7 @@
 #define vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
 
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
+#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
 {
@@ -20,7 +21,8 @@ namespace filter
 namespace flow
 {
 
-class NewFilterParticleAdvectionSteadyState : public NewFilterParticleAdvection
+class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionSteadyState
+  : public NewFilterParticleAdvection
 {
 public:
 protected:
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index 8de031238..3579b86d4 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -12,6 +12,7 @@
 #define vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
 
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
+#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
 {
@@ -20,7 +21,8 @@ namespace filter
 namespace flow
 {
 
-class NewFilterParticleAdvectionUnsteadyState : public NewFilterParticleAdvection
+class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionUnsteadyState
+  : public NewFilterParticleAdvection
 {
 public:
   VTKM_CONT void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }

From d1d5bba1c93d3a0878c91d205735e537e8f26fbb Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 26 Jul 2022 16:41:26 -0400
Subject: [PATCH 059/104] Remove Xptxas option.

---
 vtkm/filter/testing/CMakeLists.txt | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/vtkm/filter/testing/CMakeLists.txt b/vtkm/filter/testing/CMakeLists.txt
index 0bdda3c83..cb1721bf5 100644
--- a/vtkm/filter/testing/CMakeLists.txt
+++ b/vtkm/filter/testing/CMakeLists.txt
@@ -33,7 +33,7 @@ if (VTKm_ENABLE_RENDERING)
   )
 endif()
 
-if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
+#if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
 #CUDA architecture has a limited amount of memory available for constants.The CUDA
 #compiler uses this space to hold constants for some optimizations.However, for large
 #kernels, the number of constants needed might be larger than the constant space
@@ -41,14 +41,14 @@ if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
 #the - Xptxas-- disable - optimizer - constants flags.
 #TODO : Find a more elegant way to do this.Either figure out a way around this problem
 # or add more general flags to vtkm_library / vtkm_unit_tests for sources with "large" kernels.
-  set(large_kernel_sources
-    RegressionTestStreamline.cxx
-    UnitTestLagrangianFilter.cxx
-    )
-  set_source_files_properties(${large_kernel_sources} PROPERTIES
-    COMPILE_OPTIONS "-Xptxas;--disable-optimizer-constants"
-    )
-endif()
+#  set(large_kernel_sources
+#    RegressionTestStreamline.cxx
+#    UnitTestLagrangianFilter.cxx
+#    )
+#  set_source_files_properties(${large_kernel_sources} PROPERTIES
+#    COMPILE_OPTIONS "-Xptxas;--disable-optimizer-constants"
+#    )
+#endif()
 
 vtkm_unit_tests(
   DEVICE_SOURCES ${unit_tests}

From 8d0be0dbbcf9936dec528946d3eae60f1cb9100b Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Tue, 26 Jul 2022 22:33:35 -0400
Subject: [PATCH 060/104] take out Xptxas flag.

---
 vtkm/filter/flow/testing/CMakeLists.txt | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index c914d1327..4363a397e 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -21,7 +21,7 @@ set(libraries
   )
 
 
-if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
+#if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
 #CUDA architecture has a limited amount of memory available for constants.The CUDA
 #compiler uses this space to hold constants for some optimizations.However, for large
 #kernels, the number of constants needed might be larger than the constant space
@@ -29,16 +29,16 @@ if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
 #the - Xptxas-- disable - optimizer - constants flags.
 #TODO : Find a more elegant way to do this.Either figure out a way around this problem
 # or add more general flags to vtkm_library / vtkm_unit_tests for sources with "large" kernels.
-  set(large_kernel_sources
-    UnitTestStreamlineFilter.cxx
-    UnitTestStreamSurfaceFilter.cxx
-    UnitTestWorkletParticleAdvection.cxx
-    UnitTestWorkletTemporalAdvection.cxx
-    )
-  set_source_files_properties(${large_kernel_sources} PROPERTIES
-    COMPILE_OPTIONS "-Xptxas;--disable-optimizer-constants"
-    )
-endif()
+#  set(large_kernel_sources
+#    UnitTestStreamlineFilter.cxx
+#    UnitTestStreamSurfaceFilter.cxx
+#    UnitTestWorkletParticleAdvection.cxx
+#    UnitTestWorkletTemporalAdvection.cxx
+#    )
+#  set_source_files_properties(${large_kernel_sources} PROPERTIES
+#    COMPILE_OPTIONS "--disable-optimizer-constants"
+#    )
+#endif()
 
 vtkm_unit_tests(
   SOURCES ${unit_tests}

From 752fd6ab7178601aa314534e1e7c45a209e222a1 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 27 Jul 2022 09:38:44 -0400
Subject: [PATCH 061/104] add cuda flags for streamsrf worklet.

---
 vtkm/filter/flow/testing/CMakeLists.txt | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index 4363a397e..d6b54d63e 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -21,7 +21,7 @@ set(libraries
   )
 
 
-#if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
+if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
 #CUDA architecture has a limited amount of memory available for constants.The CUDA
 #compiler uses this space to hold constants for some optimizations.However, for large
 #kernels, the number of constants needed might be larger than the constant space
@@ -29,16 +29,17 @@ set(libraries
 #the - Xptxas-- disable - optimizer - constants flags.
 #TODO : Find a more elegant way to do this.Either figure out a way around this problem
 # or add more general flags to vtkm_library / vtkm_unit_tests for sources with "large" kernels.
-#  set(large_kernel_sources
-#    UnitTestStreamlineFilter.cxx
-#    UnitTestStreamSurfaceFilter.cxx
-#    UnitTestWorkletParticleAdvection.cxx
-#    UnitTestWorkletTemporalAdvection.cxx
-#    )
-#  set_source_files_properties(${large_kernel_sources} PROPERTIES
-#    COMPILE_OPTIONS "--disable-optimizer-constants"
-#    )
-#endif()
+  set(large_kernel_sources
+    UnitTestStreamlineFilter.cxx
+    UnitTestStreamSurfaceFilter.cxx
+    UnitTestStreamSurfaceWorklet.cxx
+    UnitTestWorkletParticleAdvection.cxx
+    UnitTestWorkletTemporalAdvection.cxx
+    )
+  set_source_files_properties(${large_kernel_sources} PROPERTIES
+    COMPILE_OPTIONS "-Xptxas;--disable-optimizer-constants"
+    )
+endif()
 
 vtkm_unit_tests(
   SOURCES ${unit_tests}

From 796497170dfba9afa2e3c4a926dbcad58b4e006b Mon Sep 17 00:00:00 2001
From: Sujin Philip <sujin.philip@kitware.com>
Date: Tue, 26 Jul 2022 13:39:08 -0400
Subject: [PATCH 062/104] DataSet::GetFieldIndex should not throw

As per its documentation, DataSet::GetFieldIndex should return -1 when
a field with the given name is not found.
---
 vtkm/cont/DataSet.cxx | 44 +++++++++++++++++++++++--------------------
 vtkm/cont/DataSet.h   | 27 +++++---------------------
 2 files changed, 29 insertions(+), 42 deletions(-)

diff --git a/vtkm/cont/DataSet.cxx b/vtkm/cont/DataSet.cxx
index 819b4f312..8c2e81f12 100644
--- a/vtkm/cont/DataSet.cxx
+++ b/vtkm/cont/DataSet.cxx
@@ -59,16 +59,35 @@ vtkm::cont::Field& DataSet::GetField(vtkm::Id index)
 
 vtkm::Id DataSet::GetFieldIndex(const std::string& name, vtkm::cont::Field::Association assoc) const
 {
-  bool found;
-  vtkm::Id index = this->FindFieldIndex(name, assoc, found);
-  if (found)
+  const auto it = this->Fields.find({ name, assoc });
+  if (it != this->Fields.end())
   {
-    return index;
+    return static_cast<vtkm::Id>(std::distance(this->Fields.begin(), it));
   }
-  else
+  return -1;
+}
+
+const vtkm::cont::Field& DataSet::GetField(const std::string& name,
+                                           vtkm::cont::Field::Association assoc) const
+{
+  auto idx = this->GetFieldIndex(name, assoc);
+  if (idx == -1)
   {
     throw vtkm::cont::ErrorBadValue("No field with requested name: " + name);
   }
+
+  return this->GetField(idx);
+}
+
+vtkm::cont::Field& DataSet::GetField(const std::string& name, vtkm::cont::Field::Association assoc)
+{
+  auto idx = this->GetFieldIndex(name, assoc);
+  if (idx == -1)
+  {
+    throw vtkm::cont::ErrorBadValue("No field with requested name: " + name);
+  }
+
+  return this->GetField(idx);
 }
 
 const vtkm::cont::CoordinateSystem& DataSet::GetCoordinateSystem(vtkm::Id index) const
@@ -150,21 +169,6 @@ void DataSet::PrintSummary(std::ostream& out) const
   out.flush();
 }
 
-vtkm::Id DataSet::FindFieldIndex(const std::string& name,
-                                 vtkm::cont::Field::Association association,
-                                 bool& found) const
-{
-  const auto it = this->Fields.find({ name, association });
-  if (it != this->Fields.end())
-  {
-    found = true;
-    return static_cast<vtkm::Id>(std::distance(this->Fields.begin(), it));
-  }
-
-  found = false;
-  return -1;
-}
-
 VTKM_CONT void DataSet::AddField(const Field& field)
 {
   // map::insert will not replace the duplicated element
diff --git a/vtkm/cont/DataSet.h b/vtkm/cont/DataSet.h
index 80d90cda5..85b7eb9bb 100644
--- a/vtkm/cont/DataSet.h
+++ b/vtkm/cont/DataSet.h
@@ -50,25 +50,19 @@ public:
   bool HasField(const std::string& name,
                 vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const
   {
-    bool found = false;
-    this->FindFieldIndex(name, assoc, found);
-    return found;
+    return (this->GetFieldIndex(name, assoc) != -1);
   }
 
   VTKM_CONT
   bool HasCellField(const std::string& name) const
   {
-    bool found = false;
-    this->FindFieldIndex(name, vtkm::cont::Field::Association::Cells, found);
-    return found;
+    return (this->GetFieldIndex(name, vtkm::cont::Field::Association::Cells) != -1);
   }
 
   VTKM_CONT
   bool HasPointField(const std::string& name) const
   {
-    bool found = false;
-    this->FindFieldIndex(name, vtkm::cont::Field::Association::Points, found);
-    return found;
+    return (this->GetFieldIndex(name, vtkm::cont::Field::Association::Points) != -1);
   }
 
 
@@ -85,18 +79,12 @@ public:
   VTKM_CONT
   const vtkm::cont::Field& GetField(
     const std::string& name,
-    vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const
-  {
-    return this->GetField(this->GetFieldIndex(name, assoc));
-  }
+    vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const;
 
   VTKM_CONT
   vtkm::cont::Field& GetField(
     const std::string& name,
-    vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any)
-  {
-    return this->GetField(this->GetFieldIndex(name, assoc));
-  }
+    vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any);
   //@}
 
   /// Returns the first cell field that matches the provided name.
@@ -296,11 +284,6 @@ private:
   std::vector<vtkm::cont::CoordinateSystem> CoordSystems;
   std::map<FieldCompare::Key, vtkm::cont::Field, FieldCompare> Fields;
   vtkm::cont::UnknownCellSet CellSet;
-
-  VTKM_CONT
-  vtkm::Id FindFieldIndex(const std::string& name,
-                          vtkm::cont::Field::Association association,
-                          bool& found) const;
 };
 
 } // namespace cont

From b9fd70105d0145e7becf2cbcea467f43ce2e8cc3 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 27 Jul 2022 11:39:55 -0400
Subject: [PATCH 063/104] more code cleanup.

---
 vtkm/filter/flow/NewFilterParticleAdvection.h             | 8 +++-----
 .../filter/flow/NewFilterParticleAdvectionUnsteadyState.h | 4 ++--
 vtkm/filter/flow/ParticleAdvection.h                      | 3 +--
 vtkm/filter/flow/PathParticle.h                           | 3 +--
 vtkm/filter/flow/Pathline.h                               | 3 +--
 vtkm/filter/flow/Streamline.h                             | 3 +--
 6 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index 07fc28d48..4481a8e74 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -35,11 +35,6 @@ namespace flow
 class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvection : public vtkm::filter::NewFilterField
 {
 public:
-  using SupportedTypes = vtkm::TypeListFieldVec3;
-
-  VTKM_CONT
-  NewFilterParticleAdvection() {}
-
   VTKM_CONT
   void SetStepSize(vtkm::FloatDefault s) { this->StepSize = s; }
 
@@ -89,6 +84,9 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("Coordinate system as field not supported");
     if (this->Seeds.GetNumberOfValues() == 0)
       throw vtkm::cont::ErrorFilterExecution("No seeds provided.");
+    if (!this->Seeds.IsBaseComponentType<vtkm::Particle>() &&
+        this->Seeds.IsBaseComponentType<vtkm::ChargedParticle>())
+      throw vtkm::cont::ErrorFilterExecution("Unsupported particle type in seed array.");
     if (this->NumberOfSteps == 0)
       throw vtkm::cont::ErrorFilterExecution("Number of steps not specified.");
     if (this->StepSize == 0)
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index 3579b86d4..7651be840 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -75,8 +75,8 @@ protected:
   }
 
   vtkm::cont::PartitionedDataSet Input2;
-  vtkm::FloatDefault Time1;
-  vtkm::FloatDefault Time2;
+  vtkm::FloatDefault Time1 = -1;
+  vtkm::FloatDefault Time2 = -1;
 };
 
 }
diff --git a/vtkm/filter/flow/ParticleAdvection.h b/vtkm/filter/flow/ParticleAdvection.h
index dc0caddfe..8ce1e0c82 100644
--- a/vtkm/filter/flow/ParticleAdvection.h
+++ b/vtkm/filter/flow/ParticleAdvection.h
@@ -32,11 +32,10 @@ class VTKM_FILTER_FLOW_EXPORT ParticleAdvection
   : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
 public:
-protected:
+private:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
 
-private:
   const vtkm::filter::flow::FlowResultType ResultType =
     vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
 };
diff --git a/vtkm/filter/flow/PathParticle.h b/vtkm/filter/flow/PathParticle.h
index 9dc59cd8c..1368a1a2f 100644
--- a/vtkm/filter/flow/PathParticle.h
+++ b/vtkm/filter/flow/PathParticle.h
@@ -32,11 +32,10 @@ class VTKM_FILTER_FLOW_EXPORT PathParticle
   : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
 public:
-protected:
+private:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
 
-private:
   const vtkm::filter::flow::FlowResultType ResultType =
     vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
 };
diff --git a/vtkm/filter/flow/Pathline.h b/vtkm/filter/flow/Pathline.h
index 7a8ba3c89..25f8ef76e 100644
--- a/vtkm/filter/flow/Pathline.h
+++ b/vtkm/filter/flow/Pathline.h
@@ -32,11 +32,10 @@ class VTKM_FILTER_FLOW_EXPORT Pathline
   : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
 public:
-protected:
+private:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
 
-private:
   const vtkm::filter::flow::FlowResultType ResultType =
     vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
 };
diff --git a/vtkm/filter/flow/Streamline.h b/vtkm/filter/flow/Streamline.h
index 5f08adc5a..d8b579ee5 100644
--- a/vtkm/filter/flow/Streamline.h
+++ b/vtkm/filter/flow/Streamline.h
@@ -32,11 +32,10 @@ class VTKM_FILTER_FLOW_EXPORT Streamline
   : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
 public:
-protected:
+private:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
 
-private:
   const vtkm::filter::flow::FlowResultType ResultType =
     vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
 };

From db8dc0d0807ebbf62ef38e73494c8be7c9e146aa Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 27 Jul 2022 12:05:55 -0400
Subject: [PATCH 064/104] Don't use DSIType pointers.

---
 vtkm/filter/flow/AdvectAlgorithm.h            | 16 +++++++-------
 vtkm/filter/flow/AdvectAlgorithmThreaded.h    |  8 +++----
 .../NewFilterParticleAdvectionSteadyState.h   |  6 ++---
 .../NewFilterParticleAdvectionUnsteadyState.h | 22 +++++++++----------
 vtkm/filter/flow/ParticleAdvector.h           |  4 ++--
 5 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/vtkm/filter/flow/AdvectAlgorithm.h b/vtkm/filter/flow/AdvectAlgorithm.h
index 47d7c78b8..8f4b500e6 100644
--- a/vtkm/filter/flow/AdvectAlgorithm.h
+++ b/vtkm/filter/flow/AdvectAlgorithm.h
@@ -28,7 +28,7 @@ template <typename DSIType, template <typename> class ResultType, typename Parti
 class AdvectAlgorithm
 {
 public:
-  AdvectAlgorithm(const vtkm::filter::flow::BoundsMap& bm, std::vector<DSIType*>& blocks)
+  AdvectAlgorithm(const vtkm::filter::flow::BoundsMap& bm, std::vector<DSIType>& blocks)
     : Blocks(blocks)
     , BoundsMap(bm)
     , NumRanks(this->Comm.size())
@@ -46,14 +46,14 @@ public:
     this->Go();
   }
 
-  vtkm::cont::PartitionedDataSet GetOutput()
+  vtkm::cont::PartitionedDataSet GetOutput() const
   {
     vtkm::cont::PartitionedDataSet output;
 
     for (const auto& b : this->Blocks)
     {
       vtkm::cont::DataSet ds;
-      if (b->template GetOutput<ParticleType>(ds))
+      if (b.template GetOutput<ParticleType>(ds))
         output.AppendPartition(ds);
     }
 
@@ -102,10 +102,10 @@ public:
       if (this->GetActiveParticles(v, blockId))
       {
         //make this a pointer to avoid the copy?
-        auto block = this->GetDataSet(blockId);
+        auto& block = this->GetDataSet(blockId);
         DSIHelperInfoType bb =
           DSIHelperInfo<ParticleType>(v, this->BoundsMap, this->ParticleBlockIDsMap);
-        block->Advect(bb, this->StepSize, this->NumberOfSteps);
+        block.Advect(bb, this->StepSize, this->NumberOfSteps);
         numTerm = this->UpdateResult(bb.Get<DSIHelperInfo<ParticleType>>());
       }
 
@@ -136,10 +136,10 @@ public:
     this->TotalNumParticles = static_cast<vtkm::Id>(total);
   }
 
-  DataSetIntegrator* GetDataSet(vtkm::Id id)
+  DataSetIntegrator& GetDataSet(vtkm::Id id)
   {
     for (auto& it : this->Blocks)
-      if (it->GetID() == id)
+      if (it.GetID() == id)
         return it;
 
     throw vtkm::cont::ErrorFilterExecution("Bad block");
@@ -262,7 +262,7 @@ public:
 
   //Member data
   std::vector<ParticleType> Active;
-  std::vector<DSIType*> Blocks;
+  std::vector<DSIType> Blocks;
   vtkm::filter::flow::BoundsMap BoundsMap;
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
   std::vector<ParticleType> Inactive;
diff --git a/vtkm/filter/flow/AdvectAlgorithmThreaded.h b/vtkm/filter/flow/AdvectAlgorithmThreaded.h
index 7f2ba375e..05cc0692f 100644
--- a/vtkm/filter/flow/AdvectAlgorithmThreaded.h
+++ b/vtkm/filter/flow/AdvectAlgorithmThreaded.h
@@ -30,7 +30,7 @@ template <typename DSIType, template <typename> class ResultType, typename Parti
 class AdvectAlgorithmThreaded : public AdvectAlgorithm<DSIType, ResultType, ParticleType>
 {
 public:
-  AdvectAlgorithmThreaded(const vtkm::filter::flow::BoundsMap& bm, std::vector<DSIType*>& blocks)
+  AdvectAlgorithmThreaded(const vtkm::filter::flow::BoundsMap& bm, std::vector<DSIType>& blocks)
     : AdvectAlgorithm<DSIType, ResultType, ParticleType>(bm, blocks)
     , Done(false)
     , WorkerActivate(false)
@@ -39,7 +39,7 @@ public:
     //When this happens, they are destructed by the time the Manage thread gets them.
     //Set the copy flag so the std::vector is copied into the ArrayHandle
     for (auto& block : this->Blocks)
-      block->SetCopySeedFlag(true);
+      block.SetCopySeedFlag(true);
   }
 
   void Go() override
@@ -117,10 +117,10 @@ protected:
       vtkm::Id blockId = -1;
       if (this->GetActiveParticles(v, blockId))
       {
-        const auto& block = this->GetDataSet(blockId);
+        auto& block = this->GetDataSet(blockId);
         DSIHelperInfoType bb =
           DSIHelperInfo<ParticleType>(v, this->BoundsMap, this->ParticleBlockIDsMap);
-        block->Advect(bb, this->StepSize, this->NumberOfSteps);
+        block.Advect(bb, this->StepSize, this->NumberOfSteps);
         this->UpdateWorkerResult(blockId, bb);
       }
       else
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index 09ce23f36..25b9a6f8e 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -26,7 +26,7 @@ class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionSteadyState
 {
 public:
 protected:
-  VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorSteadyState*> CreateDataSetIntegrators(
+  VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorSteadyState> CreateDataSetIntegrators(
     const vtkm::cont::PartitionedDataSet& input,
     const vtkm::filter::flow::BoundsMap& boundsMap,
     const vtkm::filter::flow::FlowResultType& resultType) const
@@ -35,7 +35,7 @@ protected:
 
     std::string activeField = this->GetActiveFieldName();
 
-    std::vector<DSIType*> dsi;
+    std::vector<DSIType> dsi;
     for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
     {
       vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
@@ -44,7 +44,7 @@ protected:
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
       dsi.push_back(
-        new DSIType(ds, blockId, activeField, this->SolverType, this->VecFieldType, resultType));
+        DSIType(ds, blockId, activeField, this->SolverType, this->VecFieldType, resultType));
     }
 
     return dsi;
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index 7651be840..29cae7ffc 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -41,7 +41,7 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("PreviousTime must be less than NextTime");
   }
 
-  VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorUnsteadyState*>
+  VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorUnsteadyState>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
                            const vtkm::filter::flow::BoundsMap& boundsMap,
                            const vtkm::filter::flow::FlowResultType& resultType) const
@@ -50,7 +50,7 @@ protected:
 
     std::string activeField = this->GetActiveFieldName();
 
-    std::vector<DSIType*> dsi;
+    std::vector<DSIType> dsi;
     for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
     {
       vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
@@ -60,15 +60,15 @@ protected:
           (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-      dsi.push_back(new DSIType(ds1,
-                                ds2,
-                                this->Time1,
-                                this->Time2,
-                                blockId,
-                                activeField,
-                                this->SolverType,
-                                this->VecFieldType,
-                                resultType));
+      dsi.push_back(DSIType(ds1,
+                            ds2,
+                            this->Time1,
+                            this->Time2,
+                            blockId,
+                            activeField,
+                            this->SolverType,
+                            this->VecFieldType,
+                            resultType));
     }
 
     return dsi;
diff --git a/vtkm/filter/flow/ParticleAdvector.h b/vtkm/filter/flow/ParticleAdvector.h
index 84c53f678..a31d37b44 100644
--- a/vtkm/filter/flow/ParticleAdvector.h
+++ b/vtkm/filter/flow/ParticleAdvector.h
@@ -28,7 +28,7 @@ class ParticleAdvector
 {
 public:
   ParticleAdvector(const vtkm::filter::flow::BoundsMap& bm,
-                   const std::vector<DSIType*> blocks,
+                   const std::vector<DSIType>& blocks,
                    const bool& useThreaded,
                    const vtkm::filter::flow::FlowResultType& parType)
     : Blocks(blocks)
@@ -108,7 +108,7 @@ private:
   }
 
 
-  std::vector<DSIType*> Blocks;
+  std::vector<DSIType> Blocks;
   vtkm::filter::flow::BoundsMap BoundsMap;
   FlowResultType ResultType;
   bool UseThreadedAlgorithm;

From e7d18d5935d705a8650930add28015be7dfcbd02 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 27 Jul 2022 12:39:28 -0400
Subject: [PATCH 065/104] push_back --> emplace_back

---
 vtkm/filter/flow/AdvectAlgorithm.h            |  6 +++---
 vtkm/filter/flow/AdvectAlgorithmThreaded.h    |  4 ++--
 vtkm/filter/flow/BoundsMap.h                  |  4 ++--
 vtkm/filter/flow/DataSetIntegrator.h          | 20 ++++++++++---------
 vtkm/filter/flow/Messenger.cxx                | 20 +++++++++----------
 .../NewFilterParticleAdvectionSteadyState.h   |  2 +-
 .../NewFilterParticleAdvectionUnsteadyState.h | 18 ++++++++---------
 vtkm/filter/flow/ParticleMessenger.h          | 10 +++++-----
 8 files changed, 43 insertions(+), 41 deletions(-)

diff --git a/vtkm/filter/flow/AdvectAlgorithm.h b/vtkm/filter/flow/AdvectAlgorithm.h
index 8f4b500e6..7897abb12 100644
--- a/vtkm/filter/flow/AdvectAlgorithm.h
+++ b/vtkm/filter/flow/AdvectAlgorithm.h
@@ -78,8 +78,8 @@ public:
 
       if (!ids.empty() && this->BoundsMap.FindRank(ids[0]) == this->Rank)
       {
-        particles.push_back(p);
-        blockIDs.push_back(ids);
+        particles.emplace_back(p);
+        blockIDs.emplace_back(ids);
       }
     }
 
@@ -176,7 +176,7 @@ public:
       auto p = *it;
       if (blockId == this->ParticleBlockIDsMap[p.ID][0])
       {
-        particles.push_back(p);
+        particles.emplace_back(p);
         it = this->Active.erase(it);
       }
       else
diff --git a/vtkm/filter/flow/AdvectAlgorithmThreaded.h b/vtkm/filter/flow/AdvectAlgorithmThreaded.h
index 05cc0692f..f72909010 100644
--- a/vtkm/filter/flow/AdvectAlgorithmThreaded.h
+++ b/vtkm/filter/flow/AdvectAlgorithmThreaded.h
@@ -48,7 +48,7 @@ public:
     this->ComputeTotalNumParticles(nLocal);
 
     std::vector<std::thread> workerThreads;
-    workerThreads.push_back(std::thread(AdvectAlgorithmThreaded::Worker, this));
+    workerThreads.emplace_back(std::thread(AdvectAlgorithmThreaded::Worker, this));
     this->Manage();
 
     //This will only work for 1 thread. For > 1, the Blocks will need a mutex.
@@ -106,7 +106,7 @@ protected:
   {
     std::lock_guard<std::mutex> lock(this->Mutex);
     auto& it = this->WorkerResults[blockId];
-    it.push_back(b);
+    it.emplace_back(b);
   }
 
   void Work()
diff --git a/vtkm/filter/flow/BoundsMap.h b/vtkm/filter/flow/BoundsMap.h
index b2b162fa9..f02bb678b 100644
--- a/vtkm/filter/flow/BoundsMap.h
+++ b/vtkm/filter/flow/BoundsMap.h
@@ -96,7 +96,7 @@ public:
       for (auto& it : this->BlockBounds)
       {
         if (blockId != ignoreBlock && it.Contains(p))
-          blockIDs.push_back(blockId);
+          blockIDs.emplace_back(blockId);
         blockId++;
       }
     }
@@ -117,7 +117,7 @@ private:
     vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
     assigner.local_gids(Comm.rank(), ids);
     for (const auto& i : ids)
-      this->LocalIDs.push_back(static_cast<vtkm::Id>(i));
+      this->LocalIDs.emplace_back(static_cast<vtkm::Id>(i));
 
     for (vtkm::Id id = 0; id < this->TotalNumBlocks; id++)
       this->BlockToRankMap[id] = assigner.rank(static_cast<int>(id));
diff --git a/vtkm/filter/flow/DataSetIntegrator.h b/vtkm/filter/flow/DataSetIntegrator.h
index 3680f60ad..c7bc538de 100644
--- a/vtkm/filter/flow/DataSetIntegrator.h
+++ b/vtkm/filter/flow/DataSetIntegrator.h
@@ -85,6 +85,8 @@ public:
     //check that things are valid.
   }
 
+  virtual ~DataSetIntegrator() {}
+
   VTKM_CONT vtkm::Id GetID() const { return this->Id; }
   VTKM_CONT void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
 
@@ -175,8 +177,8 @@ VTKM_CONT void DataSetIntegrator::ClassifyParticles(
 
     if (p.Status.CheckTerminate())
     {
-      dsiInfo.TermIdx.push_back(i);
-      dsiInfo.TermID.push_back(p.ID);
+      dsiInfo.TermIdx.emplace_back(i);
+      dsiInfo.TermID.emplace_back(p.ID);
     }
     else
     {
@@ -197,8 +199,8 @@ VTKM_CONT void DataSetIntegrator::ClassifyParticles(
       if (newIDs.empty()) //No blocks, we're done.
       {
         p.Status.SetTerminate();
-        dsiInfo.TermIdx.push_back(i);
-        dsiInfo.TermID.push_back(p.ID);
+        dsiInfo.TermIdx.emplace_back(i);
+        dsiInfo.TermID.emplace_back(p.ID);
       }
       else
       {
@@ -221,12 +223,12 @@ VTKM_CONT void DataSetIntegrator::ClassifyParticles(
         int dstRank = dsiInfo.BoundsMap.FindRank(newIDs[0]);
         if (dstRank == this->Rank)
         {
-          dsiInfo.A.push_back(p);
+          dsiInfo.A.emplace_back(p);
           dsiInfo.IdMapA[p.ID] = newIDs;
         }
         else
         {
-          dsiInfo.I.push_back(p);
+          dsiInfo.I.emplace_back(p);
           dsiInfo.IdMapI[p.ID] = newIDs;
         }
       }
@@ -259,10 +261,10 @@ VTKM_CONT void DataSetIntegrator::UpdateResult(const ResultType<ParticleType>& r
     vtkm::cont::Algorithm::Copy(termPerm, termParticles);
 
     ResType termRes(termParticles);
-    this->Results.push_back(termRes);
+    this->Results.emplace_back(termRes);
   }
   else if (this->IsStreamlineResult())
-    this->Results.push_back(result);
+    this->Results.emplace_back(result);
 }
 
 template <typename ParticleType>
@@ -279,7 +281,7 @@ VTKM_CONT bool DataSetIntegrator::GetOutput(vtkm::cont::DataSet& ds) const
     std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
     allParticles.reserve(nResults);
     for (const auto& vres : this->Results)
-      allParticles.push_back(vres.Get<ResType>().Particles);
+      allParticles.emplace_back(vres.Get<ResType>().Particles);
 
     vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
     vtkm::cont::ParticleArrayCopy(allParticles, pts);
diff --git a/vtkm/filter/flow/Messenger.cxx b/vtkm/filter/flow/Messenger.cxx
index 0baa06c17..ff6e64eab 100644
--- a/vtkm/filter/flow/Messenger.cxx
+++ b/vtkm/filter/flow/Messenger.cxx
@@ -80,7 +80,7 @@ void Messenger::CleanupRequests(int tag)
   for (const auto& i : this->RecvBuffers)
   {
     if (tag == TAG_ANY || tag == i.first.second)
-      delKeys.push_back(i.first);
+      delKeys.emplace_back(i.first);
   }
 
   if (!delKeys.empty())
@@ -150,9 +150,9 @@ void Messenger::CheckRequests(const std::map<RequestTagPair, char*>& buffers,
   {
     if (tagsToCheck.empty() || tagsToCheck.find(it.first.second) != tagsToCheck.end())
     {
-      req.push_back(it.first.first);
-      copy.push_back(it.first.first);
-      tags.push_back(it.first.second);
+      req.emplace_back(it.first.first);
+      copy.emplace_back(it.first.first);
+      tags.emplace_back(it.first.second);
     }
   }
 
@@ -176,7 +176,7 @@ void Messenger::CheckRequests(const std::map<RequestTagPair, char*>& buffers,
   //Add the req/tag to the return vector.
   reqTags.reserve(static_cast<std::size_t>(num));
   for (int i = 0; i < num; i++)
-    reqTags.push_back(RequestTagPair(copy[indices[i]], tags[indices[i]]));
+    reqTags.emplace_back(RequestTagPair(copy[indices[i]], tags[indices[i]]));
 }
 
 bool Messenger::PacketCompare(const char* a, const char* b)
@@ -300,7 +300,7 @@ bool Messenger::RecvData(const std::set<int>& tags,
     if (it == this->RecvBuffers.end())
       throw vtkm::cont::ErrorFilterExecution("receive buffer not found");
 
-    incomingBuffers.push_back(it->second);
+    incomingBuffers.emplace_back(it->second);
     this->RecvBuffers.erase(it);
   }
 
@@ -329,7 +329,7 @@ void Messenger::ProcessReceivedBuffers(std::vector<char*>& incomingBuffers,
       entry.first = header.tag;
       entry.second.save_binary((char*)(buff + sizeof(header)), header.dataSz);
       entry.second.reset();
-      buffers.push_back(std::move(entry));
+      buffers.emplace_back(std::move(entry));
 
       delete[] buff;
     }
@@ -344,12 +344,12 @@ void Messenger::ProcessReceivedBuffers(std::vector<char*>& incomingBuffers,
       if (i2 == this->RecvPackets.end())
       {
         std::list<char*> l;
-        l.push_back(buff);
+        l.emplace_back(buff);
         this->RecvPackets[k] = l;
       }
       else
       {
-        i2->second.push_back(buff);
+        i2->second.emplace_back(buff);
 
         // The last packet came in, merge into one MemStream.
         if (i2->second.size() == header.numPackets)
@@ -370,7 +370,7 @@ void Messenger::ProcessReceivedBuffers(std::vector<char*>& incomingBuffers,
           }
 
           entry.second.reset();
-          buffers.push_back(std::move(entry));
+          buffers.emplace_back(std::move(entry));
           this->RecvPackets.erase(i2);
         }
       }
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index 25b9a6f8e..1e316ff19 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -43,7 +43,7 @@ protected:
       if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-      dsi.push_back(
+      dsi.emplace_back(
         DSIType(ds, blockId, activeField, this->SolverType, this->VecFieldType, resultType));
     }
 
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index 29cae7ffc..083498f52 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -60,15 +60,15 @@ protected:
           (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-      dsi.push_back(DSIType(ds1,
-                            ds2,
-                            this->Time1,
-                            this->Time2,
-                            blockId,
-                            activeField,
-                            this->SolverType,
-                            this->VecFieldType,
-                            resultType));
+      dsi.emplace_back(DSIType(ds1,
+                               ds2,
+                               this->Time1,
+                               this->Time2,
+                               blockId,
+                               activeField,
+                               this->SolverType,
+                               this->VecFieldType,
+                               resultType));
     }
 
     return dsi;
diff --git a/vtkm/filter/flow/ParticleMessenger.h b/vtkm/filter/flow/ParticleMessenger.h
index aa45b143e..ea3189b11 100644
--- a/vtkm/filter/flow/ParticleMessenger.h
+++ b/vtkm/filter/flow/ParticleMessenger.h
@@ -172,7 +172,7 @@ void ParticleMessenger<ParticleType>::SerialExchange(
   for (auto& p : outData)
   {
     const auto& bids = outBlockIDsMap.find(p.ID)->second;
-    inData.push_back(p);
+    inData.emplace_back(p);
     inDataBlockIDsMap[p.ID] = bids;
   }
 }
@@ -204,7 +204,7 @@ void ParticleMessenger<ParticleType>::Exchange(
   {
     const auto& bids = outBlockIDsMap.find(p.ID)->second;
     int dstRank = this->BoundsMap.FindRank(bids[0]);
-    sendData[dstRank].push_back(std::make_pair(p, bids));
+    sendData[dstRank].emplace_back(std::make_pair(p, bids));
   }
 
   //Do all the sends first.
@@ -223,7 +223,7 @@ void ParticleMessenger<ParticleType>::Exchange(
       {
         const auto& p = v.first;
         const auto& bids = v.second;
-        inData.push_back(p);
+        inData.emplace_back(p);
         inDataBlockIDsMap[p.ID] = bids;
       }
 
@@ -309,7 +309,7 @@ bool ParticleMessenger<ParticleType>::RecvAny(std::vector<MsgCommType>* msgs,
       std::vector<int> m;
       vtkmdiy::load(buff.second, sendRank);
       vtkmdiy::load(buff.second, m);
-      msgs->push_back(std::make_pair(sendRank, m));
+      msgs->emplace_back(std::make_pair(sendRank, m));
     }
     else if (buff.first == ParticleMessenger::PARTICLE_TAG)
     {
@@ -318,7 +318,7 @@ bool ParticleMessenger<ParticleType>::RecvAny(std::vector<MsgCommType>* msgs,
 
       vtkmdiy::load(buff.second, sendRank);
       vtkmdiy::load(buff.second, particles);
-      recvParticles->push_back(std::make_pair(sendRank, particles));
+      recvParticles->emplace_back(std::make_pair(sendRank, particles));
     }
   }
 

From b1fda7c36e48390db7b107fadb39848e8a0cbf1f Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 27 Jul 2022 21:47:04 -0400
Subject: [PATCH 066/104] Code cleanup.....

---
 vtkm/filter/flow/Messenger.cxx                |  5 +++--
 vtkm/filter/flow/Messenger.h                  |  1 -
 vtkm/filter/flow/NewFilterParticleAdvection.h |  6 +-----
 .../NewFilterParticleAdvectionSteadyState.h   |  4 ++--
 .../NewFilterParticleAdvectionUnsteadyState.h | 19 ++++++++++---------
 vtkm/filter/flow/ParticleAdvection.h          |  1 -
 vtkm/filter/flow/ParticleMessenger.h          |  2 +-
 vtkm/filter/flow/PathParticle.h               |  1 -
 vtkm/filter/flow/Pathline.h                   |  1 -
 vtkm/filter/flow/Streamline.h                 |  1 -
 vtkm/filter/flow/testing/CMakeLists.txt       |  4 ++--
 11 files changed, 19 insertions(+), 26 deletions(-)

diff --git a/vtkm/filter/flow/Messenger.cxx b/vtkm/filter/flow/Messenger.cxx
index ff6e64eab..cca59ea28 100644
--- a/vtkm/filter/flow/Messenger.cxx
+++ b/vtkm/filter/flow/Messenger.cxx
@@ -8,11 +8,12 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ErrorFilterExecution.h>
+#include <vtkm/filter/flow/Messenger.h>
+
 #include <iostream>
 #include <sstream>
 #include <string.h>
-#include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/flow/Messenger.h>
 
 #ifdef VTKM_ENABLE_MPI
 #include <vtkm/thirdparty/diy/mpi-cast.h>
diff --git a/vtkm/filter/flow/Messenger.h b/vtkm/filter/flow/Messenger.h
index 2d874feec..11aa064fa 100644
--- a/vtkm/filter/flow/Messenger.h
+++ b/vtkm/filter/flow/Messenger.h
@@ -12,7 +12,6 @@
 #define vtk_m_filter_flow_Messenger_h
 
 #include <vtkm/Types.h>
-#include <vtkm/cont/Serialization.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 #include <vtkm/thirdparty/diy/diy.h>
 
diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index 4481a8e74..f24ad1bb5 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -12,12 +12,8 @@
 #define vtk_m_filter_flow_NewFilterParticleAdvection_h
 
 #include <vtkm/Particle.h>
+#include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/NewFilterField.h>
-#include <vtkm/filter/flow/BoundsMap.h>
-#include <vtkm/filter/flow/DataSetIntegrator.h>
-#include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
-#include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
-#include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index 1e316ff19..e5b2d9af8 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -11,6 +11,7 @@
 #ifndef vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
 #define vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
 
+#include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
@@ -43,8 +44,7 @@ protected:
       if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-      dsi.emplace_back(
-        DSIType(ds, blockId, activeField, this->SolverType, this->VecFieldType, resultType));
+      dsi.emplace_back(ds, blockId, activeField, this->SolverType, this->VecFieldType, resultType);
     }
 
     return dsi;
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index 083498f52..0162177bf 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -11,6 +11,7 @@
 #ifndef vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
 #define vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
 
+#include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
@@ -60,15 +61,15 @@ protected:
           (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
         throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-      dsi.emplace_back(DSIType(ds1,
-                               ds2,
-                               this->Time1,
-                               this->Time2,
-                               blockId,
-                               activeField,
-                               this->SolverType,
-                               this->VecFieldType,
-                               resultType));
+      dsi.emplace_back(ds1,
+                       ds2,
+                       this->Time1,
+                       this->Time2,
+                       blockId,
+                       activeField,
+                       this->SolverType,
+                       this->VecFieldType,
+                       resultType);
     }
 
     return dsi;
diff --git a/vtkm/filter/flow/ParticleAdvection.h b/vtkm/filter/flow/ParticleAdvection.h
index 8ce1e0c82..1a2cabfd6 100644
--- a/vtkm/filter/flow/ParticleAdvection.h
+++ b/vtkm/filter/flow/ParticleAdvection.h
@@ -11,7 +11,6 @@
 #ifndef vtk_m_filter_flow_ParticleAdvection_h
 #define vtk_m_filter_flow_ParticleAdvection_h
 
-#include <vtkm/Particle.h>
 #include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
diff --git a/vtkm/filter/flow/ParticleMessenger.h b/vtkm/filter/flow/ParticleMessenger.h
index ea3189b11..3802c2564 100644
--- a/vtkm/filter/flow/ParticleMessenger.h
+++ b/vtkm/filter/flow/ParticleMessenger.h
@@ -12,9 +12,9 @@
 #define vtk_m_filter_flow_ParticleMessenger_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/cont/Serialization.h>
 #include <vtkm/filter/flow/BoundsMap.h>
 #include <vtkm/filter/flow/Messenger.h>
+#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 #include <list>
 #include <map>
diff --git a/vtkm/filter/flow/PathParticle.h b/vtkm/filter/flow/PathParticle.h
index 1368a1a2f..a314b624b 100644
--- a/vtkm/filter/flow/PathParticle.h
+++ b/vtkm/filter/flow/PathParticle.h
@@ -11,7 +11,6 @@
 #ifndef vtk_m_filter_PathParticle_h
 #define vtk_m_filter_PathParticle_h
 
-#include <vtkm/Particle.h>
 #include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
diff --git a/vtkm/filter/flow/Pathline.h b/vtkm/filter/flow/Pathline.h
index 25f8ef76e..bcd8ac095 100644
--- a/vtkm/filter/flow/Pathline.h
+++ b/vtkm/filter/flow/Pathline.h
@@ -11,7 +11,6 @@
 #ifndef vtk_m_filter_Pathline_h
 #define vtk_m_filter_Pathline_h
 
-#include <vtkm/Particle.h>
 #include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
diff --git a/vtkm/filter/flow/Streamline.h b/vtkm/filter/flow/Streamline.h
index d8b579ee5..1a66538d7 100644
--- a/vtkm/filter/flow/Streamline.h
+++ b/vtkm/filter/flow/Streamline.h
@@ -11,7 +11,6 @@
 #ifndef vtk_m_filter_flow_Streamline_h
 #define vtk_m_filter_flow_Streamline_h
 
-#include <vtkm/Particle.h>
 #include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index d6b54d63e..9983d7b14 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -29,14 +29,14 @@ if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
 #the - Xptxas-- disable - optimizer - constants flags.
 #TODO : Find a more elegant way to do this.Either figure out a way around this problem
 # or add more general flags to vtkm_library / vtkm_unit_tests for sources with "large" kernels.
-  set(large_kernel_sources
+  set(flow_large_kernel_sources
     UnitTestStreamlineFilter.cxx
     UnitTestStreamSurfaceFilter.cxx
     UnitTestStreamSurfaceWorklet.cxx
     UnitTestWorkletParticleAdvection.cxx
     UnitTestWorkletTemporalAdvection.cxx
     )
-  set_source_files_properties(${large_kernel_sources} PROPERTIES
+  set_source_files_properties(${flow_large_kernel_sources} PROPERTIES
     COMPILE_OPTIONS "-Xptxas;--disable-optimizer-constants"
     )
 endif()

From d6eaf6bb8df0950aba2d4f62c28cd968a11d8416 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 28 Jul 2022 06:55:16 -0400
Subject: [PATCH 067/104] turn on verbose builds

---
 .gitlab/ci/config/gitlab_ci_setup.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitlab/ci/config/gitlab_ci_setup.cmake b/.gitlab/ci/config/gitlab_ci_setup.cmake
index cafefc65d..9b10aba0d 100644
--- a/.gitlab/ci/config/gitlab_ci_setup.cmake
+++ b/.gitlab/ci/config/gitlab_ci_setup.cmake
@@ -81,7 +81,7 @@ endif()
 # In Ninja, we do not need to specify parallelism unless we need to restrict
 # the number of threads.
 if(CTEST_CMAKE_GENERATOR STREQUAL "Ninja" AND DEFINED ENV{CTEST_MAX_PARALLELISM})
-  set(CTEST_BUILD_FLAGS "-j$ENV{CTEST_MAX_PARALLELISM}")
+  set(CTEST_BUILD_FLAGS "--verbose -j$ENV{CTEST_MAX_PARALLELISM}")
 endif()
 
 if(DEFINED ENV{CTEST_MEMORYCHECK_TYPE})

From e9ed3dbb932f3d63f67dff6286c99e85aa176b21 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 28 Jul 2022 07:52:59 -0400
Subject: [PATCH 068/104] dashboard debugging.

---
 vtkm/filter/flow/testing/CMakeLists.txt | 21 ---------------------
 vtkm/filter/testing/CMakeLists.txt      | 17 -----------------
 2 files changed, 38 deletions(-)

diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index 9983d7b14..c9579b246 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -20,27 +20,6 @@ set(libraries
   vtkm_filter_flow
   )
 
-
-if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
-#CUDA architecture has a limited amount of memory available for constants.The CUDA
-#compiler uses this space to hold constants for some optimizations.However, for large
-#kernels, the number of constants needed might be larger than the constant space
-#available.For these conditions, you have to disable this form of optimization with
-#the - Xptxas-- disable - optimizer - constants flags.
-#TODO : Find a more elegant way to do this.Either figure out a way around this problem
-# or add more general flags to vtkm_library / vtkm_unit_tests for sources with "large" kernels.
-  set(flow_large_kernel_sources
-    UnitTestStreamlineFilter.cxx
-    UnitTestStreamSurfaceFilter.cxx
-    UnitTestStreamSurfaceWorklet.cxx
-    UnitTestWorkletParticleAdvection.cxx
-    UnitTestWorkletTemporalAdvection.cxx
-    )
-  set_source_files_properties(${flow_large_kernel_sources} PROPERTIES
-    COMPILE_OPTIONS "-Xptxas;--disable-optimizer-constants"
-    )
-endif()
-
 vtkm_unit_tests(
   SOURCES ${unit_tests}
   LIBRARIES ${libraries} vtkm_filter vtkm_io
diff --git a/vtkm/filter/testing/CMakeLists.txt b/vtkm/filter/testing/CMakeLists.txt
index cb1721bf5..942cc31ec 100644
--- a/vtkm/filter/testing/CMakeLists.txt
+++ b/vtkm/filter/testing/CMakeLists.txt
@@ -33,23 +33,6 @@ if (VTKm_ENABLE_RENDERING)
   )
 endif()
 
-#if ((TARGET vtkm::cuda) OR (TARGET vtkm::kokkos_cuda))
-#CUDA architecture has a limited amount of memory available for constants.The CUDA
-#compiler uses this space to hold constants for some optimizations.However, for large
-#kernels, the number of constants needed might be larger than the constant space
-#available.For these conditions, you have to disable this form of optimization with
-#the - Xptxas-- disable - optimizer - constants flags.
-#TODO : Find a more elegant way to do this.Either figure out a way around this problem
-# or add more general flags to vtkm_library / vtkm_unit_tests for sources with "large" kernels.
-#  set(large_kernel_sources
-#    RegressionTestStreamline.cxx
-#    UnitTestLagrangianFilter.cxx
-#    )
-#  set_source_files_properties(${large_kernel_sources} PROPERTIES
-#    COMPILE_OPTIONS "-Xptxas;--disable-optimizer-constants"
-#    )
-#endif()
-
 vtkm_unit_tests(
   DEVICE_SOURCES ${unit_tests}
   LIBRARIES ${libraries}

From c0364e71cc2d61f96a144cffcf9c6d1800e540c3 Mon Sep 17 00:00:00 2001
From: Sujin Philip <sujin.philip@kitware.com>
Date: Tue, 26 Jul 2022 13:39:08 -0400
Subject: [PATCH 069/104] DataSet::GetFieldIndex should not throw

As per its documentation, DataSet::GetFieldIndex should return -1 when
a field with the given name is not found.
---
 vtkm/cont/DataSet.cxx | 44 +++++++++++++++++++++++--------------------
 vtkm/cont/DataSet.h   | 27 +++++---------------------
 2 files changed, 29 insertions(+), 42 deletions(-)

diff --git a/vtkm/cont/DataSet.cxx b/vtkm/cont/DataSet.cxx
index 819b4f312..8c2e81f12 100644
--- a/vtkm/cont/DataSet.cxx
+++ b/vtkm/cont/DataSet.cxx
@@ -59,16 +59,35 @@ vtkm::cont::Field& DataSet::GetField(vtkm::Id index)
 
 vtkm::Id DataSet::GetFieldIndex(const std::string& name, vtkm::cont::Field::Association assoc) const
 {
-  bool found;
-  vtkm::Id index = this->FindFieldIndex(name, assoc, found);
-  if (found)
+  const auto it = this->Fields.find({ name, assoc });
+  if (it != this->Fields.end())
   {
-    return index;
+    return static_cast<vtkm::Id>(std::distance(this->Fields.begin(), it));
   }
-  else
+  return -1;
+}
+
+const vtkm::cont::Field& DataSet::GetField(const std::string& name,
+                                           vtkm::cont::Field::Association assoc) const
+{
+  auto idx = this->GetFieldIndex(name, assoc);
+  if (idx == -1)
   {
     throw vtkm::cont::ErrorBadValue("No field with requested name: " + name);
   }
+
+  return this->GetField(idx);
+}
+
+vtkm::cont::Field& DataSet::GetField(const std::string& name, vtkm::cont::Field::Association assoc)
+{
+  auto idx = this->GetFieldIndex(name, assoc);
+  if (idx == -1)
+  {
+    throw vtkm::cont::ErrorBadValue("No field with requested name: " + name);
+  }
+
+  return this->GetField(idx);
 }
 
 const vtkm::cont::CoordinateSystem& DataSet::GetCoordinateSystem(vtkm::Id index) const
@@ -150,21 +169,6 @@ void DataSet::PrintSummary(std::ostream& out) const
   out.flush();
 }
 
-vtkm::Id DataSet::FindFieldIndex(const std::string& name,
-                                 vtkm::cont::Field::Association association,
-                                 bool& found) const
-{
-  const auto it = this->Fields.find({ name, association });
-  if (it != this->Fields.end())
-  {
-    found = true;
-    return static_cast<vtkm::Id>(std::distance(this->Fields.begin(), it));
-  }
-
-  found = false;
-  return -1;
-}
-
 VTKM_CONT void DataSet::AddField(const Field& field)
 {
   // map::insert will not replace the duplicated element
diff --git a/vtkm/cont/DataSet.h b/vtkm/cont/DataSet.h
index 4683d993b..18aaca7b4 100644
--- a/vtkm/cont/DataSet.h
+++ b/vtkm/cont/DataSet.h
@@ -51,25 +51,19 @@ public:
   bool HasField(const std::string& name,
                 vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY) const
   {
-    bool found = false;
-    this->FindFieldIndex(name, assoc, found);
-    return found;
+    return (this->GetFieldIndex(name, assoc) != -1);
   }
 
   VTKM_CONT
   bool HasCellField(const std::string& name) const
   {
-    bool found = false;
-    this->FindFieldIndex(name, vtkm::cont::Field::Association::CELL_SET, found);
-    return found;
+    return (this->GetFieldIndex(name, vtkm::cont::Field::Association::CELL_SET) != -1);
   }
 
   VTKM_CONT
   bool HasPointField(const std::string& name) const
   {
-    bool found = false;
-    this->FindFieldIndex(name, vtkm::cont::Field::Association::POINTS, found);
-    return found;
+    return (this->GetFieldIndex(name, vtkm::cont::Field::Association::POINTS) != -1);
   }
 
 
@@ -86,18 +80,12 @@ public:
   VTKM_CONT
   const vtkm::cont::Field& GetField(
     const std::string& name,
-    vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY) const
-  {
-    return this->GetField(this->GetFieldIndex(name, assoc));
-  }
+    vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY) const;
 
   VTKM_CONT
   vtkm::cont::Field& GetField(
     const std::string& name,
-    vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY)
-  {
-    return this->GetField(this->GetFieldIndex(name, assoc));
-  }
+    vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::ANY);
   //@}
 
   /// Returns the first cell field that matches the provided name.
@@ -292,11 +280,6 @@ private:
   std::vector<vtkm::cont::CoordinateSystem> CoordSystems;
   std::map<FieldCompare::Key, vtkm::cont::Field, FieldCompare> Fields;
   vtkm::cont::DynamicCellSet CellSet;
-
-  VTKM_CONT
-  vtkm::Id FindFieldIndex(const std::string& name,
-                          vtkm::cont::Field::Association association,
-                          bool& found) const;
 };
 
 } // namespace cont

From 767b6c004848bb79de98fa24d994b3ab300c907f Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 28 Jul 2022 13:28:09 -0400
Subject: [PATCH 070/104] CUDA fixes move device copy into .cxx file.

---
 benchmarking/BenchmarkInSitu.cxx              |  1 +
 .../temporal_advection/TemporalAdvection.cxx  |  1 +
 vtkm/filter/flow/CMakeLists.txt               |  2 +
 vtkm/filter/flow/NewFilterParticleAdvection.h |  1 +
 .../NewFilterParticleAdvectionSteadyState.cxx | 48 +++++++++++++++
 .../NewFilterParticleAdvectionSteadyState.h   | 26 ++-------
 ...ewFilterParticleAdvectionUnsteadyState.cxx | 58 +++++++++++++++++++
 .../NewFilterParticleAdvectionUnsteadyState.h | 35 ++---------
 vtkm/filter/flow/testing/CMakeLists.txt       | 10 ++--
 .../flow/testing/UnitTestStreamlineFilter.cxx |  1 +
 .../testing/UnitTestStreamlineFilterMPI.cxx   |  1 +
 11 files changed, 129 insertions(+), 55 deletions(-)
 create mode 100644 vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
 create mode 100644 vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx

diff --git a/benchmarking/BenchmarkInSitu.cxx b/benchmarking/BenchmarkInSitu.cxx
index 6146ccb6b..b6c56f3f7 100644
--- a/benchmarking/BenchmarkInSitu.cxx
+++ b/benchmarking/BenchmarkInSitu.cxx
@@ -15,6 +15,7 @@
 
 #include <vtkm/ImplicitFunction.h>
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/BoundsCompute.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/FieldRangeCompute.h>
diff --git a/examples/temporal_advection/TemporalAdvection.cxx b/examples/temporal_advection/TemporalAdvection.cxx
index 7f99698a3..99c75dc37 100644
--- a/examples/temporal_advection/TemporalAdvection.cxx
+++ b/examples/temporal_advection/TemporalAdvection.cxx
@@ -12,6 +12,7 @@
 #include <string>
 #include <vector>
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/Initialize.h>
 #include <vtkm/cont/Timer.h>
diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index c6c641a35..d2b8f65d2 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -30,6 +30,8 @@ set(flow_headers
 
 set(flow_sources
   Messenger.cxx
+  NewFilterParticleAdvectionSteadyState.cxx
+  NewFilterParticleAdvectionUnsteadyState.cxx
   ParticleAdvection.cxx
   Pathline.cxx
   PathParticle.cxx
diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index f24ad1bb5..4c1f3c98a 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -14,6 +14,7 @@
 #include <vtkm/Particle.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/NewFilterField.h>
+#include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
new file mode 100644
index 000000000..37d77b865
--- /dev/null
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
@@ -0,0 +1,48 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
+
+#include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
+
+namespace vtkm
+{
+namespace filter
+{
+namespace flow
+{
+
+VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorSteadyState>
+NewFilterParticleAdvectionSteadyState::CreateDataSetIntegrators(
+  const vtkm::cont::PartitionedDataSet& input,
+  const vtkm::filter::flow::BoundsMap& boundsMap,
+  const vtkm::filter::flow::FlowResultType& resultType) const
+{
+  using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
+
+  std::string activeField = this->GetActiveFieldName();
+
+  std::vector<DSIType> dsi;
+  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
+  {
+    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
+    auto ds = input.GetPartition(i);
+    if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
+      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
+
+    dsi.emplace_back(ds, blockId, activeField, this->SolverType, this->VecFieldType, resultType);
+  }
+
+  return dsi;
+}
+
+}
+}
+} // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index e5b2d9af8..1878fb9a6 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -11,7 +11,8 @@
 #ifndef vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
 #define vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
 
-#include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
+#include <vtkm/filter/flow/BoundsMap.h>
+#include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
@@ -22,6 +23,9 @@ namespace filter
 namespace flow
 {
 
+// Forward declaration
+class DataSetIntegratorSteadyState;
+
 class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionSteadyState
   : public NewFilterParticleAdvection
 {
@@ -30,25 +34,7 @@ protected:
   VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorSteadyState> CreateDataSetIntegrators(
     const vtkm::cont::PartitionedDataSet& input,
     const vtkm::filter::flow::BoundsMap& boundsMap,
-    const vtkm::filter::flow::FlowResultType& resultType) const
-  {
-    using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
-
-    std::string activeField = this->GetActiveFieldName();
-
-    std::vector<DSIType> dsi;
-    for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
-    {
-      vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-      auto ds = input.GetPartition(i);
-      if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
-        throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
-
-      dsi.emplace_back(ds, blockId, activeField, this->SolverType, this->VecFieldType, resultType);
-    }
-
-    return dsi;
-  }
+    const vtkm::filter::flow::FlowResultType& resultType) const;
 };
 
 }
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
new file mode 100644
index 000000000..11490841f
--- /dev/null
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
@@ -0,0 +1,58 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
+
+#include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
+
+namespace vtkm
+{
+namespace filter
+{
+namespace flow
+{
+
+VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorUnsteadyState>
+NewFilterParticleAdvectionUnsteadyState::CreateDataSetIntegrators(
+  const vtkm::cont::PartitionedDataSet& input,
+  const vtkm::filter::flow::BoundsMap& boundsMap,
+  const vtkm::filter::flow::FlowResultType& resultType) const
+{
+  using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
+
+  std::string activeField = this->GetActiveFieldName();
+
+  std::vector<DSIType> dsi;
+  for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
+  {
+    vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
+    auto ds1 = input.GetPartition(i);
+    auto ds2 = this->Input2.GetPartition(i);
+    if ((!ds1.HasPointField(activeField) && !ds1.HasCellField(activeField)) ||
+        (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
+      throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
+
+    dsi.emplace_back(ds1,
+                     ds2,
+                     this->Time1,
+                     this->Time2,
+                     blockId,
+                     activeField,
+                     this->SolverType,
+                     this->VecFieldType,
+                     resultType);
+  }
+
+  return dsi;
+}
+
+}
+}
+} // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index 0162177bf..b7f875aab 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -11,7 +11,7 @@
 #ifndef vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
 #define vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
 
-#include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
+#include <vtkm/filter/flow/BoundsMap.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
@@ -22,6 +22,9 @@ namespace filter
 namespace flow
 {
 
+// Forward declaration
+class DataSetIntegratorUnsteadyState;
+
 class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionUnsteadyState
   : public NewFilterParticleAdvection
 {
@@ -45,35 +48,7 @@ protected:
   VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorUnsteadyState>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
                            const vtkm::filter::flow::BoundsMap& boundsMap,
-                           const vtkm::filter::flow::FlowResultType& resultType) const
-  {
-    using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
-
-    std::string activeField = this->GetActiveFieldName();
-
-    std::vector<DSIType> dsi;
-    for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
-    {
-      vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
-      auto ds1 = input.GetPartition(i);
-      auto ds2 = this->Input2.GetPartition(i);
-      if ((!ds1.HasPointField(activeField) && !ds1.HasCellField(activeField)) ||
-          (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
-        throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
-
-      dsi.emplace_back(ds1,
-                       ds2,
-                       this->Time1,
-                       this->Time2,
-                       blockId,
-                       activeField,
-                       this->SolverType,
-                       this->VecFieldType,
-                       resultType);
-    }
-
-    return dsi;
-  }
+                           const vtkm::filter::flow::FlowResultType& resultType) const;
 
   vtkm::cont::PartitionedDataSet Input2;
   vtkm::FloatDefault Time1 = -1;
diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index c9579b246..63da34ce6 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -9,11 +9,11 @@
 ##============================================================================
 
 set(unit_tests
-UnitTestStreamlineFilter.cxx
-UnitTestWorkletParticleAdvection.cxx
-UnitTestWorkletTemporalAdvection.cxx
-UnitTestStreamSurfaceFilter.cxx
-UnitTestStreamSurfaceWorklet.cxx
+  UnitTestStreamlineFilter.cxx
+  UnitTestWorkletParticleAdvection.cxx
+  UnitTestWorkletTemporalAdvection.cxx
+  UnitTestStreamSurfaceFilter.cxx
+  UnitTestStreamSurfaceWorklet.cxx
   )
 
 set(libraries
diff --git a/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
index aa8b545d5..0e3c56483 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/CellClassification.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/flow/ParticleAdvection.h>
diff --git a/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
index c79b24629..506d5f6c7 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/CellClassification.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/flow/ParticleAdvection.h>
 #include <vtkm/filter/flow/Pathline.h>

From 8d0ad5c2baecffc6d4b918fdd82f27c44f083eec Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 28 Jul 2022 13:34:32 -0400
Subject: [PATCH 071/104] restore gitlab_ci_setup cmake

---
 .gitlab/ci/config/gitlab_ci_setup.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitlab/ci/config/gitlab_ci_setup.cmake b/.gitlab/ci/config/gitlab_ci_setup.cmake
index 9b10aba0d..cafefc65d 100644
--- a/.gitlab/ci/config/gitlab_ci_setup.cmake
+++ b/.gitlab/ci/config/gitlab_ci_setup.cmake
@@ -81,7 +81,7 @@ endif()
 # In Ninja, we do not need to specify parallelism unless we need to restrict
 # the number of threads.
 if(CTEST_CMAKE_GENERATOR STREQUAL "Ninja" AND DEFINED ENV{CTEST_MAX_PARALLELISM})
-  set(CTEST_BUILD_FLAGS "--verbose -j$ENV{CTEST_MAX_PARALLELISM}")
+  set(CTEST_BUILD_FLAGS "-j$ENV{CTEST_MAX_PARALLELISM}")
 endif()
 
 if(DEFINED ENV{CTEST_MEMORYCHECK_TYPE})

From c5dd2d071df2a2fc384bc8920e8457a8e70e48bb Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 28 Jul 2022 15:09:34 -0400
Subject: [PATCH 072/104] Cuda fixes, cleanup.

---
 vtkm/filter/flow/CMakeLists.txt                |  4 ----
 vtkm/filter/flow/NewFilterParticleAdvection.h  |  5 +++++
 .../NewFilterParticleAdvectionSteadyState.cxx  | 16 ++++++++++++++++
 .../NewFilterParticleAdvectionSteadyState.h    |  5 ++++-
 ...NewFilterParticleAdvectionUnsteadyState.cxx | 17 +++++++++++++++++
 .../NewFilterParticleAdvectionUnsteadyState.h  |  4 ++++
 vtkm/filter/flow/ParticleAdvection.cxx         | 15 ---------------
 vtkm/filter/flow/ParticleAdvection.h           |  9 ++++-----
 vtkm/filter/flow/PathParticle.cxx              | 18 ------------------
 vtkm/filter/flow/PathParticle.h                | 10 ++++------
 vtkm/filter/flow/Pathline.cxx                  | 15 ---------------
 vtkm/filter/flow/Pathline.h                    | 10 ++++------
 vtkm/filter/flow/Streamline.cxx                | 15 ---------------
 vtkm/filter/flow/Streamline.h                  | 11 ++++-------
 vtkm/filter/flow/worklet/GridEvaluatorStatus.h |  9 ---------
 vtkm/filter/flow/worklet/ParticleAdvection.h   |  2 --
 .../flow/worklet/ParticleAdvectionWorklets.h   |  7 -------
 vtkm/filter/flow/worklet/Particles.h           |  4 ----
 vtkm/filter/flow/worklet/Stepper.h             | 11 ++---------
 19 files changed, 64 insertions(+), 123 deletions(-)

diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index d2b8f65d2..faead17b1 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -32,10 +32,6 @@ set(flow_sources
   Messenger.cxx
   NewFilterParticleAdvectionSteadyState.cxx
   NewFilterParticleAdvectionUnsteadyState.cxx
-  ParticleAdvection.cxx
-  Pathline.cxx
-  PathParticle.cxx
-  Streamline.cxx
   StreamSurface.cxx
   )
 
diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index 4c1f3c98a..4b56270a7 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -94,6 +94,11 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("StepSize cannot be negative");
   }
 
+  VTKM_CONT virtual vtkm::filter::flow::FlowResultType GetResultType() const
+  {
+    return vtkm::filter::flow::FlowResultType::UNKNOWN_TYPE;
+  }
+
   vtkm::Id NumberOfSteps = 0;
   vtkm::cont::UnknownArrayHandle Seeds;
   vtkm::filter::flow::IntegrationSolverType SolverType =
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
index 37d77b865..c8c388973 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
@@ -11,6 +11,7 @@
 #include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
 
 #include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -43,6 +44,21 @@ NewFilterParticleAdvectionSteadyState::CreateDataSetIntegrators(
   return dsi;
 }
 
+VTKM_CONT vtkm::cont::PartitionedDataSet NewFilterParticleAdvectionSteadyState::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& input)
+{
+  using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
+  this->ValidateOptions();
+
+  vtkm::filter::flow::BoundsMap boundsMap(input);
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->GetResultType());
+
+  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
+    boundsMap, dsi, this->UseThreadedAlgorithm, this->GetResultType());
+
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
+}
+
 }
 }
 } // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index 1878fb9a6..c5839b042 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -29,12 +29,15 @@ class DataSetIntegratorSteadyState;
 class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionSteadyState
   : public NewFilterParticleAdvection
 {
-public:
 protected:
   VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorSteadyState> CreateDataSetIntegrators(
     const vtkm::cont::PartitionedDataSet& input,
     const vtkm::filter::flow::BoundsMap& boundsMap,
     const vtkm::filter::flow::FlowResultType& resultType) const;
+
+private:
+  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
+    const vtkm::cont::PartitionedDataSet& inData) override;
 };
 
 }
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
index 11490841f..4ab82af9b 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
@@ -11,6 +11,7 @@
 #include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
 
 #include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
+#include <vtkm/filter/flow/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -53,6 +54,22 @@ NewFilterParticleAdvectionUnsteadyState::CreateDataSetIntegrators(
   return dsi;
 }
 
+VTKM_CONT vtkm::cont::PartitionedDataSet
+NewFilterParticleAdvectionUnsteadyState::DoExecutePartitions(
+  const vtkm::cont::PartitionedDataSet& input)
+{
+  using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
+  this->ValidateOptions();
+
+  vtkm::filter::flow::BoundsMap boundsMap(input);
+  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->GetResultType());
+
+  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
+    boundsMap, dsi, this->UseThreadedAlgorithm, this->GetResultType());
+
+  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
+}
+
 }
 }
 } // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index b7f875aab..6c963ed0d 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -50,6 +50,10 @@ protected:
                            const vtkm::filter::flow::BoundsMap& boundsMap,
                            const vtkm::filter::flow::FlowResultType& resultType) const;
 
+private:
+  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
+    const vtkm::cont::PartitionedDataSet& inData) override;
+
   vtkm::cont::PartitionedDataSet Input2;
   vtkm::FloatDefault Time1 = -1;
   vtkm::FloatDefault Time2 = -1;
diff --git a/vtkm/filter/flow/ParticleAdvection.cxx b/vtkm/filter/flow/ParticleAdvection.cxx
index 0f5573692..94f6f44c1 100644
--- a/vtkm/filter/flow/ParticleAdvection.cxx
+++ b/vtkm/filter/flow/ParticleAdvection.cxx
@@ -22,21 +22,6 @@ namespace filter
 namespace flow
 {
 
-VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& input)
-{
-  using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
-  this->ValidateOptions();
-
-  vtkm::filter::flow::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->ResultType);
-
-  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
-    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
-}
-
 }
 }
 } // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/ParticleAdvection.h b/vtkm/filter/flow/ParticleAdvection.h
index 1a2cabfd6..07a2e9f0c 100644
--- a/vtkm/filter/flow/ParticleAdvection.h
+++ b/vtkm/filter/flow/ParticleAdvection.h
@@ -32,11 +32,10 @@ class VTKM_FILTER_FLOW_EXPORT ParticleAdvection
 {
 public:
 private:
-  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
-    const vtkm::cont::PartitionedDataSet& inData) override;
-
-  const vtkm::filter::flow::FlowResultType ResultType =
-    vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
+  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override
+  {
+    return vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
+  }
 };
 
 }
diff --git a/vtkm/filter/flow/PathParticle.cxx b/vtkm/filter/flow/PathParticle.cxx
index 19cb81cd3..04f655f55 100644
--- a/vtkm/filter/flow/PathParticle.cxx
+++ b/vtkm/filter/flow/PathParticle.cxx
@@ -22,24 +22,6 @@ namespace filter
 namespace flow
 {
 
-//vtkm::filter::flow::FlowResultType PathParticle::ResultType = vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
-
-
-VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& input)
-{
-  using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
-  this->ValidateOptions();
-
-  vtkm::filter::flow::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->ResultType);
-
-  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
-    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
-}
-
 }
 }
 } // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/PathParticle.h b/vtkm/filter/flow/PathParticle.h
index a314b624b..310ed85dc 100644
--- a/vtkm/filter/flow/PathParticle.h
+++ b/vtkm/filter/flow/PathParticle.h
@@ -30,13 +30,11 @@ namespace flow
 class VTKM_FILTER_FLOW_EXPORT PathParticle
   : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
-public:
 private:
-  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
-    const vtkm::cont::PartitionedDataSet& inData) override;
-
-  const vtkm::filter::flow::FlowResultType ResultType =
-    vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
+  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override
+  {
+    return vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
+  }
 };
 
 }
diff --git a/vtkm/filter/flow/Pathline.cxx b/vtkm/filter/flow/Pathline.cxx
index e4ae6118a..c9a5dd132 100644
--- a/vtkm/filter/flow/Pathline.cxx
+++ b/vtkm/filter/flow/Pathline.cxx
@@ -22,21 +22,6 @@ namespace filter
 namespace flow
 {
 
-VTKM_CONT vtkm::cont::PartitionedDataSet Pathline::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& input)
-{
-  using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
-  this->ValidateOptions();
-
-  vtkm::filter::flow::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->ResultType);
-
-  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
-    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
-}
-
 }
 }
 } // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/Pathline.h b/vtkm/filter/flow/Pathline.h
index bcd8ac095..a8b94afb3 100644
--- a/vtkm/filter/flow/Pathline.h
+++ b/vtkm/filter/flow/Pathline.h
@@ -30,13 +30,11 @@ namespace flow
 class VTKM_FILTER_FLOW_EXPORT Pathline
   : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
-public:
 private:
-  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
-    const vtkm::cont::PartitionedDataSet& inData) override;
-
-  const vtkm::filter::flow::FlowResultType ResultType =
-    vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
+  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override
+  {
+    return vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
+  }
 };
 
 }
diff --git a/vtkm/filter/flow/Streamline.cxx b/vtkm/filter/flow/Streamline.cxx
index 9324afc6f..25c8eabbe 100644
--- a/vtkm/filter/flow/Streamline.cxx
+++ b/vtkm/filter/flow/Streamline.cxx
@@ -22,21 +22,6 @@ namespace filter
 namespace flow
 {
 
-VTKM_CONT vtkm::cont::PartitionedDataSet Streamline::DoExecutePartitions(
-  const vtkm::cont::PartitionedDataSet& input)
-{
-  using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
-  this->ValidateOptions();
-
-  vtkm::filter::flow::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->ResultType);
-
-  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
-    boundsMap, dsi, this->UseThreadedAlgorithm, this->ResultType);
-
-  return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
-}
-
 }
 }
 } // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/Streamline.h b/vtkm/filter/flow/Streamline.h
index 1a66538d7..b5897eed0 100644
--- a/vtkm/filter/flow/Streamline.h
+++ b/vtkm/filter/flow/Streamline.h
@@ -30,13 +30,10 @@ namespace flow
 class VTKM_FILTER_FLOW_EXPORT Streamline
   : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
-public:
-private:
-  VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
-    const vtkm::cont::PartitionedDataSet& inData) override;
-
-  const vtkm::filter::flow::FlowResultType ResultType =
-    vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
+  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override
+  {
+    return vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
+  }
 };
 
 }
diff --git a/vtkm/filter/flow/worklet/GridEvaluatorStatus.h b/vtkm/filter/flow/worklet/GridEvaluatorStatus.h
index 671a69f7f..055ceb60b 100644
--- a/vtkm/filter/flow/worklet/GridEvaluatorStatus.h
+++ b/vtkm/filter/flow/worklet/GridEvaluatorStatus.h
@@ -12,15 +12,6 @@
 #define vtk_m_filter_flow_worklet_GridEvaluatorStatus_h
 
 #include <vtkm/Bitset.h>
-#include <vtkm/Types.h>
-#include <vtkm/VectorAnalysis.h>
-#include <vtkm/cont/ArrayHandle.h>
-#include <vtkm/cont/CellLocatorRectilinearGrid.h>
-#include <vtkm/cont/CellLocatorTwoLevel.h>
-#include <vtkm/cont/CellLocatorUniformGrid.h>
-#include <vtkm/cont/CellSetStructured.h>
-#include <vtkm/cont/DataSet.h>
-#include <vtkm/cont/DeviceAdapter.h>
 
 namespace vtkm
 {
diff --git a/vtkm/filter/flow/worklet/ParticleAdvection.h b/vtkm/filter/flow/worklet/ParticleAdvection.h
index 4e59d1add..60815d786 100644
--- a/vtkm/filter/flow/worklet/ParticleAdvection.h
+++ b/vtkm/filter/flow/worklet/ParticleAdvection.h
@@ -11,9 +11,7 @@
 #ifndef vtk_m_filter_flow_worklet_ParticleAdvection_h
 #define vtk_m_filter_flow_worklet_ParticleAdvection_h
 
-#include <vtkm/Types.h>
 #include <vtkm/cont/ArrayCopy.h>
-#include <vtkm/cont/ArrayHandle.h>
 #include <vtkm/cont/Invoker.h>
 #include <vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h>
 
diff --git a/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h b/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
index b5cf2664e..4885dffcd 100644
--- a/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
+++ b/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
@@ -11,19 +11,12 @@
 #ifndef vtk_m_filter_flow_worklet_ParticleAdvectionWorklets_h
 #define vtk_m_filter_flow_worklet_ParticleAdvectionWorklets_h
 
-#include <vtkm/Types.h>
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
-#include <vtkm/cont/ArrayHandle.h>
-#include <vtkm/cont/ArrayHandleCast.h>
-#include <vtkm/cont/ArrayHandleCounting.h>
 #include <vtkm/cont/CellSetExplicit.h>
 #include <vtkm/cont/ConvertNumComponentsToOffsets.h>
 #include <vtkm/cont/ExecutionObjectBase.h>
 
 #include <vtkm/Particle.h>
 #include <vtkm/filter/flow/worklet/Particles.h>
-#include <vtkm/filter/flow/worklet/Stepper.h>
 #include <vtkm/worklet/WorkletMapField.h>
 
 #ifdef VTKM_CUDA
diff --git a/vtkm/filter/flow/worklet/Particles.h b/vtkm/filter/flow/worklet/Particles.h
index 132dcb3f1..95e77cc38 100644
--- a/vtkm/filter/flow/worklet/Particles.h
+++ b/vtkm/filter/flow/worklet/Particles.h
@@ -11,11 +11,7 @@
 #ifndef vtk_m_filter_flow_worklet_Particles_h
 #define vtk_m_filter_flow_worklet_Particles_h
 
-#include <vtkm/Particle.h>
-#include <vtkm/Types.h>
 #include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
-#include <vtkm/cont/ArrayHandleConstant.h>
 #include <vtkm/cont/ExecutionObjectBase.h>
 #include <vtkm/filter/flow/worklet/IntegratorStatus.h>
 
diff --git a/vtkm/filter/flow/worklet/Stepper.h b/vtkm/filter/flow/worklet/Stepper.h
index 273a3444d..4023bfa04 100644
--- a/vtkm/filter/flow/worklet/Stepper.h
+++ b/vtkm/filter/flow/worklet/Stepper.h
@@ -13,19 +13,12 @@
 #ifndef vtk_m_filter_flow_worklet_Stepper_h
 #define vtk_m_filter_flow_worklet_Stepper_h
 
-#include <limits>
-
-#include <vtkm/Bitset.h>
-#include <vtkm/TypeTraits.h>
-#include <vtkm/Types.h>
-#include <vtkm/VectorAnalysis.h>
-
-#include <vtkm/cont/DataSet.h>
-
 #include <vtkm/filter/flow/worklet/GridEvaluators.h>
 #include <vtkm/filter/flow/worklet/IntegratorStatus.h>
 #include <vtkm/filter/flow/worklet/Particles.h>
 
+#include <limits>
+
 namespace vtkm
 {
 namespace worklet

From 2b58bf6c26bba3b8289f1531449fa4655b7f2f5e Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 28 Jul 2022 15:51:10 -0400
Subject: [PATCH 073/104] Windows link issue...

---
 vtkm/filter/flow/CMakeLists.txt        |  4 ++++
 vtkm/filter/flow/ParticleAdvection.cxx | 10 +++++-----
 vtkm/filter/flow/ParticleAdvection.h   |  5 +----
 vtkm/filter/flow/PathParticle.cxx      | 10 +++++-----
 vtkm/filter/flow/PathParticle.h        |  5 +----
 vtkm/filter/flow/Pathline.cxx          | 10 +++++-----
 vtkm/filter/flow/Pathline.h            |  5 +----
 vtkm/filter/flow/StreamSurface.h       |  3 ---
 vtkm/filter/flow/Streamline.cxx        | 10 +++++-----
 vtkm/filter/flow/Streamline.h          |  6 ++----
 10 files changed, 29 insertions(+), 39 deletions(-)

diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index faead17b1..d2b8f65d2 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -32,6 +32,10 @@ set(flow_sources
   Messenger.cxx
   NewFilterParticleAdvectionSteadyState.cxx
   NewFilterParticleAdvectionUnsteadyState.cxx
+  ParticleAdvection.cxx
+  Pathline.cxx
+  PathParticle.cxx
+  Streamline.cxx
   StreamSurface.cxx
   )
 
diff --git a/vtkm/filter/flow/ParticleAdvection.cxx b/vtkm/filter/flow/ParticleAdvection.cxx
index 94f6f44c1..d833b2289 100644
--- a/vtkm/filter/flow/ParticleAdvection.cxx
+++ b/vtkm/filter/flow/ParticleAdvection.cxx
@@ -8,13 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/flow/BoundsMap.h>
 #include <vtkm/filter/flow/ParticleAdvection.h>
 
-#include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvector.h>
-
 namespace vtkm
 {
 namespace filter
@@ -22,6 +17,11 @@ namespace filter
 namespace flow
 {
 
+VTKM_CONT vtkm::filter::flow::FlowResultType ParticleAdvection::GetResultType() const
+{
+  return vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
+}
+
 }
 }
 } // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/ParticleAdvection.h b/vtkm/filter/flow/ParticleAdvection.h
index 07a2e9f0c..12f5aaf3d 100644
--- a/vtkm/filter/flow/ParticleAdvection.h
+++ b/vtkm/filter/flow/ParticleAdvection.h
@@ -32,10 +32,7 @@ class VTKM_FILTER_FLOW_EXPORT ParticleAdvection
 {
 public:
 private:
-  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override
-  {
-    return vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
-  }
+  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override;
 };
 
 }
diff --git a/vtkm/filter/flow/PathParticle.cxx b/vtkm/filter/flow/PathParticle.cxx
index 04f655f55..f6c0f63a1 100644
--- a/vtkm/filter/flow/PathParticle.cxx
+++ b/vtkm/filter/flow/PathParticle.cxx
@@ -8,13 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/flow/BoundsMap.h>
 #include <vtkm/filter/flow/PathParticle.h>
 
-#include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvector.h>
-
 namespace vtkm
 {
 namespace filter
@@ -22,6 +17,11 @@ namespace filter
 namespace flow
 {
 
+VTKM_CONT vtkm::filter::flow::FlowResultType PathParticle::GetResultType() const
+{
+  return vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
+}
+
 }
 }
 } // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/PathParticle.h b/vtkm/filter/flow/PathParticle.h
index 310ed85dc..8f2c99c37 100644
--- a/vtkm/filter/flow/PathParticle.h
+++ b/vtkm/filter/flow/PathParticle.h
@@ -31,10 +31,7 @@ class VTKM_FILTER_FLOW_EXPORT PathParticle
   : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
 private:
-  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override
-  {
-    return vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE;
-  }
+  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override;
 };
 
 }
diff --git a/vtkm/filter/flow/Pathline.cxx b/vtkm/filter/flow/Pathline.cxx
index c9a5dd132..ada93727f 100644
--- a/vtkm/filter/flow/Pathline.cxx
+++ b/vtkm/filter/flow/Pathline.cxx
@@ -8,13 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/flow/BoundsMap.h>
 #include <vtkm/filter/flow/Pathline.h>
 
-#include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvector.h>
-
 namespace vtkm
 {
 namespace filter
@@ -22,6 +17,11 @@ namespace filter
 namespace flow
 {
 
+VTKM_CONT vtkm::filter::flow::FlowResultType Pathline::GetResultType() const
+{
+  return vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
+}
+
 }
 }
 } // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/Pathline.h b/vtkm/filter/flow/Pathline.h
index a8b94afb3..e92cc5dc0 100644
--- a/vtkm/filter/flow/Pathline.h
+++ b/vtkm/filter/flow/Pathline.h
@@ -31,10 +31,7 @@ class VTKM_FILTER_FLOW_EXPORT Pathline
   : public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
 {
 private:
-  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override
-  {
-    return vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
-  }
+  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override;
 };
 
 }
diff --git a/vtkm/filter/flow/StreamSurface.h b/vtkm/filter/flow/StreamSurface.h
index 3a5cad7be..546fa0a06 100644
--- a/vtkm/filter/flow/StreamSurface.h
+++ b/vtkm/filter/flow/StreamSurface.h
@@ -31,9 +31,6 @@ namespace flow
 class VTKM_FILTER_FLOW_EXPORT StreamSurface
   : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
-public:
-  VTKM_CONT StreamSurface() {}
-
 protected:
   VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
 };
diff --git a/vtkm/filter/flow/Streamline.cxx b/vtkm/filter/flow/Streamline.cxx
index 25c8eabbe..d5789f197 100644
--- a/vtkm/filter/flow/Streamline.cxx
+++ b/vtkm/filter/flow/Streamline.cxx
@@ -8,13 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/flow/BoundsMap.h>
 #include <vtkm/filter/flow/Streamline.h>
 
-#include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvector.h>
-
 namespace vtkm
 {
 namespace filter
@@ -22,6 +17,11 @@ namespace filter
 namespace flow
 {
 
+VTKM_CONT vtkm::filter::flow::FlowResultType Streamline::GetResultType() const
+{
+  return vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
+}
+
 }
 }
 } // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/Streamline.h b/vtkm/filter/flow/Streamline.h
index b5897eed0..d4633f0e0 100644
--- a/vtkm/filter/flow/Streamline.h
+++ b/vtkm/filter/flow/Streamline.h
@@ -30,10 +30,8 @@ namespace flow
 class VTKM_FILTER_FLOW_EXPORT Streamline
   : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
 {
-  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override
-  {
-    return vtkm::filter::flow::FlowResultType::STREAMLINE_TYPE;
-  }
+private:
+  VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override;
 };
 
 }

From aa01c51cb9c6f627ecc5c88de757236f3782ef5c Mon Sep 17 00:00:00 2001
From: Tushar Athawale <athawaletm@ornl.gov>
Date: Fri, 20 May 2022 09:25:30 -0400
Subject: [PATCH 074/104] Addition of GhostCellField API to the Dataset Class

AddGhostCellField function for Dataset class

setGhostCellName function for GhostCellClassify class

setGhostCellName function for GhostCellClassify class

added default ghost cell name in Dataset class

Default ghost cell field name defined in GhostCellClassify class

Default ghost cell field name for GhostCellClassify class

Unit test for ghost field name check

Unit test for ghost field name check updated

Default ghost field name updated

Get function for GhostCellClassify and default ghost name

UnitTestStreamlineFilter updated with AddGhostCellField

AddGhostCellField and GetGlobalGhostCellFieldName propagated

GhostCellClassify constructor now defined in header file

Assigned default values to dataset class members GhostSet and GhostCellName

default values set for GhostSet and GhostCellName in dataset constructor

Constructor removed from dataset class and noexcept for GetGlobalGhostName

added Dataset constructor with noexcept

additions to make sure default move constructor has not changed

GhostSetName field made as a shared pointer since string class is not noexcept

AddGhostCellField funtion added without field name

hasGhostCellField added and unit tests updated for addGhostCellField

hasGhostCellField added and unit tests updated for addGhostCellField

GetGhostCellField and GetGhostCellFieldName functions added to Dataset

GetGhostCellField and GetGhostCellFieldName functions added to Dataset

debugging UnitTestCellLocatorGerneral for CUDA error

UnitTestCellLocatorGeneral testing for error

UnitTestCellLocatorGeneral testing for cude error

UnitTestCellLocatorGeneral error resolution

UnitTestCellLocatorGeneral error resolution

UnitTestCellLocatorGeneral error resolution print statement removed

Minor updates to Dataset class files

GlobalGhostCellFieldName implementation revised to return a static variable

GhostSet member removed, hasGhostCellField, constructor, copystructure updated

GetGhostCellField and GetGhostCellFieldName made cosistent with GetField

Fixes to a few function calls
---
 vtkm/cont/DataSet.cxx                         | 18 +++++
 vtkm/cont/DataSet.h                           | 79 +++++++++++++++++++
 .../entity_extraction/GhostCellRemove.cxx     |  5 +-
 .../testing/UnitTestGhostCellRemove.cxx       |  6 +-
 vtkm/filter/mesh_info/GhostCellClassify.cxx   |  3 +-
 vtkm/filter/mesh_info/GhostCellClassify.h     | 11 +++
 .../testing/UnitTestGhostCellClassify.cxx     | 14 ++--
 .../testing/UnitTestStreamlineFilter.cxx      |  2 +-
 .../testing/UnitTestStreamlineFilterMPI.cxx   |  2 +-
 .../particleadvection/GridEvaluators.h        |  4 +-
 vtkm/worklet/testing/GenerateTestDataSets.h   |  5 +-
 11 files changed, 133 insertions(+), 16 deletions(-)

diff --git a/vtkm/cont/DataSet.cxx b/vtkm/cont/DataSet.cxx
index 8c2e81f12..155bfbe1f 100644
--- a/vtkm/cont/DataSet.cxx
+++ b/vtkm/cont/DataSet.cxx
@@ -14,6 +14,23 @@ namespace vtkm
 {
 namespace cont
 {
+
+VTKM_CONT std::string& GlobalGhostCellFieldName() noexcept
+{
+  static std::string GhostCellName("vtkGhostCells");
+  return GhostCellName;
+}
+
+VTKM_CONT const std::string& GetGlobalGhostCellFieldName() noexcept
+{
+  return GlobalGhostCellFieldName();
+}
+
+VTKM_CONT void SetGlobalGhostCellFieldName(const std::string& name) noexcept
+{
+  GlobalGhostCellFieldName() = name;
+}
+
 void DataSet::Clear()
 {
   this->CoordSystems.clear();
@@ -39,6 +56,7 @@ void DataSet::CopyStructure(const vtkm::cont::DataSet& source)
 {
   this->CoordSystems = source.CoordSystems;
   this->CellSet = source.CellSet;
+  this->GhostCellName = source.GhostCellName;
 }
 
 const vtkm::cont::Field& DataSet::GetField(vtkm::Id index) const
diff --git a/vtkm/cont/DataSet.h b/vtkm/cont/DataSet.h
index 85b7eb9bb..c445549de 100644
--- a/vtkm/cont/DataSet.h
+++ b/vtkm/cont/DataSet.h
@@ -24,9 +24,25 @@ namespace vtkm
 namespace cont
 {
 
+VTKM_CONT_EXPORT VTKM_CONT std::string& GlobalGhostCellFieldName() noexcept;
+
+VTKM_CONT_EXPORT VTKM_CONT const std::string& GetGlobalGhostCellFieldName() noexcept;
+
+VTKM_CONT_EXPORT VTKM_CONT void SetGlobalGhostCellFieldName(const std::string& name) noexcept;
+
 class VTKM_CONT_EXPORT DataSet
 {
 public:
+  DataSet() = default;
+
+  DataSet(vtkm::cont::DataSet&&) = default;
+
+  DataSet(const vtkm::cont::DataSet&) = default;
+
+  vtkm::cont::DataSet& operator=(vtkm::cont::DataSet&&) = default;
+
+  vtkm::cont::DataSet& operator=(const vtkm::cont::DataSet&) = default;
+
   VTKM_CONT void Clear();
 
   /// Get the number of cells contained in this DataSet
@@ -59,6 +75,32 @@ public:
     return (this->GetFieldIndex(name, vtkm::cont::Field::Association::Cells) != -1);
   }
 
+  VTKM_CONT
+  bool HasGhostCellField() const
+  {
+    if (this->GhostCellName)
+    {
+      return this->HasCellField(*this->GhostCellName);
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+  VTKM_CONT
+  const std::string& GetGhostCellFieldName() const
+  {
+    if (this->HasGhostCellField())
+    {
+      return *this->GhostCellName;
+    }
+    else
+    {
+      throw vtkm::cont::ErrorBadValue("No Ghost Cell Field Name");
+    }
+  }
+
   VTKM_CONT
   bool HasPointField(const std::string& name) const
   {
@@ -103,6 +145,23 @@ public:
   }
   //@}
 
+  /// Returns the first cell field that matches the provided name.
+  /// Will throw an exception if no match is found
+  //@{
+  VTKM_CONT
+  const vtkm::cont::Field& GetGhostCellField() const
+  {
+    if (this->HasGhostCellField())
+    {
+      return this->GetCellField(*(this->GhostCellName));
+    }
+    else
+    {
+      throw vtkm::cont::ErrorBadValue("No Ghost Cell Field");
+    }
+  }
+  //@}
+
   /// Returns the first point field that matches the provided name.
   /// Will throw an exception if no match is found
   //@{
@@ -153,6 +212,25 @@ public:
     this->AddField(make_FieldCell(fieldName, field));
   }
 
+  VTKM_CONT
+  void AddGhostCellField(const std::string& fieldName, const vtkm::cont::UnknownArrayHandle& field)
+  {
+    this->GhostCellName.reset(new std::string(fieldName));
+    this->AddField(make_FieldCell(fieldName, field));
+  }
+
+  VTKM_CONT
+  void AddGhostCellField(const vtkm::cont::UnknownArrayHandle& field)
+  {
+    this->AddGhostCellField(GetGlobalGhostCellFieldName(), field);
+  }
+
+  VTKM_CONT
+  void AddGhostCellField(const vtkm::cont::Field& field)
+  {
+    this->AddGhostCellField(field.GetName(), field.GetData());
+  }
+
   template <typename T, typename Storage>
   VTKM_CONT void AddCellField(const std::string& fieldName,
                               const vtkm::cont::ArrayHandle<T, Storage>& field)
@@ -284,6 +362,7 @@ private:
   std::vector<vtkm::cont::CoordinateSystem> CoordSystems;
   std::map<FieldCompare::Key, vtkm::cont::Field, FieldCompare> Fields;
   vtkm::cont::UnknownCellSet CellSet;
+  std::shared_ptr<std::string> GhostCellName;
 };
 
 } // namespace cont
diff --git a/vtkm/filter/entity_extraction/GhostCellRemove.cxx b/vtkm/filter/entity_extraction/GhostCellRemove.cxx
index e6eadd9e3..576d0cf51 100644
--- a/vtkm/filter/entity_extraction/GhostCellRemove.cxx
+++ b/vtkm/filter/entity_extraction/GhostCellRemove.cxx
@@ -308,8 +308,9 @@ namespace entity_extraction
 //-----------------------------------------------------------------------------
 VTKM_CONT GhostCellRemove::GhostCellRemove()
 {
-  this->SetActiveField("vtkmGhostCells");
-  this->SetFieldsToPass("vtkmGhostCells", vtkm::filter::FieldSelection::Mode::Exclude);
+  this->SetActiveField(vtkm::cont::GetGlobalGhostCellFieldName());
+  this->SetFieldsToPass(vtkm::cont::GetGlobalGhostCellFieldName(),
+                        vtkm::filter::FieldSelection::Mode::Exclude);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/vtkm/filter/entity_extraction/testing/UnitTestGhostCellRemove.cxx b/vtkm/filter/entity_extraction/testing/UnitTestGhostCellRemove.cxx
index 0d2f0354e..c05912251 100644
--- a/vtkm/filter/entity_extraction/testing/UnitTestGhostCellRemove.cxx
+++ b/vtkm/filter/entity_extraction/testing/UnitTestGhostCellRemove.cxx
@@ -94,7 +94,7 @@ vtkm::cont::DataSet MakeUniform(vtkm::Id numI,
     ds = vtkm::cont::DataSetBuilderUniform::Create(vtkm::Id3(numI + 1, numJ + 1, numK + 1));
   auto ghosts = StructuredGhostCellArray(numI, numJ, numK, numLayers, addMidGhost);
 
-  ds.AddCellField("vtkmGhostCells", ghosts);
+  ds.AddGhostCellField(ghosts);
 
   return ds;
 }
@@ -128,7 +128,7 @@ vtkm::cont::DataSet MakeRectilinear(vtkm::Id numI,
 
   auto ghosts = StructuredGhostCellArray(numI, numJ, numK, numLayers, addMidGhost);
 
-  ds.AddCellField("vtkmGhostCells", ghosts);
+  ds.AddGhostCellField(ghosts);
 
   return ds;
 }
@@ -205,7 +205,7 @@ vtkm::cont::DataSet MakeExplicit(vtkm::Id numI, vtkm::Id numJ, vtkm::Id numK, in
 
   auto ghosts = StructuredGhostCellArray(numI, numJ, numK, numLayers);
 
-  ds.AddCellField("vtkmGhostCells", ghosts);
+  ds.AddGhostCellField(ghosts);
 
   return ds;
 }
diff --git a/vtkm/filter/mesh_info/GhostCellClassify.cxx b/vtkm/filter/mesh_info/GhostCellClassify.cxx
index 4c930c8c6..366e1a063 100644
--- a/vtkm/filter/mesh_info/GhostCellClassify.cxx
+++ b/vtkm/filter/mesh_info/GhostCellClassify.cxx
@@ -88,6 +88,7 @@ private:
 
 namespace mesh_info
 {
+
 VTKM_CONT vtkm::cont::DataSet GhostCellClassify::DoExecute(const vtkm::cont::DataSet& input)
 {
   const vtkm::cont::UnknownCellSet& cellset = input.GetCellSet();
@@ -142,7 +143,7 @@ VTKM_CONT vtkm::cont::DataSet GhostCellClassify::DoExecute(const vtkm::cont::Dat
   }
 
   auto output = this->CreateResult(input);
-  output.AddCellField("vtkmGhostCells", ghosts);
+  output.AddGhostCellField(this->GhostCellName, ghosts);
   return output;
 }
 }
diff --git a/vtkm/filter/mesh_info/GhostCellClassify.h b/vtkm/filter/mesh_info/GhostCellClassify.h
index c55dffb84..03e1d6952 100644
--- a/vtkm/filter/mesh_info/GhostCellClassify.h
+++ b/vtkm/filter/mesh_info/GhostCellClassify.h
@@ -22,6 +22,17 @@ namespace mesh_info
 class VTKM_FILTER_MESH_INFO_EXPORT GhostCellClassify : public vtkm::filter::NewFilter
 {
   VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
+  std::string GhostCellName;
+
+public:
+  VTKM_CONT GhostCellClassify()
+    : NewFilter()
+    , GhostCellName(vtkm::cont::GetGlobalGhostCellFieldName())
+  {
+  }
+
+  VTKM_CONT void SetGhostCellName(const std::string& fieldName) { this->GhostCellName = fieldName; }
+  VTKM_CONT const std::string& GetGhostCellName() { return this->GhostCellName; }
 };
 } // namespace mesh_info
 class VTKM_DEPRECATED(1.8, "Use vtkm::filter::mesh_info::GhostCellClassify.") GhostCellClassify
diff --git a/vtkm/filter/mesh_info/testing/UnitTestGhostCellClassify.cxx b/vtkm/filter/mesh_info/testing/UnitTestGhostCellClassify.cxx
index 7d76f327e..4390238fe 100644
--- a/vtkm/filter/mesh_info/testing/UnitTestGhostCellClassify.cxx
+++ b/vtkm/filter/mesh_info/testing/UnitTestGhostCellClassify.cxx
@@ -60,7 +60,7 @@ vtkm::cont::DataSet MakeRectilinear(vtkm::Id numI, vtkm::Id numJ, vtkm::Id numK)
   return ds;
 }
 
-void TestStructured()
+void TestStructured(std::string GhostFieldName = "")
 {
   std::cout << "Testing ghost cells for structured datasets." << std::endl;
 
@@ -99,14 +99,18 @@ void TestStructured()
           ds = MakeRectilinear(nx, ny, nz);
 
         vtkm::filter::mesh_info::GhostCellClassify addGhost;
-
+        if (GhostFieldName != "")
+          addGhost.SetGhostCellName(GhostFieldName);
         auto output = addGhost.Execute(ds);
 
         //Validate the output.
-        VTKM_TEST_ASSERT(output.HasCellField("vtkmGhostCells"),
+        std::string correctFieldName = vtkm::cont::GetGlobalGhostCellFieldName();
+        if (GhostFieldName != "")
+          correctFieldName = GhostFieldName;
+        VTKM_TEST_ASSERT(output.HasCellField(correctFieldName),
                          "Ghost cells array not found in output");
         vtkm::Id numCells = output.GetNumberOfCells();
-        auto fieldArray = output.GetCellField("vtkmGhostCells").GetData();
+        auto fieldArray = output.GetCellField(addGhost.GetGhostCellName()).GetData();
         VTKM_TEST_ASSERT(fieldArray.GetNumberOfValues() == numCells,
                          "Wrong number of values in ghost cell array");
 
@@ -134,7 +138,7 @@ void TestStructured()
 
 void TestGhostCellClassify()
 {
-  TestStructured();
+  TestStructured("MyGhostFieldName");
 }
 }
 
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
index 3b6def36f..da1fa9fcc 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx
@@ -192,7 +192,7 @@ void TestAMRStreamline(bool useSL)
             ghosts[idx] = vtkm::CellClassification::Normal;
           idx++;
         }
-    dsOuter.AddCellField("vtkmGhostCells", ghosts);
+    dsOuter.AddGhostCellField(vtkm::cont::make_ArrayHandle(ghosts, vtkm::CopyFlag::On));
 
     //Create a partitioned dataset with 1 inner and 1 outer.
     vtkm::cont::PartitionedDataSet pds;
diff --git a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
index 4af041bff..b83a6a4e5 100644
--- a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
+++ b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
@@ -111,7 +111,7 @@ void TestAMRStreamline(FilterType fType, bool useThreaded)
             ghosts[idx] = vtkm::CellClassification::Normal;
           idx++;
         }
-    dsOuter.AddCellField("vtkmGhostCells", ghosts);
+    dsOuter.AddGhostCellField(vtkm::cont::make_ArrayHandle(ghosts, vtkm::CopyFlag::On));
 
     //Create a partitioned dataset with 1 inner and 1 outer.
     vtkm::cont::PartitionedDataSet pds;
diff --git a/vtkm/worklet/particleadvection/GridEvaluators.h b/vtkm/worklet/particleadvection/GridEvaluators.h
index 70fe9b398..f6fcaeefc 100644
--- a/vtkm/worklet/particleadvection/GridEvaluators.h
+++ b/vtkm/worklet/particleadvection/GridEvaluators.h
@@ -184,9 +184,9 @@ public:
   {
     this->InitializeLocator(dataSet.GetCoordinateSystem(), dataSet.GetCellSet());
 
-    if (dataSet.HasCellField("vtkmGhostCells"))
+    if (dataSet.HasGhostCellField())
     {
-      auto arr = dataSet.GetCellField("vtkmGhostCells").GetData();
+      auto arr = dataSet.GetGhostCellField().GetData();
       vtkm::cont::ArrayCopyShallowIfPossible(arr, this->GhostCellArray);
     }
   }
diff --git a/vtkm/worklet/testing/GenerateTestDataSets.h b/vtkm/worklet/testing/GenerateTestDataSets.h
index 2abddcdfa..cbf13d69b 100644
--- a/vtkm/worklet/testing/GenerateTestDataSets.h
+++ b/vtkm/worklet/testing/GenerateTestDataSets.h
@@ -192,7 +192,10 @@ inline vtkm::cont::DataSet CreateExplicitFromStructuredDataSet(const vtkm::Bound
   }
 
   if (addGhost)
-    output.AddField(input.GetField("vtkmGhostCells"));
+  {
+    output.AddGhostCellField(input.GetGhostCellField());
+  }
+
   return output;
 }
 

From f15cc055b9a476731c1b91b59510926647a84d8f Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 28 Jul 2022 16:52:24 -0400
Subject: [PATCH 075/104] Remove device code from headers.

---
 vtkm/filter/flow/StreamSurface.cxx                            | 1 +
 vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx | 1 +
 vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx | 1 +
 vtkm/filter/flow/worklet/Particles.h                          | 1 -
 4 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/vtkm/filter/flow/StreamSurface.cxx b/vtkm/filter/flow/StreamSurface.cxx
index 06b09849a..40fe6e416 100644
--- a/vtkm/filter/flow/StreamSurface.cxx
+++ b/vtkm/filter/flow/StreamSurface.cxx
@@ -10,6 +10,7 @@
 
 #include <vtkm/filter/flow/StreamSurface.h>
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/flow/worklet/Field.h>
diff --git a/vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx b/vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx
index 5d5f5f023..884449ed5 100644
--- a/vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx
+++ b/vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx
@@ -9,6 +9,7 @@
 //============================================================================
 
 #include <typeinfo>
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ArrayHandle.h>
 #include <vtkm/cont/DataSet.h>
diff --git a/vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx b/vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx
index a3ad7b1e1..9cb4ddbe3 100644
--- a/vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx
+++ b/vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx
@@ -10,6 +10,7 @@
 
 #include <typeinfo>
 #include <vtkm/VecVariable.h>
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ArrayHandle.h>
 #include <vtkm/cont/DataSet.h>
diff --git a/vtkm/filter/flow/worklet/Particles.h b/vtkm/filter/flow/worklet/Particles.h
index 95e77cc38..d0087d79f 100644
--- a/vtkm/filter/flow/worklet/Particles.h
+++ b/vtkm/filter/flow/worklet/Particles.h
@@ -11,7 +11,6 @@
 #ifndef vtk_m_filter_flow_worklet_Particles_h
 #define vtk_m_filter_flow_worklet_Particles_h
 
-#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ExecutionObjectBase.h>
 #include <vtkm/filter/flow/worklet/IntegratorStatus.h>
 

From d23ebb324bbf8560c8f19ece7874051ecdc55373 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 28 Jul 2022 21:42:43 -0400
Subject: [PATCH 076/104] Cuda fixes: device in headers.

---
 vtkm/filter/flow/testing/UnitTestStreamSurfaceWorklet.cxx | 2 +-
 vtkm/filter/flow/worklet/StreamSurface.h                  | 4 ----
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/vtkm/filter/flow/testing/UnitTestStreamSurfaceWorklet.cxx b/vtkm/filter/flow/testing/UnitTestStreamSurfaceWorklet.cxx
index 07848da0c..79b70992a 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamSurfaceWorklet.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamSurfaceWorklet.cxx
@@ -8,11 +8,11 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/DataSetBuilderExplicit.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/flow/worklet/StreamSurface.h>
 #include <vtkm/io/VTKDataSetWriter.h>
-#include <vtkm/worklet/DispatcherMapField.h>
 
 namespace
 {
diff --git a/vtkm/filter/flow/worklet/StreamSurface.h b/vtkm/filter/flow/worklet/StreamSurface.h
index 33389bba7..6108abd0e 100644
--- a/vtkm/filter/flow/worklet/StreamSurface.h
+++ b/vtkm/filter/flow/worklet/StreamSurface.h
@@ -10,12 +10,8 @@
 #ifndef vtk_m_filter_flow_worklet_streamsurface_h
 #define vtk_m_filter_flow_worklet_streamsurface_h
 
-#include <typeinfo>
-#include <vtkm/VectorAnalysis.h>
-#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayHandleView.h>
 #include <vtkm/cont/CellSetExplicit.h>
-#include <vtkm/cont/DataSet.h>
 #include <vtkm/worklet/DispatcherMapTopology.h>
 #include <vtkm/worklet/WorkletMapField.h>
 #include <vtkm/worklet/WorkletMapTopology.h>

From c1c80e7ef84de83bc26bab9532f15095f48c1e2f Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Thu, 28 Jul 2022 21:48:50 -0400
Subject: [PATCH 077/104] Moe cuda device in header fixes.

---
 vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx   | 1 +
 vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx | 1 +
 vtkm/filter/flow/worklet/GridEvaluators.h                    | 4 ----
 vtkm/filter/flow/worklet/ParticleAdvection.h                 | 1 -
 vtkm/filter/testing/UnitTestLagrangianStructuresFilter.cxx   | 1 +
 5 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
index c8c388973..6a48397a3 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
@@ -10,6 +10,7 @@
 
 #include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
 #include <vtkm/filter/flow/ParticleAdvector.h>
 
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
index 4ab82af9b..b3ecf89e5 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
@@ -10,6 +10,7 @@
 
 #include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
 #include <vtkm/filter/flow/ParticleAdvector.h>
 
diff --git a/vtkm/filter/flow/worklet/GridEvaluators.h b/vtkm/filter/flow/worklet/GridEvaluators.h
index 7e1dfa88f..85a9730cf 100644
--- a/vtkm/filter/flow/worklet/GridEvaluators.h
+++ b/vtkm/filter/flow/worklet/GridEvaluators.h
@@ -11,11 +11,7 @@
 #ifndef vtk_m_filter_flow_worklet_GridEvaluators_h
 #define vtk_m_filter_flow_worklet_GridEvaluators_h
 
-#include <vtkm/Bitset.h>
 #include <vtkm/CellClassification.h>
-#include <vtkm/Types.h>
-#include <vtkm/VectorAnalysis.h>
-#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ArrayHandle.h>
 #include <vtkm/cont/CellLocatorGeneral.h>
 #include <vtkm/cont/CellLocatorRectilinearGrid.h>
diff --git a/vtkm/filter/flow/worklet/ParticleAdvection.h b/vtkm/filter/flow/worklet/ParticleAdvection.h
index 60815d786..fa28c9ae6 100644
--- a/vtkm/filter/flow/worklet/ParticleAdvection.h
+++ b/vtkm/filter/flow/worklet/ParticleAdvection.h
@@ -11,7 +11,6 @@
 #ifndef vtk_m_filter_flow_worklet_ParticleAdvection_h
 #define vtk_m_filter_flow_worklet_ParticleAdvection_h
 
-#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/Invoker.h>
 #include <vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h>
 
diff --git a/vtkm/filter/testing/UnitTestLagrangianStructuresFilter.cxx b/vtkm/filter/testing/UnitTestLagrangianStructuresFilter.cxx
index e2ecb2686..cee1b803f 100644
--- a/vtkm/filter/testing/UnitTestLagrangianStructuresFilter.cxx
+++ b/vtkm/filter/testing/UnitTestLagrangianStructuresFilter.cxx
@@ -9,6 +9,7 @@
 //============================================================================
 
 #include <iostream>
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/LagrangianStructures.h>

From 5528a79aa27aab98802131c3ca9b97447230450a Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 29 Jul 2022 08:37:03 -0400
Subject: [PATCH 078/104] cuda fixes. DEVICE_SOURCES is needed!

---
 vtkm/filter/flow/testing/CMakeLists.txt               |  4 ++--
 vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx | 11 -----------
 2 files changed, 2 insertions(+), 13 deletions(-)

diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index 63da34ce6..4188325c3 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -21,7 +21,7 @@ set(libraries
   )
 
 vtkm_unit_tests(
-  SOURCES ${unit_tests}
+  DEVICE_SOURCES ${unit_tests}
   LIBRARIES ${libraries} vtkm_filter vtkm_io
   USE_VTKM_JOB_POOL
 )
@@ -34,7 +34,7 @@ if (VTKm_ENABLE_MPI)
     UnitTestStreamlineFilterMPI.cxx
   )
   vtkm_unit_tests(
-    MPI SOURCES ${mpi_unit_tests}
+    MPI DEVICE_SOURCES ${mpi_unit_tests}
     LIBRARIES vtkm_filter vtkm_source vtkm_io
     ALL_BACKENDS
     USE_VTKM_JOB_POOL
diff --git a/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
index 0e3c56483..94adad56e 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
@@ -86,12 +86,6 @@ void TestStreamline()
   }
 }
 
-void DumpDS(const vtkm::cont::DataSet& ds, const std::string& fname)
-{
-  vtkm::io::VTKDataSetWriter wrt(fname);
-  wrt.WriteDataSet(ds);
-}
-
 void TestPathline()
 {
   const vtkm::Id3 dims(5, 5, 5);
@@ -140,11 +134,6 @@ void TestPathline()
         filt.SetNextDataSet(ds2);
         output = filt.Execute(ds1);
         numExpectedPoints = 33;
-        /*
-        DumpDS(output, "pathline.vtk");
-        DumpDS(ds1, "ds1.vtk");
-        DumpDS(ds2, "ds2.vtk");
-        */
       }
       else
       {

From c41c3b7a575b8b14ac979993662f43aa90626512 Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <morelandkd@ornl.gov>
Date: Fri, 29 Jul 2022 06:50:34 -0600
Subject: [PATCH 079/104] Fix Variant::CastAndCall SFINAE for auto return type
 functors

`Variant::CastAndCall` was using the C++11 style for an `auto` return
where the return type was specified with a `->` that got the `decltype`
of the return value of the functor. This was used as part of SFINAE to
pick whether you needed the const or non-const version.

However, this was causing a problem with functions that got an error
when deducing the return type for that. This was particularly
problematic for lambda functions. For example, say you have the
following simple `CastAndCall`.

```cpp
variant.CastAndCall([](auto& x){ ++x; });
```

To determine the return type of the lambda (`void`), the function has to
be compiled. But when it is compiled with a const type, which happens
when deducing the const version of `CastAndCall`, you get a compile
error. This error is not considered a substitution error (hence SFINAE),
it is an outright error. So you get a compile error just trying to
deduce the type.

The solution was to move to the C++14 version of an auto return type. In
this case, the return type is no longer important for SFINAE and is
delayed until the function is actually compiled with the specific
template parameters. This would be a problem if the const version of
`CastAndCall` was used when the non-const version was needed. But now
both versions will pass SFINAE and thus the non-const version will be
chosen as long as the `Variant` object itself is non-const. If the
`Variant` object itself is const, then that is in fact a legitimate
error, so a compile error is OK.

One thing I find wierd is that `CastAndCall` still has a `noexcept`
expression that will likewise cause a compile error in this case.
However, it is still working. I _think_ the difference is that
`noexcept` is not used to determine template substitution/overloaded, so
is therefore ignored until the function is actually compiled.
---
 vtkm/exec/internal/testing/UnitTestVariant.cxx | 2 ++
 vtkm/internal/VariantImpl.h                    | 2 --
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/vtkm/exec/internal/testing/UnitTestVariant.cxx b/vtkm/exec/internal/testing/UnitTestVariant.cxx
index 25dcfd32a..64834a369 100644
--- a/vtkm/exec/internal/testing/UnitTestVariant.cxx
+++ b/vtkm/exec/internal/testing/UnitTestVariant.cxx
@@ -444,6 +444,8 @@ void TestCastAndCall()
 
   variant1.CastAndCall(TestFunctorModify{}, 1);
   VTKM_TEST_ASSERT(variant1.Get<1>().Value == 2, "Variant object not updated.");
+
+  variant1.CastAndCall([](auto& object) { ++object.Value; });
 }
 
 void TestCopyInvalid()
diff --git a/vtkm/internal/VariantImpl.h b/vtkm/internal/VariantImpl.h
index 5533477cc..7e586b6de 100644
--- a/vtkm/internal/VariantImpl.h
+++ b/vtkm/internal/VariantImpl.h
@@ -510,7 +510,6 @@ public:
   template <typename Functor, typename... Args>
   VTK_M_DEVICE auto CastAndCall(Functor&& f, Args&&... args) const
     noexcept(noexcept(f(std::declval<const TypeAt<0>&>(), args...)))
-      -> decltype(f(std::declval<const TypeAt<0>&>(), args...))
   {
     VTKM_ASSERT(this->IsValid());
     return detail::VariantCastAndCallImpl<sizeof...(Ts)>(
@@ -521,7 +520,6 @@ public:
   VTK_M_DEVICE auto CastAndCall(Functor&& f,
                                 Args&&... args) noexcept(noexcept(f(std::declval<TypeAt<0>&>(),
                                                                     args...)))
-    -> decltype(f(std::declval<TypeAt<0>&>(), args...))
   {
     VTKM_ASSERT(this->IsValid());
     return detail::VariantCastAndCallImpl<sizeof...(Ts)>(

From 92ac6ae71b7df893a23f0866007320d72165aee9 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 29 Jul 2022 10:01:39 -0400
Subject: [PATCH 080/104] Move non-user-facing code into internal.

---
 vtkm/filter/flow/CMakeLists.txt               | 14 ++-----
 .../NewFilterParticleAdvectionSteadyState.cxx | 19 +++++-----
 .../NewFilterParticleAdvectionSteadyState.h   | 12 +++---
 ...ewFilterParticleAdvectionUnsteadyState.cxx | 19 +++++-----
 .../NewFilterParticleAdvectionUnsteadyState.h |  8 ++--
 vtkm/filter/flow/ParticleAdvection.cxx        |  1 +
 vtkm/filter/flow/PathParticle.cxx             |  1 +
 vtkm/filter/flow/Pathline.cxx                 |  1 +
 vtkm/filter/flow/StreamSurface.cxx            |  3 +-
 vtkm/filter/flow/Streamline.cxx               |  1 +
 .../flow/{ => internal}/AdvectAlgorithm.h     | 24 ++++++------
 .../{ => internal}/AdvectAlgorithmThreaded.h  | 22 ++++++-----
 vtkm/filter/flow/{ => internal}/BoundsMap.h   | 16 +++++---
 vtkm/filter/flow/internal/CMakeLists.txt      | 26 +++++++++++++
 .../flow/{ => internal}/DataSetIntegrator.h   | 15 +++++---
 .../DataSetIntegratorSteadyState.h            | 19 +++++++---
 .../DataSetIntegratorUnsteadyState.h          | 21 +++++++----
 vtkm/filter/flow/{ => internal}/Messenger.cxx |  8 +++-
 vtkm/filter/flow/{ => internal}/Messenger.h   | 12 +++---
 .../flow/{ => internal}/ParticleAdvector.h    | 35 ++++++++++--------
 .../flow/{ => internal}/ParticleMessenger.h   | 37 +++++++++++--------
 vtkm/filter/flow/testing/CMakeLists.txt       |  9 +++--
 .../testing/UnitTestParticleMessengerMPI.cxx  | 10 ++---
 .../testing/UnitTestStreamSurfaceFilter.cxx   |  1 +
 .../flow/testing/UnitTestStreamlineFilter.cxx |  1 +
 .../testing/UnitTestStreamlineFilterMPI.cxx   |  1 +
 vtkm/filter/testing/RenderTestStreamline.cxx  |  1 +
 27 files changed, 204 insertions(+), 133 deletions(-)
 rename vtkm/filter/flow/{ => internal}/AdvectAlgorithm.h (91%)
 rename vtkm/filter/flow/{ => internal}/AdvectAlgorithmThreaded.h (88%)
 rename vtkm/filter/flow/{ => internal}/BoundsMap.h (96%)
 create mode 100644 vtkm/filter/flow/internal/CMakeLists.txt
 rename vtkm/filter/flow/{ => internal}/DataSetIntegrator.h (96%)
 rename vtkm/filter/flow/{ => internal}/DataSetIntegratorSteadyState.h (91%)
 rename vtkm/filter/flow/{ => internal}/DataSetIntegratorUnsteadyState.h (92%)
 rename vtkm/filter/flow/{ => internal}/Messenger.cxx (98%)
 rename vtkm/filter/flow/{ => internal}/Messenger.h (93%)
 rename vtkm/filter/flow/{ => internal}/ParticleAdvector.h (78%)
 rename vtkm/filter/flow/{ => internal}/ParticleMessenger.h (93%)

diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index d2b8f65d2..bb0f8f548 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -8,19 +8,10 @@
 ##  PURPOSE.  See the above copyright notice for more information.
 ##============================================================================
 set(flow_headers
-  AdvectAlgorithm.h
-  AdvectAlgorithmThreaded.h
-  BoundsMap.h
-  DataSetIntegrator.h
-  DataSetIntegratorSteadyState.h
-  DataSetIntegratorUnsteadyState.h
-  Messenger.h
+  FlowTypes.h
   NewFilterParticleAdvection.h
   NewFilterParticleAdvectionSteadyState.h
   NewFilterParticleAdvectionUnsteadyState.h
-  FlowTypes.h
-  ParticleAdvector.h
-  ParticleMessenger.h
   ParticleAdvection.h
   Pathline.h
   PathParticle.h
@@ -29,7 +20,7 @@ set(flow_headers
   )
 
 set(flow_sources
-  Messenger.cxx
+  internal/Messenger.cxx
   NewFilterParticleAdvectionSteadyState.cxx
   NewFilterParticleAdvectionUnsteadyState.cxx
   ParticleAdvection.cxx
@@ -52,6 +43,7 @@ if (VTKm_ENABLE_MPI)
   target_link_libraries(vtkm_filter_flow PUBLIC MPI::MPI_CXX)
 endif()
 
+add_subdirectory(internal)
 add_subdirectory(worklet)
 
 #-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
index 6a48397a3..a9a9f5799 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
@@ -8,11 +8,10 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
-
 #include <vtkm/cont/ArrayCopy.h>
-#include <vtkm/filter/flow/DataSetIntegratorSteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvector.h>
+#include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
+#include <vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h>
+#include <vtkm/filter/flow/internal/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -21,13 +20,13 @@ namespace filter
 namespace flow
 {
 
-VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorSteadyState>
+VTKM_CONT std::vector<vtkm::filter::flow::internal::DataSetIntegratorSteadyState>
 NewFilterParticleAdvectionSteadyState::CreateDataSetIntegrators(
   const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::flow::BoundsMap& boundsMap,
+  const vtkm::filter::flow::internal::BoundsMap& boundsMap,
   const vtkm::filter::flow::FlowResultType& resultType) const
 {
-  using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
+  using DSIType = vtkm::filter::flow::internal::DataSetIntegratorSteadyState;
 
   std::string activeField = this->GetActiveFieldName();
 
@@ -48,13 +47,13 @@ NewFilterParticleAdvectionSteadyState::CreateDataSetIntegrators(
 VTKM_CONT vtkm::cont::PartitionedDataSet NewFilterParticleAdvectionSteadyState::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  using DSIType = vtkm::filter::flow::DataSetIntegratorSteadyState;
+  using DSIType = vtkm::filter::flow::internal::DataSetIntegratorSteadyState;
   this->ValidateOptions();
 
-  vtkm::filter::flow::BoundsMap boundsMap(input);
+  vtkm::filter::flow::internal::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->GetResultType());
 
-  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
+  vtkm::filter::flow::internal::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->GetResultType());
 
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index c5839b042..de9a67f03 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -11,9 +11,11 @@
 #ifndef vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
 #define vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
 
-#include <vtkm/filter/flow/BoundsMap.h>
 #include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
+#include <vtkm/filter/flow/internal/BoundsMap.h>
+#include <vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h>
+
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
@@ -30,10 +32,10 @@ class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionSteadyState
   : public NewFilterParticleAdvection
 {
 protected:
-  VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorSteadyState> CreateDataSetIntegrators(
-    const vtkm::cont::PartitionedDataSet& input,
-    const vtkm::filter::flow::BoundsMap& boundsMap,
-    const vtkm::filter::flow::FlowResultType& resultType) const;
+  VTKM_CONT std::vector<vtkm::filter::flow::internal::DataSetIntegratorSteadyState>
+  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
+                           const vtkm::filter::flow::internal::BoundsMap& boundsMap,
+                           const vtkm::filter::flow::FlowResultType& resultType) const;
 
 private:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
index b3ecf89e5..98b43249f 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
@@ -8,11 +8,10 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
-
 #include <vtkm/cont/ArrayCopy.h>
-#include <vtkm/filter/flow/DataSetIntegratorUnsteadyState.h>
-#include <vtkm/filter/flow/ParticleAdvector.h>
+#include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
+#include <vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h>
+#include <vtkm/filter/flow/internal/ParticleAdvector.h>
 
 namespace vtkm
 {
@@ -21,13 +20,13 @@ namespace filter
 namespace flow
 {
 
-VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorUnsteadyState>
+VTKM_CONT std::vector<vtkm::filter::flow::internal::DataSetIntegratorUnsteadyState>
 NewFilterParticleAdvectionUnsteadyState::CreateDataSetIntegrators(
   const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::flow::BoundsMap& boundsMap,
+  const vtkm::filter::flow::internal::BoundsMap& boundsMap,
   const vtkm::filter::flow::FlowResultType& resultType) const
 {
-  using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
+  using DSIType = vtkm::filter::flow::internal::DataSetIntegratorUnsteadyState;
 
   std::string activeField = this->GetActiveFieldName();
 
@@ -59,13 +58,13 @@ VTKM_CONT vtkm::cont::PartitionedDataSet
 NewFilterParticleAdvectionUnsteadyState::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  using DSIType = vtkm::filter::flow::DataSetIntegratorUnsteadyState;
+  using DSIType = vtkm::filter::flow::internal::DataSetIntegratorUnsteadyState;
   this->ValidateOptions();
 
-  vtkm::filter::flow::BoundsMap boundsMap(input);
+  vtkm::filter::flow::internal::BoundsMap boundsMap(input);
   auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->GetResultType());
 
-  vtkm::filter::flow::ParticleAdvector<DSIType> pav(
+  vtkm::filter::flow::internal::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->GetResultType());
 
   return pav.Execute(this->NumberOfSteps, this->StepSize, this->Seeds);
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index 6c963ed0d..c404d86f4 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -11,8 +11,10 @@
 #ifndef vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
 #define vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
 
-#include <vtkm/filter/flow/BoundsMap.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
+#include <vtkm/filter/flow/internal/BoundsMap.h>
+#include <vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h>
+
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
@@ -45,9 +47,9 @@ protected:
       throw vtkm::cont::ErrorFilterExecution("PreviousTime must be less than NextTime");
   }
 
-  VTKM_CONT std::vector<vtkm::filter::flow::DataSetIntegratorUnsteadyState>
+  VTKM_CONT std::vector<vtkm::filter::flow::internal::DataSetIntegratorUnsteadyState>
   CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
-                           const vtkm::filter::flow::BoundsMap& boundsMap,
+                           const vtkm::filter::flow::internal::BoundsMap& boundsMap,
                            const vtkm::filter::flow::FlowResultType& resultType) const;
 
 private:
diff --git a/vtkm/filter/flow/ParticleAdvection.cxx b/vtkm/filter/flow/ParticleAdvection.cxx
index d833b2289..b4defef86 100644
--- a/vtkm/filter/flow/ParticleAdvection.cxx
+++ b/vtkm/filter/flow/ParticleAdvection.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/ParticleAdvection.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/PathParticle.cxx b/vtkm/filter/flow/PathParticle.cxx
index f6c0f63a1..03e091b4e 100644
--- a/vtkm/filter/flow/PathParticle.cxx
+++ b/vtkm/filter/flow/PathParticle.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/PathParticle.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/Pathline.cxx b/vtkm/filter/flow/Pathline.cxx
index ada93727f..4fe512182 100644
--- a/vtkm/filter/flow/Pathline.cxx
+++ b/vtkm/filter/flow/Pathline.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/Pathline.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/StreamSurface.cxx b/vtkm/filter/flow/StreamSurface.cxx
index 40fe6e416..7a5c52039 100644
--- a/vtkm/filter/flow/StreamSurface.cxx
+++ b/vtkm/filter/flow/StreamSurface.cxx
@@ -8,11 +8,10 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/filter/flow/StreamSurface.h>
-
 #include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
+#include <vtkm/filter/flow/StreamSurface.h>
 #include <vtkm/filter/flow/worklet/Field.h>
 #include <vtkm/filter/flow/worklet/GridEvaluators.h>
 #include <vtkm/filter/flow/worklet/ParticleAdvection.h>
diff --git a/vtkm/filter/flow/Streamline.cxx b/vtkm/filter/flow/Streamline.cxx
index d5789f197..0eeeec8e4 100644
--- a/vtkm/filter/flow/Streamline.cxx
+++ b/vtkm/filter/flow/Streamline.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/Streamline.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/AdvectAlgorithm.h b/vtkm/filter/flow/internal/AdvectAlgorithm.h
similarity index 91%
rename from vtkm/filter/flow/AdvectAlgorithm.h
rename to vtkm/filter/flow/internal/AdvectAlgorithm.h
index 7897abb12..bce021733 100644
--- a/vtkm/filter/flow/AdvectAlgorithm.h
+++ b/vtkm/filter/flow/internal/AdvectAlgorithm.h
@@ -8,14 +8,13 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_flow_AdvectAlgorithm_h
-#define vtk_m_filter_flow_AdvectAlgorithm_h
+#ifndef vtk_m_filter_flow_internal_AdvectAlgorithm_h
+#define vtk_m_filter_flow_internal_AdvectAlgorithm_h
 
 #include <vtkm/cont/PartitionedDataSet.h>
-#include <vtkm/filter/flow/BoundsMap.h>
-#include <vtkm/filter/flow/DataSetIntegrator.h>
-#include <vtkm/filter/flow/ParticleMessenger.h>
-
+#include <vtkm/filter/flow/internal/BoundsMap.h>
+#include <vtkm/filter/flow/internal/DataSetIntegrator.h>
+#include <vtkm/filter/flow/internal/ParticleMessenger.h>
 
 namespace vtkm
 {
@@ -23,12 +22,14 @@ namespace filter
 {
 namespace flow
 {
+namespace internal
+{
 
 template <typename DSIType, template <typename> class ResultType, typename ParticleType>
 class AdvectAlgorithm
 {
 public:
-  AdvectAlgorithm(const vtkm::filter::flow::BoundsMap& bm, std::vector<DSIType>& blocks)
+  AdvectAlgorithm(const vtkm::filter::flow::internal::BoundsMap& bm, std::vector<DSIType>& blocks)
     : Blocks(blocks)
     , BoundsMap(bm)
     , NumRanks(this->Comm.size())
@@ -89,7 +90,7 @@ public:
   //Advect all the particles.
   virtual void Go()
   {
-    vtkm::filter::flow::ParticleMessenger<ParticleType> messenger(
+    vtkm::filter::flow::internal::ParticleMessenger<ParticleType> messenger(
       this->Comm, this->BoundsMap, 1, 128);
 
     vtkm::Id nLocal = static_cast<vtkm::Id>(this->Active.size() + this->Inactive.size());
@@ -186,7 +187,7 @@ public:
     return !particles.empty();
   }
 
-  virtual void Communicate(vtkm::filter::flow::ParticleMessenger<ParticleType>& messenger,
+  virtual void Communicate(vtkm::filter::flow::internal::ParticleMessenger<ParticleType>& messenger,
                            vtkm::Id numLocalTerminations,
                            vtkm::Id& numTermMessages)
   {
@@ -263,7 +264,7 @@ public:
   //Member data
   std::vector<ParticleType> Active;
   std::vector<DSIType> Blocks;
-  vtkm::filter::flow::BoundsMap BoundsMap;
+  vtkm::filter::flow::internal::BoundsMap BoundsMap;
   vtkmdiy::mpi::communicator Comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
   std::vector<ParticleType> Inactive;
   vtkm::Id NumberOfSteps;
@@ -278,5 +279,6 @@ public:
 }
 }
 }
+} //vtkm::filter::flow::internal
 
-#endif //vtk_m_filter_flow_AdvectAlgorithm_h
+#endif //vtk_m_filter_flow_internal_AdvectAlgorithm_h
diff --git a/vtkm/filter/flow/AdvectAlgorithmThreaded.h b/vtkm/filter/flow/internal/AdvectAlgorithmThreaded.h
similarity index 88%
rename from vtkm/filter/flow/AdvectAlgorithmThreaded.h
rename to vtkm/filter/flow/internal/AdvectAlgorithmThreaded.h
index f72909010..3417defaf 100644
--- a/vtkm/filter/flow/AdvectAlgorithmThreaded.h
+++ b/vtkm/filter/flow/internal/AdvectAlgorithmThreaded.h
@@ -8,14 +8,14 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_flow_AdvectAlgorithmThreaded_h
-#define vtk_m_filter_flow_AdvectAlgorithmThreaded_h
+#ifndef vtk_m_filter_flow_internal_AdvectAlgorithmThreaded_h
+#define vtk_m_filter_flow_internal_AdvectAlgorithmThreaded_h
 
 #include <vtkm/cont/PartitionedDataSet.h>
-#include <vtkm/filter/flow/AdvectAlgorithm.h>
-#include <vtkm/filter/flow/BoundsMap.h>
-#include <vtkm/filter/flow/DataSetIntegrator.h>
-#include <vtkm/filter/flow/ParticleMessenger.h>
+#include <vtkm/filter/flow/internal/AdvectAlgorithm.h>
+#include <vtkm/filter/flow/internal/BoundsMap.h>
+#include <vtkm/filter/flow/internal/DataSetIntegrator.h>
+#include <vtkm/filter/flow/internal/ParticleMessenger.h>
 
 #include <thread>
 
@@ -25,12 +25,15 @@ namespace filter
 {
 namespace flow
 {
+namespace internal
+{
 
 template <typename DSIType, template <typename> class ResultType, typename ParticleType>
 class AdvectAlgorithmThreaded : public AdvectAlgorithm<DSIType, ResultType, ParticleType>
 {
 public:
-  AdvectAlgorithmThreaded(const vtkm::filter::flow::BoundsMap& bm, std::vector<DSIType>& blocks)
+  AdvectAlgorithmThreaded(const vtkm::filter::flow::internal::BoundsMap& bm,
+                          std::vector<DSIType>& blocks)
     : AdvectAlgorithm<DSIType, ResultType, ParticleType>(bm, blocks)
     , Done(false)
     , WorkerActivate(false)
@@ -130,7 +133,7 @@ protected:
 
   void Manage()
   {
-    vtkm::filter::flow::ParticleMessenger<ParticleType> messenger(
+    vtkm::filter::flow::internal::ParticleMessenger<ParticleType> messenger(
       this->Comm, this->BoundsMap, 1, 128);
 
     while (this->TotalNumTerminatedParticles < this->TotalNumParticles)
@@ -188,5 +191,6 @@ protected:
 }
 }
 }
+} //vtkm::filter::flow::internal
 
-#endif //vtk_m_filter_flow_AdvectAlgorithmThreaded_h
+#endif //vtk_m_filter_flow_internal_AdvectAlgorithmThreaded_h
diff --git a/vtkm/filter/flow/BoundsMap.h b/vtkm/filter/flow/internal/BoundsMap.h
similarity index 96%
rename from vtkm/filter/flow/BoundsMap.h
rename to vtkm/filter/flow/internal/BoundsMap.h
index f02bb678b..70368026c 100644
--- a/vtkm/filter/flow/BoundsMap.h
+++ b/vtkm/filter/flow/internal/BoundsMap.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_flow_BoundsMap_h
-#define vtk_m_filter_flow_BoundsMap_h
+#ifndef vtk_m_filter_flow_internal_BoundsMap_h
+#define vtk_m_filter_flow_internal_BoundsMap_h
 
 #include <vtkm/Bounds.h>
 #include <vtkm/cont/AssignerPartitionedDataSet.h>
@@ -33,6 +33,8 @@ namespace filter
 {
 namespace flow
 {
+namespace internal
+{
 
 class VTKM_ALWAYS_EXPORT BoundsMap
 {
@@ -174,8 +176,10 @@ private:
   std::vector<vtkm::Bounds> BlockBounds;
   vtkm::Bounds GlobalBounds;
 };
-}
-}
-} // namespace vtkm::filter::flow
 
-#endif //vtk_m_filter_flow_BoundsMap_h
+}
+}
+}
+} // namespace vtkm::filter::flow::internal
+
+#endif //vtk_m_filter_flow_internal_BoundsMap_h
diff --git a/vtkm/filter/flow/internal/CMakeLists.txt b/vtkm/filter/flow/internal/CMakeLists.txt
new file mode 100644
index 000000000..0f192e284
--- /dev/null
+++ b/vtkm/filter/flow/internal/CMakeLists.txt
@@ -0,0 +1,26 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##============================================================================
+
+set(headers
+  AdvectAlgorithm.h
+  AdvectAlgorithmThreaded.h
+  BoundsMap.h
+  DataSetIntegrator.h
+  DataSetIntegratorSteadyState.h
+  DataSetIntegratorUnsteadyState.h
+  Messenger.h
+  ParticleAdvector.h
+  ParticleMessenger.h
+  )
+
+# Note: The C++ source files are added to the flow library
+# in the CMakeLists.txt in the parent directory.
+
+vtkm_declare_headers(${headers})
diff --git a/vtkm/filter/flow/DataSetIntegrator.h b/vtkm/filter/flow/internal/DataSetIntegrator.h
similarity index 96%
rename from vtkm/filter/flow/DataSetIntegrator.h
rename to vtkm/filter/flow/internal/DataSetIntegrator.h
index c7bc538de..2870d5b5e 100644
--- a/vtkm/filter/flow/DataSetIntegrator.h
+++ b/vtkm/filter/flow/internal/DataSetIntegrator.h
@@ -8,14 +8,14 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_flow_DataSetIntegrator_h
-#define vtk_m_filter_flow_DataSetIntegrator_h
+#ifndef vtk_m_filter_flow_internal_DataSetIntegrator_h
+#define vtk_m_filter_flow_internal_DataSetIntegrator_h
 
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/cont/ParticleArrayCopy.h>
-#include <vtkm/filter/flow/BoundsMap.h>
 #include <vtkm/filter/flow/FlowTypes.h>
+#include <vtkm/filter/flow/internal/BoundsMap.h>
 #include <vtkm/filter/flow/worklet/EulerIntegrator.h>
 #include <vtkm/filter/flow/worklet/IntegratorStatus.h>
 #include <vtkm/filter/flow/worklet/ParticleAdvection.h>
@@ -30,13 +30,15 @@ namespace filter
 {
 namespace flow
 {
+namespace internal
+{
 
 template <typename ParticleType>
 class DSIHelperInfo
 {
 public:
   DSIHelperInfo(const std::vector<ParticleType>& v,
-                const vtkm::filter::flow::BoundsMap& boundsMap,
+                const vtkm::filter::flow::internal::BoundsMap& boundsMap,
                 const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>>& particleBlockIDsMap)
     : BoundsMap(boundsMap)
     , ParticleBlockIDsMap(particleBlockIDsMap)
@@ -44,7 +46,7 @@ public:
   {
   }
 
-  const vtkm::filter::flow::BoundsMap BoundsMap;
+  const vtkm::filter::flow::internal::BoundsMap BoundsMap;
   const std::unordered_map<vtkm::Id, std::vector<vtkm::Id>> ParticleBlockIDsMap;
 
   std::vector<ParticleType> A, I, V;
@@ -383,5 +385,6 @@ VTKM_CONT bool DataSetIntegrator::GetOutput(vtkm::cont::DataSet& ds) const
 }
 }
 }
+} //vtkm::filter::flow::internal
 
-#endif //vtk_m_filter_flow_DataSetIntegrator_h
+#endif //vtk_m_filter_flow_internal_DataSetIntegrator_h
diff --git a/vtkm/filter/flow/DataSetIntegratorSteadyState.h b/vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h
similarity index 91%
rename from vtkm/filter/flow/DataSetIntegratorSteadyState.h
rename to vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h
index 4583667ce..fc4d0cc00 100644
--- a/vtkm/filter/flow/DataSetIntegratorSteadyState.h
+++ b/vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h
@@ -8,10 +8,10 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_flow_DataSetIntegratorSteadyState_h
-#define vtk_m_filter_flow_DataSetIntegratorSteadyState_h
+#ifndef vtk_m_filter_flow_internal_DataSetIntegratorSteadyState_h
+#define vtk_m_filter_flow_internal_DataSetIntegratorSteadyState_h
 
-#include <vtkm/filter/flow/DataSetIntegrator.h>
+#include <vtkm/filter/flow/internal/DataSetIntegrator.h>
 
 namespace vtkm
 {
@@ -19,8 +19,10 @@ namespace filter
 {
 namespace flow
 {
+namespace internal
+{
 
-class DataSetIntegratorSteadyState : public vtkm::filter::flow::DataSetIntegrator
+class DataSetIntegratorSteadyState : public vtkm::filter::flow::internal::DataSetIntegrator
 {
 public:
   DataSetIntegratorSteadyState(const vtkm::cont::DataSet& ds,
@@ -29,7 +31,11 @@ public:
                                vtkm::filter::flow::IntegrationSolverType solverType,
                                vtkm::filter::flow::VectorFieldType vecFieldType,
                                vtkm::filter::flow::FlowResultType resultType)
-    : vtkm::filter::flow::DataSetIntegrator(id, fieldName, solverType, vecFieldType, resultType)
+    : vtkm::filter::flow::internal::DataSetIntegrator(id,
+                                                      fieldName,
+                                                      solverType,
+                                                      vecFieldType,
+                                                      resultType)
     , DataSet(ds)
   {
   }
@@ -201,5 +207,6 @@ VTKM_CONT inline void DataSetIntegratorSteadyState::DoAdvect(
 }
 }
 }
+} //vtkm::filter::flow::internal
 
-#endif //vtk_m_filter_flow_DataSetIntegratorSteadyState_h
+#endif //vtk_m_filter_flow_internal_DataSetIntegratorSteadyState_h
diff --git a/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h b/vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h
similarity index 92%
rename from vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
rename to vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h
index 46a7a44a8..dddc64f1f 100644
--- a/vtkm/filter/flow/DataSetIntegratorUnsteadyState.h
+++ b/vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h
@@ -8,10 +8,10 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_flow_DataSetIntegratorUnsteadyState_h
-#define vtk_m_filter_flow_DataSetIntegratorUnsteadyState_h
+#ifndef vtk_m_filter_flow_internal_DataSetIntegratorUnsteadyState_h
+#define vtk_m_filter_flow_internal_DataSetIntegratorUnsteadyState_h
 
-#include <vtkm/filter/flow/DataSetIntegrator.h>
+#include <vtkm/filter/flow/internal/DataSetIntegrator.h>
 #include <vtkm/filter/flow/worklet/TemporalGridEvaluators.h>
 
 namespace vtkm
@@ -20,8 +20,10 @@ namespace filter
 {
 namespace flow
 {
+namespace internal
+{
 
-class DataSetIntegratorUnsteadyState : public vtkm::filter::flow::DataSetIntegrator
+class DataSetIntegratorUnsteadyState : public vtkm::filter::flow::internal::DataSetIntegrator
 {
 public:
   DataSetIntegratorUnsteadyState(
@@ -30,11 +32,15 @@ public:
     vtkm::FloatDefault t1,
     vtkm::FloatDefault t2,
     vtkm::Id id,
-    const vtkm::filter::flow::DataSetIntegrator::FieldNameType& fieldName,
+    const vtkm::filter::flow::internal::DataSetIntegrator::FieldNameType& fieldName,
     vtkm::filter::flow::IntegrationSolverType solverType,
     vtkm::filter::flow::VectorFieldType vecFieldType,
     vtkm::filter::flow::FlowResultType resultType)
-    : vtkm::filter::flow::DataSetIntegrator(id, fieldName, solverType, vecFieldType, resultType)
+    : vtkm::filter::flow::internal::DataSetIntegrator(id,
+                                                      fieldName,
+                                                      solverType,
+                                                      vecFieldType,
+                                                      resultType)
     , DataSet1(ds1)
     , DataSet2(ds2)
     , Time1(t1)
@@ -252,5 +258,6 @@ VTKM_CONT inline void DataSetIntegratorUnsteadyState::DoAdvect(
 }
 }
 }
+} //vtkm::filter::flow::internal
 
-#endif //vtk_m_filter_flow_DataSetIntegratorUnsteadyState_h
+#endif //vtk_m_filter_flow_internal_DataSetIntegratorUnsteadyState_h
diff --git a/vtkm/filter/flow/Messenger.cxx b/vtkm/filter/flow/internal/Messenger.cxx
similarity index 98%
rename from vtkm/filter/flow/Messenger.cxx
rename to vtkm/filter/flow/internal/Messenger.cxx
index cca59ea28..71ea9340b 100644
--- a/vtkm/filter/flow/Messenger.cxx
+++ b/vtkm/filter/flow/internal/Messenger.cxx
@@ -9,7 +9,7 @@
 //============================================================================
 
 #include <vtkm/cont/ErrorFilterExecution.h>
-#include <vtkm/filter/flow/Messenger.h>
+#include <vtkm/filter/flow/internal/Messenger.h>
 
 #include <iostream>
 #include <sstream>
@@ -25,6 +25,8 @@ namespace filter
 {
 namespace flow
 {
+namespace internal
+{
 
 VTKM_CONT
 #ifdef VTKM_ENABLE_MPI
@@ -380,6 +382,8 @@ void Messenger::ProcessReceivedBuffers(std::vector<char*>& incomingBuffers,
 }
 
 #endif
+
 }
 }
-} // namespace vtkm::filter::flow
+}
+} // vtkm::filter::flow::internal
diff --git a/vtkm/filter/flow/Messenger.h b/vtkm/filter/flow/internal/Messenger.h
similarity index 93%
rename from vtkm/filter/flow/Messenger.h
rename to vtkm/filter/flow/internal/Messenger.h
index 11aa064fa..895f9bf46 100644
--- a/vtkm/filter/flow/Messenger.h
+++ b/vtkm/filter/flow/internal/Messenger.h
@@ -8,8 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_flow_Messenger_h
-#define vtk_m_filter_flow_Messenger_h
+#ifndef vtk_m_filter_flow_internal_Messenger_h
+#define vtk_m_filter_flow_internal_Messenger_h
 
 #include <vtkm/Types.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
@@ -30,6 +30,8 @@ namespace filter
 {
 namespace flow
 {
+namespace internal
+{
 
 class VTKM_FILTER_FLOW_EXPORT Messenger
 {
@@ -107,7 +109,7 @@ protected:
 
 }
 }
-} // namespace vtk_m_filter_flow_Messenger_h
+}
+} // vtkm::filter::flow::internal
 
-
-#endif
+#endif // vtk_m_filter_flow_internal_Messenger_h
diff --git a/vtkm/filter/flow/ParticleAdvector.h b/vtkm/filter/flow/internal/ParticleAdvector.h
similarity index 78%
rename from vtkm/filter/flow/ParticleAdvector.h
rename to vtkm/filter/flow/internal/ParticleAdvector.h
index a31d37b44..02595d557 100644
--- a/vtkm/filter/flow/ParticleAdvector.h
+++ b/vtkm/filter/flow/internal/ParticleAdvector.h
@@ -8,13 +8,13 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_flow_ParticleAdvector_h
-#define vtk_m_filter_flow_ParticleAdvector_h
+#ifndef vtk_m_filter_flow_internal_ParticleAdvector_h
+#define vtk_m_filter_flow_internal_ParticleAdvector_h
 
-#include <vtkm/filter/flow/AdvectAlgorithm.h>
-#include <vtkm/filter/flow/AdvectAlgorithmThreaded.h>
-#include <vtkm/filter/flow/BoundsMap.h>
-#include <vtkm/filter/flow/DataSetIntegrator.h>
+#include <vtkm/filter/flow/internal/AdvectAlgorithm.h>
+#include <vtkm/filter/flow/internal/AdvectAlgorithmThreaded.h>
+#include <vtkm/filter/flow/internal/BoundsMap.h>
+#include <vtkm/filter/flow/internal/DataSetIntegrator.h>
 
 namespace vtkm
 {
@@ -22,12 +22,14 @@ namespace filter
 {
 namespace flow
 {
+namespace internal
+{
 
 template <typename DSIType>
 class ParticleAdvector
 {
 public:
-  ParticleAdvector(const vtkm::filter::flow::BoundsMap& bm,
+  ParticleAdvector(const vtkm::filter::flow::internal::BoundsMap& bm,
                    const std::vector<DSIType>& blocks,
                    const bool& useThreaded,
                    const vtkm::filter::flow::FlowResultType& parType)
@@ -73,14 +75,14 @@ private:
     {
       if (this->ResultType == vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE)
       {
-        using AlgorithmType = vtkm::filter::flow::
+        using AlgorithmType = vtkm::filter::flow::internal::
           AdvectAlgorithm<DSIType, vtkm::worklet::flow::ParticleAdvectionResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
       else
       {
-        using AlgorithmType = vtkm::filter::flow::
+        using AlgorithmType = vtkm::filter::flow::internal::
           AdvectAlgorithm<DSIType, vtkm::worklet::flow::StreamlineResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
@@ -90,16 +92,16 @@ private:
     {
       if (this->ResultType == vtkm::filter::flow::FlowResultType::PARTICLE_ADVECT_TYPE)
       {
-        using AlgorithmType =
-          vtkm::filter::flow::AdvectAlgorithmThreaded<DSIType,
-                                                      vtkm::worklet::flow::ParticleAdvectionResult,
-                                                      ParticleType>;
+        using AlgorithmType = vtkm::filter::flow::internal::AdvectAlgorithmThreaded<
+          DSIType,
+          vtkm::worklet::flow::ParticleAdvectionResult,
+          ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
       }
       else
       {
-        using AlgorithmType = vtkm::filter::flow::
+        using AlgorithmType = vtkm::filter::flow::internal::
           AdvectAlgorithmThreaded<DSIType, vtkm::worklet::flow::StreamlineResult, ParticleType>;
 
         return this->RunAlgo<AlgorithmType, ParticleType>(numSteps, stepSize, seeds);
@@ -109,7 +111,7 @@ private:
 
 
   std::vector<DSIType> Blocks;
-  vtkm::filter::flow::BoundsMap BoundsMap;
+  vtkm::filter::flow::internal::BoundsMap BoundsMap;
   FlowResultType ResultType;
   bool UseThreadedAlgorithm;
 };
@@ -117,6 +119,7 @@ private:
 }
 }
 }
+} //vtkm::filter::flow::internal
 
 
-#endif //vtk_m_filter_flow_ParticleAdvector_h
+#endif //vtk_m_filter_flow_internal_ParticleAdvector_h
diff --git a/vtkm/filter/flow/ParticleMessenger.h b/vtkm/filter/flow/internal/ParticleMessenger.h
similarity index 93%
rename from vtkm/filter/flow/ParticleMessenger.h
rename to vtkm/filter/flow/internal/ParticleMessenger.h
index 3802c2564..3f010432e 100644
--- a/vtkm/filter/flow/ParticleMessenger.h
+++ b/vtkm/filter/flow/internal/ParticleMessenger.h
@@ -8,12 +8,12 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#ifndef vtk_m_filter_flow_ParticleMessenger_h
-#define vtk_m_filter_flow_ParticleMessenger_h
+#ifndef vtk_m_filter_flow_internal_ParticleMessenger_h
+#define vtk_m_filter_flow_internal_ParticleMessenger_h
 
 #include <vtkm/Particle.h>
-#include <vtkm/filter/flow/BoundsMap.h>
-#include <vtkm/filter/flow/Messenger.h>
+#include <vtkm/filter/flow/internal/BoundsMap.h>
+#include <vtkm/filter/flow/internal/Messenger.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 #include <list>
@@ -27,9 +27,11 @@ namespace filter
 {
 namespace flow
 {
+namespace internal
+{
 
 template <typename ParticleType>
-class VTKM_FILTER_FLOW_EXPORT ParticleMessenger : public vtkm::filter::flow::Messenger
+class VTKM_FILTER_FLOW_EXPORT ParticleMessenger : public vtkm::filter::flow::internal::Messenger
 {
   //sendRank, message
   using MsgCommType = std::pair<int, std::vector<int>>;
@@ -42,7 +44,7 @@ class VTKM_FILTER_FLOW_EXPORT ParticleMessenger : public vtkm::filter::flow::Mes
 
 public:
   VTKM_CONT ParticleMessenger(vtkmdiy::mpi::communicator& comm,
-                              const vtkm::filter::flow::BoundsMap& bm,
+                              const vtkm::filter::flow::internal::BoundsMap& bm,
                               int msgSz = 1,
                               int numParticles = 128,
                               int numBlockIds = 2);
@@ -88,7 +90,7 @@ protected:
   VTKM_CONT bool RecvAny(std::vector<MsgCommType>* msgs,
                          std::vector<ParticleRecvCommType>* recvParticles,
                          bool blockAndWait);
-  const vtkm::filter::flow::BoundsMap& BoundsMap;
+  const vtkm::filter::flow::internal::BoundsMap& BoundsMap;
 
 #endif
 
@@ -107,11 +109,12 @@ protected:
 
 VTKM_CONT
 template <typename ParticleType>
-ParticleMessenger<ParticleType>::ParticleMessenger(vtkmdiy::mpi::communicator& comm,
-                                                   const vtkm::filter::flow::BoundsMap& boundsMap,
-                                                   int msgSz,
-                                                   int numParticles,
-                                                   int numBlockIds)
+ParticleMessenger<ParticleType>::ParticleMessenger(
+  vtkmdiy::mpi::communicator& comm,
+  const vtkm::filter::flow::internal::BoundsMap& boundsMap,
+  int msgSz,
+  int numParticles,
+  int numBlockIds)
   : Messenger(comm)
 #ifdef VTKM_ENABLE_MPI
   , BoundsMap(boundsMap)
@@ -356,8 +359,10 @@ inline void ParticleMessenger<ParticleType>::SendParticles(
       this->SendParticles(mit.first, mit.second);
 }
 #endif
-}
-}
-} // namespace vtkm::filter::flow
 
-#endif
+}
+}
+}
+} // vtkm::filter::flow::internal
+
+#endif // vtk_m_filter_flow_internal_ParticleMessenger_h
diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index 4188325c3..68ecc5511 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -8,11 +8,13 @@
 ##  PURPOSE.  See the above copyright notice for more information.
 ##============================================================================
 
-set(unit_tests
+set(filter_unit_tests
   UnitTestStreamlineFilter.cxx
+  UnitTestStreamSurfaceFilter.cxx
+  )
+set(worklet_unit_tests
   UnitTestWorkletParticleAdvection.cxx
   UnitTestWorkletTemporalAdvection.cxx
-  UnitTestStreamSurfaceFilter.cxx
   UnitTestStreamSurfaceWorklet.cxx
   )
 
@@ -21,7 +23,8 @@ set(libraries
   )
 
 vtkm_unit_tests(
-  DEVICE_SOURCES ${unit_tests}
+  SOURCES ${filter_unit_tests}
+  DEVICE_SOURCES ${worklet_unit_tests}
   LIBRARIES ${libraries} vtkm_filter vtkm_io
   USE_VTKM_JOB_POOL
 )
diff --git a/vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx b/vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx
index 1ea6d22a8..480d9551b 100644
--- a/vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx
+++ b/vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx
@@ -10,7 +10,7 @@
 
 #include <vtkm/cont/Serialization.h>
 #include <vtkm/cont/testing/Testing.h>
-#include <vtkm/filter/flow/ParticleMessenger.h>
+#include <vtkm/filter/flow/internal/ParticleMessenger.h>
 
 #include <vtkm/thirdparty/diy/diy.h>
 
@@ -23,11 +23,11 @@ using MCommType = std::pair<int, std::vector<int>>;
 using PCommType = std::pair<vtkm::Particle, std::vector<vtkm::Id>>;
 using PRecvCommType = std::pair<int, std::vector<PCommType>>;
 
-class TestMessenger : public vtkm::filter::flow::ParticleMessenger<vtkm::Particle>
+class TestMessenger : public vtkm::filter::flow::internal::ParticleMessenger<vtkm::Particle>
 {
 public:
   TestMessenger(vtkmdiy::mpi::communicator& comm,
-                const vtkm::filter::flow::BoundsMap& bm,
+                const vtkm::filter::flow::internal::BoundsMap& bm,
                 int msgSz = 1,
                 int numParticles = 1,
                 int numBlockIds = 1)
@@ -120,7 +120,7 @@ void TestParticleMessenger()
   //Only works for 2 or more ranks.
   if (comm.size() == 1)
     return;
-  vtkm::filter::flow::BoundsMap boundsMap;
+  vtkm::filter::flow::internal::BoundsMap boundsMap;
 
   int maxMsgSz = 100;
   int maxNumParticles = 128;
@@ -244,7 +244,7 @@ void TestBufferSizes()
 {
   //Make sure the buffer sizes are correct.
   auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
-  vtkm::filter::flow::BoundsMap boundsMap;
+  vtkm::filter::flow::internal::BoundsMap boundsMap;
 
   std::vector<int> mSzs = { 1, 2, 3, 4, 5 };
   std::vector<int> numPs = { 1, 2, 3, 4, 5 };
diff --git a/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx b/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
index ca4ea34c1..482583ccf 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/flow/StreamSurface.h>
diff --git a/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
index 94adad56e..cf76ba2d3 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
@@ -9,6 +9,7 @@
 //============================================================================
 
 #include <vtkm/CellClassification.h>
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/flow/ParticleAdvection.h>
diff --git a/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
index 506d5f6c7..82cb28af4 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
@@ -9,6 +9,7 @@
 //============================================================================
 
 #include <vtkm/CellClassification.h>
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/flow/ParticleAdvection.h>
 #include <vtkm/filter/flow/Pathline.h>
diff --git a/vtkm/filter/testing/RenderTestStreamline.cxx b/vtkm/filter/testing/RenderTestStreamline.cxx
index 53f723a4f..1201ddc96 100644
--- a/vtkm/filter/testing/RenderTestStreamline.cxx
+++ b/vtkm/filter/testing/RenderTestStreamline.cxx
@@ -9,6 +9,7 @@
 //============================================================================
 
 #include <vtkm/Math.h>
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ArrayHandleConstant.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/testing/Testing.h>

From 0800f19b4333800455b70532677bd617b2483c5c Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 29 Jul 2022 10:09:13 -0400
Subject: [PATCH 081/104] Fix the particle advection examples.

---
 examples/particle_advection/ParticleAdvection.cxx | 1 +
 examples/streamline_mpi/StreamlineMPI.cxx         | 8 ++------
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/examples/particle_advection/ParticleAdvection.cxx b/examples/particle_advection/ParticleAdvection.cxx
index eff3b1224..437b37efe 100644
--- a/examples/particle_advection/ParticleAdvection.cxx
+++ b/examples/particle_advection/ParticleAdvection.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/Initialize.h>
 #include <vtkm/filter/flow/Streamline.h>
diff --git a/examples/streamline_mpi/StreamlineMPI.cxx b/examples/streamline_mpi/StreamlineMPI.cxx
index ac204800f..3395ddf49 100644
--- a/examples/streamline_mpi/StreamlineMPI.cxx
+++ b/examples/streamline_mpi/StreamlineMPI.cxx
@@ -8,12 +8,14 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/AssignerPartitionedDataSet.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/EnvironmentTracker.h>
 #include <vtkm/cont/Field.h>
 #include <vtkm/cont/Initialize.h>
 #include <vtkm/cont/PartitionedDataSet.h>
+#include <vtkm/filter/flow/ParticleAdvection.h>
 #include <vtkm/io/VTKDataSetReader.h>
 #include <vtkm/io/VTKDataSetWriter.h>
 #include <vtkm/io/reader/VTKDataSetReader.h>
@@ -22,12 +24,6 @@
 #include <vtkm/thirdparty/diy/diy.h>
 #include <vtkm/thirdparty/diy/mpi-cast.h>
 
-
-#include <vtkm/filter/flow/BoundsMap.h>
-#include <vtkm/filter/flow/ParticleAdvection.h>
-#include <vtkm/filter/flow/ParticleMessenger.h>
-
-
 void LoadData(std::string& fname, std::vector<vtkm::cont::DataSet>& dataSets, int rank, int nRanks)
 {
   std::string buff;

From f963f519077c20c6cf6081c952d9420d8fabc5cb Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 29 Jul 2022 10:16:14 -0400
Subject: [PATCH 082/104] Fix the benchmarks......

---
 benchmarking/BenchmarkODEIntegrators.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/benchmarking/BenchmarkODEIntegrators.cxx b/benchmarking/BenchmarkODEIntegrators.cxx
index fb267968c..62d04555b 100644
--- a/benchmarking/BenchmarkODEIntegrators.cxx
+++ b/benchmarking/BenchmarkODEIntegrators.cxx
@@ -10,6 +10,7 @@
 
 #include "Benchmarker.h"
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/ErrorInternal.h>

From 0c2652e16dce6cbb9e17be55902244cbcf292f76 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 29 Jul 2022 10:54:19 -0400
Subject: [PATCH 083/104] Test the variant fix from !2824

---
 vtkm/filter/flow/internal/DataSetIntegrator.h | 14 +-------------
 vtkm/internal/VariantImpl.h                   |  7 +++----
 2 files changed, 4 insertions(+), 17 deletions(-)

diff --git a/vtkm/filter/flow/internal/DataSetIntegrator.h b/vtkm/filter/flow/internal/DataSetIntegrator.h
index 2870d5b5e..9dc4db9cf 100644
--- a/vtkm/filter/flow/internal/DataSetIntegrator.h
+++ b/vtkm/filter/flow/internal/DataSetIntegrator.h
@@ -97,19 +97,8 @@ public:
                       vtkm::FloatDefault stepSize, //move these to member data(?)
                       vtkm::Id maxSteps)
   {
-    if (b.GetIndex() == b.GetIndexOf<DSIHelperInfo<vtkm::Particle>>())
-    {
-      auto& bb = b.Get<DSIHelperInfo<vtkm::Particle>>();
-      this->DoAdvect(bb, stepSize, maxSteps);
-    }
-    else if (b.GetIndex() == b.GetIndexOf<DSIHelperInfo<vtkm::ChargedParticle>>())
-    {
-      auto& bb = b.Get<DSIHelperInfo<vtkm::ChargedParticle>>();
-      this->DoAdvect(bb, stepSize, maxSteps);
-    }
-
     //Cast the DSIHelperInfo<ParticleType> to the concrete type and call DoAdvect.
-    //b.CastAndCall([&](auto& concrete) { this->DoAdvect(concrete, stepSize, maxSteps); });
+    b.CastAndCall([&](auto& concrete) { this->DoAdvect(concrete, stepSize, maxSteps); });
   }
 
   template <typename ParticleType>
@@ -381,7 +370,6 @@ VTKM_CONT bool DataSetIntegrator::GetOutput(vtkm::cont::DataSet& ds) const
   return true;
 }
 
-
 }
 }
 }
diff --git a/vtkm/internal/VariantImpl.h b/vtkm/internal/VariantImpl.h
index e11926865..7e586b6de 100644
--- a/vtkm/internal/VariantImpl.h
+++ b/vtkm/internal/VariantImpl.h
@@ -510,7 +510,6 @@ public:
   template <typename Functor, typename... Args>
   VTK_M_DEVICE auto CastAndCall(Functor&& f, Args&&... args) const
     noexcept(noexcept(f(std::declval<const TypeAt<0>&>(), args...)))
-      -> decltype(f(std::declval<const TypeAt<0>&>(), args...))
   {
     VTKM_ASSERT(this->IsValid());
     return detail::VariantCastAndCallImpl<sizeof...(Ts)>(
@@ -518,9 +517,9 @@ public:
   }
 
   template <typename Functor, typename... Args>
-  VTK_M_DEVICE auto CastAndCall(Functor&& f, Args&&... args) noexcept(
-    noexcept(f(std::declval<const TypeAt<0>&>(), args...)))
-    -> decltype(f(std::declval<TypeAt<0>&>(), args...))
+  VTK_M_DEVICE auto CastAndCall(Functor&& f,
+                                Args&&... args) noexcept(noexcept(f(std::declval<TypeAt<0>&>(),
+                                                                    args...)))
   {
     VTKM_ASSERT(this->IsValid());
     return detail::VariantCastAndCallImpl<sizeof...(Ts)>(

From 0d15a015fac750f5ddc0f71ae5f6eed2fe82a50c Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 29 Jul 2022 11:14:24 -0400
Subject: [PATCH 084/104] Remove unused virtuals.....

---
 vtkm/filter/flow/internal/DataSetIntegrator.h | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/vtkm/filter/flow/internal/DataSetIntegrator.h b/vtkm/filter/flow/internal/DataSetIntegrator.h
index 9dc4db9cf..32297ac18 100644
--- a/vtkm/filter/flow/internal/DataSetIntegrator.h
+++ b/vtkm/filter/flow/internal/DataSetIntegrator.h
@@ -87,15 +87,13 @@ public:
     //check that things are valid.
   }
 
-  virtual ~DataSetIntegrator() {}
-
   VTKM_CONT vtkm::Id GetID() const { return this->Id; }
   VTKM_CONT void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
 
   VTKM_CONT
-  virtual void Advect(DSIHelperInfoType& b,
-                      vtkm::FloatDefault stepSize, //move these to member data(?)
-                      vtkm::Id maxSteps)
+  void Advect(DSIHelperInfoType& b,
+              vtkm::FloatDefault stepSize, //move these to member data(?)
+              vtkm::Id maxSteps)
   {
     //Cast the DSIHelperInfo<ParticleType> to the concrete type and call DoAdvect.
     b.CastAndCall([&](auto& concrete) { this->DoAdvect(concrete, stepSize, maxSteps); });

From 6a200c62d9415650900c43afd37ee219b0f0720e Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 29 Jul 2022 13:39:38 -0400
Subject: [PATCH 085/104] Cuda fixes: device in headers..

---
 benchmarking/BenchmarkInSitu.cxx                             | 1 +
 benchmarking/BenchmarkODEIntegrators.cxx                     | 1 +
 examples/particle_advection/ParticleAdvection.cxx            | 1 +
 examples/streamline_mpi/StreamlineMPI.cxx                    | 2 ++
 examples/temporal_advection/TemporalAdvection.cxx            | 1 +
 vtkm/cont/ParticleArrayCopy.hxx                              | 1 -
 vtkm/cont/testing/UnitTestParticleArrayCopy.cxx              | 1 +
 vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx   | 1 +
 vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx | 1 +
 vtkm/filter/flow/ParticleAdvection.cxx                       | 1 +
 vtkm/filter/flow/PathParticle.cxx                            | 1 +
 vtkm/filter/flow/Pathline.cxx                                | 1 +
 vtkm/filter/flow/Streamline.cxx                              | 1 +
 vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx     | 1 +
 vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx        | 1 +
 vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx     | 1 +
 vtkm/filter/testing/RenderTestStreamline.cxx                 | 1 +
 17 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/benchmarking/BenchmarkInSitu.cxx b/benchmarking/BenchmarkInSitu.cxx
index b6c56f3f7..958e22a03 100644
--- a/benchmarking/BenchmarkInSitu.cxx
+++ b/benchmarking/BenchmarkInSitu.cxx
@@ -15,6 +15,7 @@
 
 #include <vtkm/ImplicitFunction.h>
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/BoundsCompute.h>
 #include <vtkm/cont/DataSet.h>
diff --git a/benchmarking/BenchmarkODEIntegrators.cxx b/benchmarking/BenchmarkODEIntegrators.cxx
index 62d04555b..7b6c44f61 100644
--- a/benchmarking/BenchmarkODEIntegrators.cxx
+++ b/benchmarking/BenchmarkODEIntegrators.cxx
@@ -10,6 +10,7 @@
 
 #include "Benchmarker.h"
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
diff --git a/examples/particle_advection/ParticleAdvection.cxx b/examples/particle_advection/ParticleAdvection.cxx
index 437b37efe..945376cae 100644
--- a/examples/particle_advection/ParticleAdvection.cxx
+++ b/examples/particle_advection/ParticleAdvection.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/Initialize.h>
diff --git a/examples/streamline_mpi/StreamlineMPI.cxx b/examples/streamline_mpi/StreamlineMPI.cxx
index 3395ddf49..d6619cd03 100644
--- a/examples/streamline_mpi/StreamlineMPI.cxx
+++ b/examples/streamline_mpi/StreamlineMPI.cxx
@@ -8,6 +8,8 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/AssignerPartitionedDataSet.h>
 #include <vtkm/cont/DataSet.h>
diff --git a/examples/temporal_advection/TemporalAdvection.cxx b/examples/temporal_advection/TemporalAdvection.cxx
index 99c75dc37..f578c10bc 100644
--- a/examples/temporal_advection/TemporalAdvection.cxx
+++ b/examples/temporal_advection/TemporalAdvection.cxx
@@ -12,6 +12,7 @@
 #include <string>
 #include <vector>
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/Initialize.h>
diff --git a/vtkm/cont/ParticleArrayCopy.hxx b/vtkm/cont/ParticleArrayCopy.hxx
index 8901d5104..fb0a2123f 100644
--- a/vtkm/cont/ParticleArrayCopy.hxx
+++ b/vtkm/cont/ParticleArrayCopy.hxx
@@ -11,7 +11,6 @@
 #ifndef vtk_m_cont_ParticleArrayCopy_hxx
 #define vtk_m_cont_ParticleArrayCopy_hxx
 
-#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayHandleTransform.h>
 #include <vtkm/cont/Invoker.h>
 #include <vtkm/cont/ParticleArrayCopy.h>
diff --git a/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx b/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx
index 09c495383..4054270cf 100644
--- a/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx
+++ b/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx
@@ -9,6 +9,7 @@
 //============================================================================
 
 #include <random>
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ParticleArrayCopy.h>
 #include <vtkm/cont/testing/Testing.h>
 
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
index a9a9f5799..9793ee726 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
 #include <vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h>
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
index 98b43249f..4a053da9e 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
 #include <vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h>
diff --git a/vtkm/filter/flow/ParticleAdvection.cxx b/vtkm/filter/flow/ParticleAdvection.cxx
index b4defef86..71ca9259e 100644
--- a/vtkm/filter/flow/ParticleAdvection.cxx
+++ b/vtkm/filter/flow/ParticleAdvection.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/ParticleAdvection.h>
 
diff --git a/vtkm/filter/flow/PathParticle.cxx b/vtkm/filter/flow/PathParticle.cxx
index 03e091b4e..e288dca11 100644
--- a/vtkm/filter/flow/PathParticle.cxx
+++ b/vtkm/filter/flow/PathParticle.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/PathParticle.h>
 
diff --git a/vtkm/filter/flow/Pathline.cxx b/vtkm/filter/flow/Pathline.cxx
index 4fe512182..de5b74cc9 100644
--- a/vtkm/filter/flow/Pathline.cxx
+++ b/vtkm/filter/flow/Pathline.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/Pathline.h>
 
diff --git a/vtkm/filter/flow/Streamline.cxx b/vtkm/filter/flow/Streamline.cxx
index 0eeeec8e4..d33b7b620 100644
--- a/vtkm/filter/flow/Streamline.cxx
+++ b/vtkm/filter/flow/Streamline.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/Streamline.h>
 
diff --git a/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx b/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
index 482583ccf..4c7fffae1 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
diff --git a/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
index cf76ba2d3..5e6f8a819 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
@@ -9,6 +9,7 @@
 //============================================================================
 
 #include <vtkm/CellClassification.h>
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
diff --git a/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
index 82cb28af4..bd42b74e9 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
@@ -9,6 +9,7 @@
 //============================================================================
 
 #include <vtkm/CellClassification.h>
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/flow/ParticleAdvection.h>
diff --git a/vtkm/filter/testing/RenderTestStreamline.cxx b/vtkm/filter/testing/RenderTestStreamline.cxx
index 1201ddc96..a6fde1804 100644
--- a/vtkm/filter/testing/RenderTestStreamline.cxx
+++ b/vtkm/filter/testing/RenderTestStreamline.cxx
@@ -9,6 +9,7 @@
 //============================================================================
 
 #include <vtkm/Math.h>
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ArrayHandleConstant.h>
 #include <vtkm/cont/DataSet.h>

From 403d800584bf31358f37fcc11b34720149dfb30c Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 29 Jul 2022 13:55:37 -0400
Subject: [PATCH 086/104] Remove compiler warnings on dashboard

---
 vtkm/filter/flow/internal/DataSetIntegrator.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/vtkm/filter/flow/internal/DataSetIntegrator.h b/vtkm/filter/flow/internal/DataSetIntegrator.h
index 32297ac18..270bba091 100644
--- a/vtkm/filter/flow/internal/DataSetIntegrator.h
+++ b/vtkm/filter/flow/internal/DataSetIntegrator.h
@@ -87,6 +87,8 @@ public:
     //check that things are valid.
   }
 
+  virtual ~DataSetIntegrator() {}
+
   VTKM_CONT vtkm::Id GetID() const { return this->Id; }
   VTKM_CONT void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
 

From 9b2a257d9fab5615a3870fab36f8b281b31c9fdd Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 29 Jul 2022 15:05:59 -0400
Subject: [PATCH 087/104] Move include  out of .h file.

---
 vtkm/filter/flow/CMakeLists.txt               |  1 +
 .../flow/NewFilterParticleAdvection.cxx       | 54 +++++++++++++++++++
 vtkm/filter/flow/NewFilterParticleAdvection.h | 31 +----------
 3 files changed, 57 insertions(+), 29 deletions(-)
 create mode 100644 vtkm/filter/flow/NewFilterParticleAdvection.cxx

diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index bb0f8f548..4a8ab1c27 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -21,6 +21,7 @@ set(flow_headers
 
 set(flow_sources
   internal/Messenger.cxx
+  NewFilterParticleAdvection.cxx
   NewFilterParticleAdvectionSteadyState.cxx
   NewFilterParticleAdvectionUnsteadyState.cxx
   ParticleAdvection.cxx
diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.cxx b/vtkm/filter/flow/NewFilterParticleAdvection.cxx
new file mode 100644
index 000000000..3ef938356
--- /dev/null
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.cxx
@@ -0,0 +1,54 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+
+#include <vtkm/Particle.h>
+#include <vtkm/cont/ErrorFilterExecution.h>
+#include <vtkm/filter/flow/NewFilterParticleAdvection.h>
+
+namespace vtkm
+{
+namespace filter
+{
+namespace flow
+{
+
+VTKM_CONT vtkm::cont::DataSet NewFilterParticleAdvection::DoExecute(
+  const vtkm::cont::DataSet& inData)
+{
+  auto out = this->DoExecutePartitions(inData);
+  if (out.GetNumberOfPartitions() != 1)
+    throw vtkm::cont::ErrorFilterExecution("Wrong number of results");
+
+  return out.GetPartition(0);
+}
+
+VTKM_CONT void NewFilterParticleAdvection::ValidateOptions() const
+{
+  if (this->GetUseCoordinateSystemAsField())
+    throw vtkm::cont::ErrorFilterExecution("Coordinate system as field not supported");
+  if (this->Seeds.GetNumberOfValues() == 0)
+    throw vtkm::cont::ErrorFilterExecution("No seeds provided.");
+  if (!this->Seeds.IsBaseComponentType<vtkm::Particle>() &&
+      this->Seeds.IsBaseComponentType<vtkm::ChargedParticle>())
+    throw vtkm::cont::ErrorFilterExecution("Unsupported particle type in seed array.");
+  if (this->NumberOfSteps == 0)
+    throw vtkm::cont::ErrorFilterExecution("Number of steps not specified.");
+  if (this->StepSize == 0)
+    throw vtkm::cont::ErrorFilterExecution("Step size not specified.");
+  if (this->NumberOfSteps < 0)
+    throw vtkm::cont::ErrorFilterExecution("NumberOfSteps cannot be negative");
+  if (this->StepSize < 0)
+    throw vtkm::cont::ErrorFilterExecution("StepSize cannot be negative");
+}
+
+}
+}
+} // namespace vtkm::filter::flow
diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index 4b56270a7..a5e54738d 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -11,8 +11,6 @@
 #ifndef vtk_m_filter_flow_NewFilterParticleAdvection_h
 #define vtk_m_filter_flow_NewFilterParticleAdvection_h
 
-#include <vtkm/Particle.h>
-#include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/NewFilterField.h>
 #include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
@@ -66,33 +64,8 @@ public:
   void SetUseThreadedAlgorithm(bool val) { this->UseThreadedAlgorithm = val; }
 
 protected:
-  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override
-  {
-    auto out = this->DoExecutePartitions(inData);
-    if (out.GetNumberOfPartitions() != 1)
-      throw vtkm::cont::ErrorFilterExecution("Wrong number of results");
-
-    return out.GetPartition(0);
-  }
-
-  VTKM_CONT virtual void ValidateOptions() const
-  {
-    if (this->GetUseCoordinateSystemAsField())
-      throw vtkm::cont::ErrorFilterExecution("Coordinate system as field not supported");
-    if (this->Seeds.GetNumberOfValues() == 0)
-      throw vtkm::cont::ErrorFilterExecution("No seeds provided.");
-    if (!this->Seeds.IsBaseComponentType<vtkm::Particle>() &&
-        this->Seeds.IsBaseComponentType<vtkm::ChargedParticle>())
-      throw vtkm::cont::ErrorFilterExecution("Unsupported particle type in seed array.");
-    if (this->NumberOfSteps == 0)
-      throw vtkm::cont::ErrorFilterExecution("Number of steps not specified.");
-    if (this->StepSize == 0)
-      throw vtkm::cont::ErrorFilterExecution("Step size not specified.");
-    if (this->NumberOfSteps < 0)
-      throw vtkm::cont::ErrorFilterExecution("NumberOfSteps cannot be negative");
-    if (this->StepSize < 0)
-      throw vtkm::cont::ErrorFilterExecution("StepSize cannot be negative");
-  }
+  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
+  VTKM_CONT virtual void ValidateOptions() const;
 
   VTKM_CONT virtual vtkm::filter::flow::FlowResultType GetResultType() const
   {

From 2a4430447ac339a4afd1ca8dba2ac21dc9d41f43 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Fri, 29 Jul 2022 22:15:13 -0400
Subject: [PATCH 088/104] tests need to be device compiled.

---
 vtkm/filter/flow/testing/CMakeLists.txt | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index 68ecc5511..7a119c0ac 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -8,11 +8,9 @@
 ##  PURPOSE.  See the above copyright notice for more information.
 ##============================================================================
 
-set(filter_unit_tests
+set(unit_tests
   UnitTestStreamlineFilter.cxx
   UnitTestStreamSurfaceFilter.cxx
-  )
-set(worklet_unit_tests
   UnitTestWorkletParticleAdvection.cxx
   UnitTestWorkletTemporalAdvection.cxx
   UnitTestStreamSurfaceWorklet.cxx
@@ -23,8 +21,7 @@ set(libraries
   )
 
 vtkm_unit_tests(
-  SOURCES ${filter_unit_tests}
-  DEVICE_SOURCES ${worklet_unit_tests}
+  DEVICE_SOURCES ${unit_tests}
   LIBRARIES ${libraries} vtkm_filter vtkm_io
   USE_VTKM_JOB_POOL
 )

From e1fbfea305c410650c6f5b1776001960c71a7cce Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 1 Aug 2022 08:00:46 -0400
Subject: [PATCH 089/104] Remove device compiler dependencies.

---
 benchmarking/BenchmarkInSitu.cxx              |  1 +
 benchmarking/BenchmarkODEIntegrators.cxx      |  4 +-
 examples/particle_advection/CMakeLists.txt    |  8 +-
 .../particle_advection/ParticleAdvection.cxx  |  3 +-
 examples/streamline_mpi/CMakeLists.txt        |  9 +--
 examples/streamline_mpi/StreamlineMPI.cxx     |  4 +-
 .../temporal_advection/TemporalAdvection.cxx  |  5 +-
 vtkm/cont/ParticleArrayCopy.hxx               |  1 +
 vtkm/filter/flow/CMakeLists.txt               | 10 ++-
 .../NewFilterParticleAdvectionSteadyState.cxx | 28 ++++---
 .../NewFilterParticleAdvectionSteadyState.h   | 13 ----
 ...ewFilterParticleAdvectionUnsteadyState.cxx | 51 ++++++++-----
 .../NewFilterParticleAdvectionUnsteadyState.h | 18 +----
 vtkm/filter/flow/PathParticle.cxx             |  2 -
 vtkm/filter/flow/Pathline.cxx                 |  2 -
 vtkm/filter/flow/StreamSurface.cxx            |  2 -
 vtkm/filter/flow/StreamSurface.h              |  1 -
 .../internal/DataSetIntegratorSteadyState.h   |  1 +
 .../internal/DataSetIntegratorUnsteadyState.h |  1 +
 vtkm/filter/flow/testing/CMakeLists.txt       | 21 +++++-
 .../flow/testing/RenderTestStreamline.cxx     | 74 +++++++++++++++++++
 .../testing/UnitTestStreamSurfaceFilter.cxx   |  3 +-
 .../flow/testing/UnitTestStreamlineFilter.cxx |  3 +-
 .../testing/UnitTestStreamlineFilterMPI.cxx   |  3 +-
 .../flow/worklet/ParticleAdvectionWorklets.h  |  1 +
 vtkm/filter/testing/CMakeLists.txt            |  8 --
 26 files changed, 164 insertions(+), 113 deletions(-)
 create mode 100644 vtkm/filter/flow/testing/RenderTestStreamline.cxx

diff --git a/benchmarking/BenchmarkInSitu.cxx b/benchmarking/BenchmarkInSitu.cxx
index 958e22a03..721f53b6e 100644
--- a/benchmarking/BenchmarkInSitu.cxx
+++ b/benchmarking/BenchmarkInSitu.cxx
@@ -14,6 +14,7 @@
 #include <sstream>
 
 #include <vtkm/ImplicitFunction.h>
+#include <vtkm/Particle.h>
 
 #include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
diff --git a/benchmarking/BenchmarkODEIntegrators.cxx b/benchmarking/BenchmarkODEIntegrators.cxx
index 7b6c44f61..c3848a289 100644
--- a/benchmarking/BenchmarkODEIntegrators.cxx
+++ b/benchmarking/BenchmarkODEIntegrators.cxx
@@ -10,11 +10,9 @@
 
 #include "Benchmarker.h"
 
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
+#include <vtkm/Particle.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
-#include <vtkm/cont/ErrorInternal.h>
 #include <vtkm/cont/Logging.h>
 #include <vtkm/cont/RuntimeDeviceTracker.h>
 #include <vtkm/cont/Timer.h>
diff --git a/examples/particle_advection/CMakeLists.txt b/examples/particle_advection/CMakeLists.txt
index 7866c56c6..12a8ef3b3 100644
--- a/examples/particle_advection/CMakeLists.txt
+++ b/examples/particle_advection/CMakeLists.txt
@@ -14,10 +14,4 @@ project(ParticleAdvection CXX)
 find_package(VTKm REQUIRED QUIET)
 
 add_executable(Particle_Advection ParticleAdvection.cxx)
-target_link_libraries(Particle_Advection PRIVATE vtkm_filter vtkm_io)
-vtkm_add_target_information(Particle_Advection
-                            DROP_UNUSED_SYMBOLS MODIFY_CUDA_FLAGS
-                            DEVICE_SOURCES ParticleAdvection.cxx)
-if(TARGET vtkm::tbb)
-  target_compile_definitions(Particle_Advection PRIVATE BUILDING_TBB_VERSION)
-endif()
+target_link_libraries(Particle_Advection PRIVATE vtkm_filter_flow vtkm_io)
diff --git a/examples/particle_advection/ParticleAdvection.cxx b/examples/particle_advection/ParticleAdvection.cxx
index 945376cae..64172d152 100644
--- a/examples/particle_advection/ParticleAdvection.cxx
+++ b/examples/particle_advection/ParticleAdvection.cxx
@@ -8,8 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
+#include <vtkm/Particle.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/Initialize.h>
 #include <vtkm/filter/flow/Streamline.h>
diff --git a/examples/streamline_mpi/CMakeLists.txt b/examples/streamline_mpi/CMakeLists.txt
index c65f29474..5ce083ae3 100644
--- a/examples/streamline_mpi/CMakeLists.txt
+++ b/examples/streamline_mpi/CMakeLists.txt
@@ -16,12 +16,5 @@ find_package(VTKm REQUIRED QUIET)
 if (VTKm_ENABLE_MPI)
   add_executable(StreamlineMPI StreamlineMPI.cxx)
   target_compile_definitions(StreamlineMPI PRIVATE "MPI_ENABLED")
-  target_link_libraries(StreamlineMPI PRIVATE vtkm_filter vtkm_io MPI::MPI_CXX)
-  vtkm_add_target_information(StreamlineMPI
-                              DROP_UNUSED_SYMBOLS MODIFY_CUDA_FLAGS
-                              DEVICE_SOURCES StreamlineMPI.cxx)
+  target_link_libraries(StreamlineMPI PRIVATE vtkm_filter_flow vtkm_io MPI::MPI_CXX)
 endif()
-
-#if(TARGET vtkm::tbb)
-#  target_compile_definitions(streamline_mpi PRIVATE BUILDING_TBB_VERSION)
-#endif()
diff --git a/examples/streamline_mpi/StreamlineMPI.cxx b/examples/streamline_mpi/StreamlineMPI.cxx
index d6619cd03..aec518cec 100644
--- a/examples/streamline_mpi/StreamlineMPI.cxx
+++ b/examples/streamline_mpi/StreamlineMPI.cxx
@@ -8,9 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
+#include <vtkm/Particle.h>
 #include <vtkm/cont/AssignerPartitionedDataSet.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/EnvironmentTracker.h>
diff --git a/examples/temporal_advection/TemporalAdvection.cxx b/examples/temporal_advection/TemporalAdvection.cxx
index f578c10bc..141833e6b 100644
--- a/examples/temporal_advection/TemporalAdvection.cxx
+++ b/examples/temporal_advection/TemporalAdvection.cxx
@@ -12,11 +12,12 @@
 #include <string>
 #include <vector>
 
-#include <vtkm/cont/Algorithm.h>
+#include <vtkm/Particle.h>
+//#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/Initialize.h>
-#include <vtkm/cont/Timer.h>
+//#include <vtkm/cont/Timer.h>
 
 #include <vtkm/filter/flow/Pathline.h>
 
diff --git a/vtkm/cont/ParticleArrayCopy.hxx b/vtkm/cont/ParticleArrayCopy.hxx
index fb0a2123f..8901d5104 100644
--- a/vtkm/cont/ParticleArrayCopy.hxx
+++ b/vtkm/cont/ParticleArrayCopy.hxx
@@ -11,6 +11,7 @@
 #ifndef vtk_m_cont_ParticleArrayCopy_hxx
 #define vtk_m_cont_ParticleArrayCopy_hxx
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayHandleTransform.h>
 #include <vtkm/cont/Invoker.h>
 #include <vtkm/cont/ParticleArrayCopy.h>
diff --git a/vtkm/filter/flow/CMakeLists.txt b/vtkm/filter/flow/CMakeLists.txt
index 4a8ab1c27..7eb390a4b 100644
--- a/vtkm/filter/flow/CMakeLists.txt
+++ b/vtkm/filter/flow/CMakeLists.txt
@@ -22,19 +22,23 @@ set(flow_headers
 set(flow_sources
   internal/Messenger.cxx
   NewFilterParticleAdvection.cxx
-  NewFilterParticleAdvectionSteadyState.cxx
-  NewFilterParticleAdvectionUnsteadyState.cxx
   ParticleAdvection.cxx
   Pathline.cxx
   PathParticle.cxx
   Streamline.cxx
+  )
+
+set(flow_device_sources
+  NewFilterParticleAdvectionSteadyState.cxx
+  NewFilterParticleAdvectionUnsteadyState.cxx
   StreamSurface.cxx
   )
 
 vtkm_library(
   NAME vtkm_filter_flow
   HEADERS ${flow_headers}
-  DEVICE_SOURCES ${flow_sources}
+  SOURCES ${flow_sources}
+  DEVICE_SOURCES ${flow_device_sources}
   USE_VTKM_JOB_POOL
 )
 
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
index 9793ee726..fbee0fa1c 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx
@@ -8,10 +8,10 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
 #include <vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h>
+
+#include <vtkm/filter/flow/internal/BoundsMap.h>
 #include <vtkm/filter/flow/internal/ParticleAdvector.h>
 
 namespace vtkm
@@ -21,16 +21,18 @@ namespace filter
 namespace flow
 {
 
+namespace
+{
 VTKM_CONT std::vector<vtkm::filter::flow::internal::DataSetIntegratorSteadyState>
-NewFilterParticleAdvectionSteadyState::CreateDataSetIntegrators(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::flow::internal::BoundsMap& boundsMap,
-  const vtkm::filter::flow::FlowResultType& resultType) const
+CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
+                         const std::string& activeField,
+                         const vtkm::filter::flow::internal::BoundsMap& boundsMap,
+                         const vtkm::filter::flow::IntegrationSolverType solverType,
+                         const vtkm::filter::flow::VectorFieldType vecFieldType,
+                         const vtkm::filter::flow::FlowResultType resultType)
 {
   using DSIType = vtkm::filter::flow::internal::DataSetIntegratorSteadyState;
 
-  std::string activeField = this->GetActiveFieldName();
-
   std::vector<DSIType> dsi;
   for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
   {
@@ -39,11 +41,12 @@ NewFilterParticleAdvectionSteadyState::CreateDataSetIntegrators(
     if (!ds.HasPointField(activeField) && !ds.HasCellField(activeField))
       throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-    dsi.emplace_back(ds, blockId, activeField, this->SolverType, this->VecFieldType, resultType);
+    dsi.emplace_back(ds, blockId, activeField, solverType, vecFieldType, resultType);
   }
 
   return dsi;
 }
+} //anonymous namespace
 
 VTKM_CONT vtkm::cont::PartitionedDataSet NewFilterParticleAdvectionSteadyState::DoExecutePartitions(
   const vtkm::cont::PartitionedDataSet& input)
@@ -52,7 +55,12 @@ VTKM_CONT vtkm::cont::PartitionedDataSet NewFilterParticleAdvectionSteadyState::
   this->ValidateOptions();
 
   vtkm::filter::flow::internal::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->GetResultType());
+  auto dsi = CreateDataSetIntegrators(input,
+                                      this->GetActiveFieldName(),
+                                      boundsMap,
+                                      this->SolverType,
+                                      this->VecFieldType,
+                                      this->GetResultType());
 
   vtkm::filter::flow::internal::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->GetResultType());
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
index de9a67f03..ed0731301 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h
@@ -13,9 +13,6 @@
 
 #include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
-#include <vtkm/filter/flow/internal/BoundsMap.h>
-#include <vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h>
-
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
@@ -24,19 +21,9 @@ namespace filter
 {
 namespace flow
 {
-
-// Forward declaration
-class DataSetIntegratorSteadyState;
-
 class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionSteadyState
   : public NewFilterParticleAdvection
 {
-protected:
-  VTKM_CONT std::vector<vtkm::filter::flow::internal::DataSetIntegratorSteadyState>
-  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
-                           const vtkm::filter::flow::internal::BoundsMap& boundsMap,
-                           const vtkm::filter::flow::FlowResultType& resultType) const;
-
 private:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
index 4a053da9e..b2df0b8e4 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx
@@ -8,8 +8,6 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
 #include <vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h>
 #include <vtkm/filter/flow/internal/ParticleAdvector.h>
@@ -20,40 +18,45 @@ namespace filter
 {
 namespace flow
 {
-
+namespace
+{
 VTKM_CONT std::vector<vtkm::filter::flow::internal::DataSetIntegratorUnsteadyState>
-NewFilterParticleAdvectionUnsteadyState::CreateDataSetIntegrators(
-  const vtkm::cont::PartitionedDataSet& input,
-  const vtkm::filter::flow::internal::BoundsMap& boundsMap,
-  const vtkm::filter::flow::FlowResultType& resultType) const
+CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
+                         const vtkm::cont::PartitionedDataSet& input2,
+                         const std::string& activeField,
+                         const vtkm::FloatDefault timer1,
+                         const vtkm::FloatDefault timer2,
+                         const vtkm::filter::flow::internal::BoundsMap& boundsMap,
+                         const vtkm::filter::flow::IntegrationSolverType solverType,
+                         const vtkm::filter::flow::VectorFieldType vecFieldType,
+                         const vtkm::filter::flow::FlowResultType resultType)
 {
   using DSIType = vtkm::filter::flow::internal::DataSetIntegratorUnsteadyState;
 
-  std::string activeField = this->GetActiveFieldName();
-
   std::vector<DSIType> dsi;
   for (vtkm::Id i = 0; i < input.GetNumberOfPartitions(); i++)
   {
     vtkm::Id blockId = boundsMap.GetLocalBlockId(i);
     auto ds1 = input.GetPartition(i);
-    auto ds2 = this->Input2.GetPartition(i);
+    auto ds2 = input2.GetPartition(i);
     if ((!ds1.HasPointField(activeField) && !ds1.HasCellField(activeField)) ||
         (!ds2.HasPointField(activeField) && !ds2.HasCellField(activeField)))
       throw vtkm::cont::ErrorFilterExecution("Unsupported field assocation");
 
-    dsi.emplace_back(ds1,
-                     ds2,
-                     this->Time1,
-                     this->Time2,
-                     blockId,
-                     activeField,
-                     this->SolverType,
-                     this->VecFieldType,
-                     resultType);
+    dsi.emplace_back(
+      ds1, ds2, timer1, timer2, blockId, activeField, solverType, vecFieldType, resultType);
   }
 
   return dsi;
 }
+} // anonymous namespace
+
+VTKM_CONT void NewFilterParticleAdvectionUnsteadyState::ValidateOptions() const
+{
+  this->NewFilterParticleAdvection::ValidateOptions();
+  if (this->Time1 >= this->Time2)
+    throw vtkm::cont::ErrorFilterExecution("PreviousTime must be less than NextTime");
+}
 
 VTKM_CONT vtkm::cont::PartitionedDataSet
 NewFilterParticleAdvectionUnsteadyState::DoExecutePartitions(
@@ -63,7 +66,15 @@ NewFilterParticleAdvectionUnsteadyState::DoExecutePartitions(
   this->ValidateOptions();
 
   vtkm::filter::flow::internal::BoundsMap boundsMap(input);
-  auto dsi = this->CreateDataSetIntegrators(input, boundsMap, this->GetResultType());
+  auto dsi = CreateDataSetIntegrators(input,
+                                      this->Input2,
+                                      this->GetActiveFieldName(),
+                                      this->Time1,
+                                      this->Time2,
+                                      boundsMap,
+                                      this->SolverType,
+                                      this->VecFieldType,
+                                      this->GetResultType());
 
   vtkm::filter::flow::internal::ParticleAdvector<DSIType> pav(
     boundsMap, dsi, this->UseThreadedAlgorithm, this->GetResultType());
diff --git a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
index c404d86f4..d1d959329 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h
@@ -12,9 +12,6 @@
 #define vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
 
 #include <vtkm/filter/flow/NewFilterParticleAdvection.h>
-#include <vtkm/filter/flow/internal/BoundsMap.h>
-#include <vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h>
-
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
@@ -24,9 +21,6 @@ namespace filter
 namespace flow
 {
 
-// Forward declaration
-class DataSetIntegratorUnsteadyState;
-
 class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionUnsteadyState
   : public NewFilterParticleAdvection
 {
@@ -40,17 +34,7 @@ public:
   VTKM_CONT void SetNextDataSet(const vtkm::cont::PartitionedDataSet& pds) { this->Input2 = pds; }
 
 protected:
-  VTKM_CONT virtual void ValidateOptions() const override
-  {
-    this->NewFilterParticleAdvection::ValidateOptions();
-    if (this->Time1 >= this->Time2)
-      throw vtkm::cont::ErrorFilterExecution("PreviousTime must be less than NextTime");
-  }
-
-  VTKM_CONT std::vector<vtkm::filter::flow::internal::DataSetIntegratorUnsteadyState>
-  CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
-                           const vtkm::filter::flow::internal::BoundsMap& boundsMap,
-                           const vtkm::filter::flow::FlowResultType& resultType) const;
+  VTKM_CONT virtual void ValidateOptions() const override;
 
 private:
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
diff --git a/vtkm/filter/flow/PathParticle.cxx b/vtkm/filter/flow/PathParticle.cxx
index e288dca11..f6c0f63a1 100644
--- a/vtkm/filter/flow/PathParticle.cxx
+++ b/vtkm/filter/flow/PathParticle.cxx
@@ -8,8 +8,6 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/PathParticle.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/Pathline.cxx b/vtkm/filter/flow/Pathline.cxx
index de5b74cc9..ada93727f 100644
--- a/vtkm/filter/flow/Pathline.cxx
+++ b/vtkm/filter/flow/Pathline.cxx
@@ -8,8 +8,6 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/Pathline.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/StreamSurface.cxx b/vtkm/filter/flow/StreamSurface.cxx
index 7a5c52039..d2ae9a426 100644
--- a/vtkm/filter/flow/StreamSurface.cxx
+++ b/vtkm/filter/flow/StreamSurface.cxx
@@ -8,14 +8,12 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/filter/flow/StreamSurface.h>
 #include <vtkm/filter/flow/worklet/Field.h>
 #include <vtkm/filter/flow/worklet/GridEvaluators.h>
 #include <vtkm/filter/flow/worklet/ParticleAdvection.h>
-#include <vtkm/filter/flow/worklet/Particles.h>
 #include <vtkm/filter/flow/worklet/RK4Integrator.h>
 #include <vtkm/filter/flow/worklet/Stepper.h>
 #include <vtkm/filter/flow/worklet/StreamSurface.h>
diff --git a/vtkm/filter/flow/StreamSurface.h b/vtkm/filter/flow/StreamSurface.h
index 546fa0a06..b3c77cd75 100644
--- a/vtkm/filter/flow/StreamSurface.h
+++ b/vtkm/filter/flow/StreamSurface.h
@@ -11,7 +11,6 @@
 #ifndef vtk_m_filter_flow_StreamSurface_h
 #define vtk_m_filter_flow_StreamSurface_h
 
-#include <vtkm/Particle.h>
 #include <vtkm/filter/flow/FlowTypes.h>
 #include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
diff --git a/vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h b/vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h
index fc4d0cc00..3c299533a 100644
--- a/vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h
+++ b/vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h
@@ -11,6 +11,7 @@
 #ifndef vtk_m_filter_flow_internal_DataSetIntegratorSteadyState_h
 #define vtk_m_filter_flow_internal_DataSetIntegratorSteadyState_h
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/internal/DataSetIntegrator.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h b/vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h
index dddc64f1f..6feafe539 100644
--- a/vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h
+++ b/vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h
@@ -11,6 +11,7 @@
 #ifndef vtk_m_filter_flow_internal_DataSetIntegratorUnsteadyState_h
 #define vtk_m_filter_flow_internal_DataSetIntegratorUnsteadyState_h
 
+#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/internal/DataSetIntegrator.h>
 #include <vtkm/filter/flow/worklet/TemporalGridEvaluators.h>
 
diff --git a/vtkm/filter/flow/testing/CMakeLists.txt b/vtkm/filter/flow/testing/CMakeLists.txt
index 7a119c0ac..858aed60a 100644
--- a/vtkm/filter/flow/testing/CMakeLists.txt
+++ b/vtkm/filter/flow/testing/CMakeLists.txt
@@ -8,21 +8,34 @@
 ##  PURPOSE.  See the above copyright notice for more information.
 ##============================================================================
 
-set(unit_tests
+set(filter_unit_tests
   UnitTestStreamlineFilter.cxx
   UnitTestStreamSurfaceFilter.cxx
+  )
+set(worklet_unit_tests
   UnitTestWorkletParticleAdvection.cxx
   UnitTestWorkletTemporalAdvection.cxx
   UnitTestStreamSurfaceWorklet.cxx
   )
 
 set(libraries
+  vtkm_filter_mesh_info
   vtkm_filter_flow
+  vtkm_io
   )
 
+if (VTKm_ENABLE_RENDERING)
+  list(APPEND libraries vtkm_filter_geometry_refinement vtkm_rendering vtkm_rendering_testing)
+
+  list(APPEND filter_unit_tests
+    RenderTestStreamline.cxx
+    )
+endif()
+
 vtkm_unit_tests(
-  DEVICE_SOURCES ${unit_tests}
-  LIBRARIES ${libraries} vtkm_filter vtkm_io
+  SOURCES ${filter_unit_tests}
+  DEVICE_SOURCES ${worklet_unit_tests}
+  LIBRARIES ${libraries}
   USE_VTKM_JOB_POOL
 )
 
@@ -35,7 +48,7 @@ if (VTKm_ENABLE_MPI)
   )
   vtkm_unit_tests(
     MPI DEVICE_SOURCES ${mpi_unit_tests}
-    LIBRARIES vtkm_filter vtkm_source vtkm_io
+    LIBRARIES ${libraries}
     ALL_BACKENDS
     USE_VTKM_JOB_POOL
   )
diff --git a/vtkm/filter/flow/testing/RenderTestStreamline.cxx b/vtkm/filter/flow/testing/RenderTestStreamline.cxx
new file mode 100644
index 000000000..92ea31028
--- /dev/null
+++ b/vtkm/filter/flow/testing/RenderTestStreamline.cxx
@@ -0,0 +1,74 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#include <vtkm/Math.h>
+#include <vtkm/Particle.h>
+#include <vtkm/cont/ArrayHandleConstant.h>
+#include <vtkm/cont/DataSet.h>
+#include <vtkm/cont/testing/Testing.h>
+#include <vtkm/io/VTKDataSetReader.h>
+
+#include <vtkm/filter/flow/Streamline.h>
+#include <vtkm/filter/geometry_refinement/Tube.h>
+
+#include <vtkm/rendering/testing/RenderTest.h>
+#include <vtkm/rendering/testing/Testing.h>
+
+namespace
+{
+void TestStreamline()
+{
+  std::cout << "Generate Image for Streamline filter" << std::endl;
+
+  auto pathname = vtkm::cont::testing::Testing::DataPath("uniform/StreamlineTestDataSet.vtk");
+  vtkm::io::VTKDataSetReader reader(pathname);
+  vtkm::cont::DataSet dataSet = reader.ReadDataSet();
+  vtkm::cont::ArrayHandle<vtkm::Particle> seedArray =
+    vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
+                                   vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
+                                   vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
+
+  vtkm::filter::flow::Streamline streamline;
+  streamline.SetStepSize(0.1f);
+  streamline.SetNumberOfSteps(20);
+  streamline.SetSeeds(seedArray);
+  streamline.SetActiveField("vector");
+  auto result = streamline.Execute(dataSet);
+
+  // Some sort of color map is needed when rendering the coordinates of a dataset
+  // so create a zeroed array for the coordinates.
+  std::vector<vtkm::FloatDefault> colorMap(static_cast<std::vector<vtkm::FloatDefault>::size_type>(
+    result.GetCoordinateSystem().GetNumberOfPoints()));
+  for (std::vector<vtkm::FloatDefault>::size_type i = 0; i < colorMap.size(); i++)
+  {
+    colorMap[i] = static_cast<vtkm::FloatDefault>(i);
+  }
+  result.AddPointField("pointvar", colorMap);
+
+  // The streamline by itself doesn't generate renderable geometry, so surround the
+  // streamlines in tubes.
+  vtkm::filter::geometry_refinement::Tube tube;
+  tube.SetCapping(true);
+  tube.SetNumberOfSides(3);
+  tube.SetRadius(static_cast<vtkm::FloatDefault>(0.2));
+  result = tube.Execute(result);
+  result.PrintSummary(std::cout);
+
+  vtkm::rendering::testing::RenderTestOptions testOptions;
+  testOptions.ColorTable = vtkm::cont::ColorTable::Preset::Inferno;
+  testOptions.EnableAnnotations = false;
+  vtkm::rendering::testing::RenderTest(result, "pointvar", "filter/streamline.png", testOptions);
+}
+} // namespace
+
+int RenderTestStreamline(int argc, char* argv[])
+{
+  return vtkm::cont::testing::Testing::Run(TestStreamline, argc, argv);
+}
diff --git a/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx b/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
index 4c7fffae1..505f84ff5 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamSurfaceFilter.cxx
@@ -8,8 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
+#include <vtkm/Particle.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/flow/StreamSurface.h>
diff --git a/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
index 5e6f8a819..0927a6150 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamlineFilter.cxx
@@ -9,7 +9,7 @@
 //============================================================================
 
 #include <vtkm/CellClassification.h>
-#include <vtkm/cont/Algorithm.h>
+#include <vtkm/Particle.h>
 #include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/cont/DataSetBuilderUniform.h>
 #include <vtkm/cont/testing/Testing.h>
@@ -18,7 +18,6 @@
 #include <vtkm/filter/flow/Pathline.h>
 #include <vtkm/filter/flow/Streamline.h>
 #include <vtkm/io/VTKDataSetReader.h>
-#include <vtkm/io/VTKDataSetWriter.h>
 #include <vtkm/worklet/testing/GenerateTestDataSets.h>
 
 namespace
diff --git a/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
index bd42b74e9..ba8b027a7 100644
--- a/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
+++ b/vtkm/filter/flow/testing/UnitTestStreamlineFilterMPI.cxx
@@ -9,8 +9,7 @@
 //============================================================================
 
 #include <vtkm/CellClassification.h>
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
+#include <vtkm/Particle.h>
 #include <vtkm/cont/testing/Testing.h>
 #include <vtkm/filter/flow/ParticleAdvection.h>
 #include <vtkm/filter/flow/Pathline.h>
diff --git a/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h b/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
index 4885dffcd..af3d5a730 100644
--- a/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
+++ b/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
@@ -11,6 +11,7 @@
 #ifndef vtk_m_filter_flow_worklet_ParticleAdvectionWorklets_h
 #define vtk_m_filter_flow_worklet_ParticleAdvectionWorklets_h
 
+#include <vtkm/cont/Algorithm.h>
 #include <vtkm/cont/CellSetExplicit.h>
 #include <vtkm/cont/ConvertNumComponentsToOffsets.h>
 #include <vtkm/cont/ExecutionObjectBase.h>
diff --git a/vtkm/filter/testing/CMakeLists.txt b/vtkm/filter/testing/CMakeLists.txt
index 942cc31ec..b9995d3c0 100644
--- a/vtkm/filter/testing/CMakeLists.txt
+++ b/vtkm/filter/testing/CMakeLists.txt
@@ -25,14 +25,6 @@ set(libraries
   vtkm_source
 )
 
-if (VTKm_ENABLE_RENDERING)
-  list(APPEND libraries vtkm_rendering vtkm_rendering_testing)
-
-  list(APPEND unit_tests
-    RenderTestStreamline.cxx
-  )
-endif()
-
 vtkm_unit_tests(
   DEVICE_SOURCES ${unit_tests}
   LIBRARIES ${libraries}

From 2524c16a0c8f6c82de7ef6cda61ad272c977839e Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 1 Aug 2022 09:55:38 -0400
Subject: [PATCH 090/104] Missed some cuda fixes filters...

---
 vtkm/filter/flow/ParticleAdvection.cxx | 2 --
 vtkm/filter/flow/Streamline.cxx        | 2 --
 2 files changed, 4 deletions(-)

diff --git a/vtkm/filter/flow/ParticleAdvection.cxx b/vtkm/filter/flow/ParticleAdvection.cxx
index 71ca9259e..d833b2289 100644
--- a/vtkm/filter/flow/ParticleAdvection.cxx
+++ b/vtkm/filter/flow/ParticleAdvection.cxx
@@ -8,8 +8,6 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/ParticleAdvection.h>
 
 namespace vtkm
diff --git a/vtkm/filter/flow/Streamline.cxx b/vtkm/filter/flow/Streamline.cxx
index d33b7b620..d5789f197 100644
--- a/vtkm/filter/flow/Streamline.cxx
+++ b/vtkm/filter/flow/Streamline.cxx
@@ -8,8 +8,6 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
-#include <vtkm/cont/Algorithm.h>
-#include <vtkm/cont/ArrayCopy.h>
 #include <vtkm/filter/flow/Streamline.h>
 
 namespace vtkm

From 42fd70d50ff5b895b79ccf2ddf1c553ec51b4693 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 1 Aug 2022 10:59:32 -0400
Subject: [PATCH 091/104] Remove virtuals from DataSetIntegrator classes.

---
 vtkm/filter/flow/internal/AdvectAlgorithm.h   |  2 +-
 vtkm/filter/flow/internal/DataSetIntegrator.h | 31 ++++++-------
 .../internal/DataSetIntegratorSteadyState.h   | 17 +++----
 .../internal/DataSetIntegratorUnsteadyState.h | 45 ++++++++++---------
 4 files changed, 47 insertions(+), 48 deletions(-)

diff --git a/vtkm/filter/flow/internal/AdvectAlgorithm.h b/vtkm/filter/flow/internal/AdvectAlgorithm.h
index bce021733..33d38d4b5 100644
--- a/vtkm/filter/flow/internal/AdvectAlgorithm.h
+++ b/vtkm/filter/flow/internal/AdvectAlgorithm.h
@@ -137,7 +137,7 @@ public:
     this->TotalNumParticles = static_cast<vtkm::Id>(total);
   }
 
-  DataSetIntegrator& GetDataSet(vtkm::Id id)
+  DataSetIntegrator<DSIType>& GetDataSet(vtkm::Id id)
   {
     for (auto& it : this->Blocks)
       if (it.GetID() == id)
diff --git a/vtkm/filter/flow/internal/DataSetIntegrator.h b/vtkm/filter/flow/internal/DataSetIntegrator.h
index 270bba091..5477bed53 100644
--- a/vtkm/filter/flow/internal/DataSetIntegrator.h
+++ b/vtkm/filter/flow/internal/DataSetIntegrator.h
@@ -57,6 +57,7 @@ public:
 using DSIHelperInfoType = vtkm::cont::internal::Variant<DSIHelperInfo<vtkm::Particle>,
                                                         DSIHelperInfo<vtkm::ChargedParticle>>;
 
+template <typename Derived>
 class DataSetIntegrator
 {
 protected:
@@ -87,8 +88,6 @@ public:
     //check that things are valid.
   }
 
-  virtual ~DataSetIntegrator() {}
-
   VTKM_CONT vtkm::Id GetID() const { return this->Id; }
   VTKM_CONT void SetCopySeedFlag(bool val) { this->CopySeedArray = val; }
 
@@ -97,8 +96,10 @@ public:
               vtkm::FloatDefault stepSize, //move these to member data(?)
               vtkm::Id maxSteps)
   {
+    Derived* inst = static_cast<Derived*>(this);
+
     //Cast the DSIHelperInfo<ParticleType> to the concrete type and call DoAdvect.
-    b.CastAndCall([&](auto& concrete) { this->DoAdvect(concrete, stepSize, maxSteps); });
+    b.CastAndCall([&](auto& concrete) { inst->DoAdvect(concrete, stepSize, maxSteps); });
   }
 
   template <typename ParticleType>
@@ -120,17 +121,9 @@ protected:
     return this->AdvectionResType == FlowResultType::STREAMLINE_TYPE;
   }
 
-  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) = 0;
-
-  VTKM_CONT virtual void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
-                                  vtkm::FloatDefault stepSize,
-                                  vtkm::Id maxSteps) = 0;
-
   template <typename ParticleType>
-  VTKM_CONT void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
-                                   DSIHelperInfo<ParticleType>& dsiInfo) const;
+  VTKM_CONT inline void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
+                                          DSIHelperInfo<ParticleType>& dsiInfo) const;
 
   //Data members.
   vtkm::cont::internal::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType> FieldName;
@@ -147,8 +140,9 @@ protected:
   std::vector<RType> Results;
 };
 
+template <typename Derived>
 template <typename ParticleType>
-VTKM_CONT void DataSetIntegrator::ClassifyParticles(
+VTKM_CONT inline void DataSetIntegrator<Derived>::ClassifyParticles(
   const vtkm::cont::ArrayHandle<ParticleType>& particles,
   DSIHelperInfo<ParticleType>& dsiInfo) const
 {
@@ -233,9 +227,11 @@ VTKM_CONT void DataSetIntegrator::ClassifyParticles(
   VTKM_ASSERT(dsiInfo.TermIdx.size() == dsiInfo.TermID.size());
 }
 
+template <typename Derived>
 template <typename ParticleType, template <typename> class ResultType>
-VTKM_CONT void DataSetIntegrator::UpdateResult(const ResultType<ParticleType>& result,
-                                               DSIHelperInfo<ParticleType>& dsiInfo)
+VTKM_CONT inline void DataSetIntegrator<Derived>::UpdateResult(
+  const ResultType<ParticleType>& result,
+  DSIHelperInfo<ParticleType>& dsiInfo)
 {
   this->ClassifyParticles(result.Particles, dsiInfo);
 
@@ -258,8 +254,9 @@ VTKM_CONT void DataSetIntegrator::UpdateResult(const ResultType<ParticleType>& r
     this->Results.emplace_back(result);
 }
 
+template <typename Derived>
 template <typename ParticleType>
-VTKM_CONT bool DataSetIntegrator::GetOutput(vtkm::cont::DataSet& ds) const
+VTKM_CONT inline bool DataSetIntegrator<Derived>::GetOutput(vtkm::cont::DataSet& ds) const
 {
   std::size_t nResults = this->Results.size();
   if (nResults == 0)
diff --git a/vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h b/vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h
index 3c299533a..6e4bd5712 100644
--- a/vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h
+++ b/vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h
@@ -23,7 +23,8 @@ namespace flow
 namespace internal
 {
 
-class DataSetIntegratorSteadyState : public vtkm::filter::flow::internal::DataSetIntegrator
+class DataSetIntegratorSteadyState
+  : public vtkm::filter::flow::internal::DataSetIntegrator<DataSetIntegratorSteadyState>
 {
 public:
   DataSetIntegratorSteadyState(const vtkm::cont::DataSet& ds,
@@ -32,22 +33,22 @@ public:
                                vtkm::filter::flow::IntegrationSolverType solverType,
                                vtkm::filter::flow::VectorFieldType vecFieldType,
                                vtkm::filter::flow::FlowResultType resultType)
-    : vtkm::filter::flow::internal::DataSetIntegrator(id,
-                                                      fieldName,
-                                                      solverType,
-                                                      vecFieldType,
-                                                      resultType)
+    : vtkm::filter::flow::internal::DataSetIntegrator<DataSetIntegratorSteadyState>(id,
+                                                                                    fieldName,
+                                                                                    solverType,
+                                                                                    vecFieldType,
+                                                                                    resultType)
     , DataSet(ds)
   {
   }
 
   VTKM_CONT inline void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
                                  vtkm::FloatDefault stepSize,
-                                 vtkm::Id maxSteps) override;
+                                 vtkm::Id maxSteps);
 
   VTKM_CONT inline void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
                                  vtkm::FloatDefault stepSize,
-                                 vtkm::Id maxSteps) override;
+                                 vtkm::Id maxSteps);
 
 protected:
   template <typename ArrayType>
diff --git a/vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h b/vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h
index 6feafe539..de4a9d540 100644
--- a/vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h
+++ b/vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h
@@ -24,24 +24,25 @@ namespace flow
 namespace internal
 {
 
-class DataSetIntegratorUnsteadyState : public vtkm::filter::flow::internal::DataSetIntegrator
+class DataSetIntegratorUnsteadyState
+  : public vtkm::filter::flow::internal::DataSetIntegrator<DataSetIntegratorUnsteadyState>
 {
 public:
-  DataSetIntegratorUnsteadyState(
-    const vtkm::cont::DataSet& ds1,
-    const vtkm::cont::DataSet& ds2,
-    vtkm::FloatDefault t1,
-    vtkm::FloatDefault t2,
-    vtkm::Id id,
-    const vtkm::filter::flow::internal::DataSetIntegrator::FieldNameType& fieldName,
-    vtkm::filter::flow::IntegrationSolverType solverType,
-    vtkm::filter::flow::VectorFieldType vecFieldType,
-    vtkm::filter::flow::FlowResultType resultType)
-    : vtkm::filter::flow::internal::DataSetIntegrator(id,
-                                                      fieldName,
-                                                      solverType,
-                                                      vecFieldType,
-                                                      resultType)
+  DataSetIntegratorUnsteadyState(const vtkm::cont::DataSet& ds1,
+                                 const vtkm::cont::DataSet& ds2,
+                                 vtkm::FloatDefault t1,
+                                 vtkm::FloatDefault t2,
+                                 vtkm::Id id,
+                                 const vtkm::filter::flow::internal::DataSetIntegrator<
+                                   DataSetIntegratorUnsteadyState>::FieldNameType& fieldName,
+                                 vtkm::filter::flow::IntegrationSolverType solverType,
+                                 vtkm::filter::flow::VectorFieldType vecFieldType,
+                                 vtkm::filter::flow::FlowResultType resultType)
+    : vtkm::filter::flow::internal::DataSetIntegrator<DataSetIntegratorUnsteadyState>(id,
+                                                                                      fieldName,
+                                                                                      solverType,
+                                                                                      vecFieldType,
+                                                                                      resultType)
     , DataSet1(ds1)
     , DataSet2(ds2)
     , Time1(t1)
@@ -49,13 +50,13 @@ public:
   {
   }
 
-  VTKM_CONT virtual inline void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
-                                         vtkm::FloatDefault stepSize,
-                                         vtkm::Id maxSteps) override;
+  VTKM_CONT inline void DoAdvect(DSIHelperInfo<vtkm::Particle>& b,
+                                 vtkm::FloatDefault stepSize,
+                                 vtkm::Id maxSteps);
 
-  VTKM_CONT virtual inline void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
-                                         vtkm::FloatDefault stepSize,
-                                         vtkm::Id maxSteps) override;
+  VTKM_CONT inline void DoAdvect(DSIHelperInfo<vtkm::ChargedParticle>& b,
+                                 vtkm::FloatDefault stepSize,
+                                 vtkm::Id maxSteps);
 
 protected:
   template <typename ArrayType>

From 061fe6afbb753813cfabebec2f14257d50328512 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 1 Aug 2022 11:10:25 -0400
Subject: [PATCH 092/104] Fix dashboard compile errors.

---
 vtkm/filter/flow/internal/DataSetIntegrator.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/vtkm/filter/flow/internal/DataSetIntegrator.h b/vtkm/filter/flow/internal/DataSetIntegrator.h
index 5477bed53..b3974cda7 100644
--- a/vtkm/filter/flow/internal/DataSetIntegrator.h
+++ b/vtkm/filter/flow/internal/DataSetIntegrator.h
@@ -269,7 +269,7 @@ VTKM_CONT inline bool DataSetIntegrator<Derived>::GetOutput(vtkm::cont::DataSet&
     std::vector<vtkm::cont::ArrayHandle<ParticleType>> allParticles;
     allParticles.reserve(nResults);
     for (const auto& vres : this->Results)
-      allParticles.emplace_back(vres.Get<ResType>().Particles);
+      allParticles.emplace_back(vres.template Get<ResType>().Particles);
 
     vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
     vtkm::cont::ParticleArrayCopy(allParticles, pts);
@@ -296,7 +296,7 @@ VTKM_CONT inline bool DataSetIntegrator<Derived>::GetOutput(vtkm::cont::DataSet&
     //Easy case with one result.
     if (nResults == 1)
     {
-      const auto& res = this->Results[0].Get<ResType>();
+      const auto& res = this->Results[0].template Get<ResType>();
       ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", res.Positions));
       ds.SetCellSet(res.PolyLines);
     }
@@ -306,7 +306,7 @@ VTKM_CONT inline bool DataSetIntegrator<Derived>::GetOutput(vtkm::cont::DataSet&
       vtkm::Id totalNumCells = 0, totalNumPts = 0;
       for (std::size_t i = 0; i < nResults; i++)
       {
-        const auto& res = this->Results[i].Get<ResType>();
+        const auto& res = this->Results[i].template Get<ResType>();
         if (i == 0)
           posOffsets[i] = 0;
         else
@@ -321,7 +321,7 @@ VTKM_CONT inline bool DataSetIntegrator<Derived>::GetOutput(vtkm::cont::DataSet&
       appendPts.Allocate(totalNumPts);
       for (std::size_t i = 0; i < nResults; i++)
       {
-        const auto& res = this->Results[i].Get<ResType>();
+        const auto& res = this->Results[i].template Get<ResType>();
         // copy all values into appendPts starting at offset.
         vtkm::cont::Algorithm::CopySubRange(
           res.Positions, 0, res.Positions.GetNumberOfValues(), appendPts, posOffsets[i]);
@@ -333,7 +333,7 @@ VTKM_CONT inline bool DataSetIntegrator<Derived>::GetOutput(vtkm::cont::DataSet&
       std::size_t off = 0;
       for (std::size_t i = 0; i < nResults; i++)
       {
-        const auto& res = this->Results[i].Get<ResType>();
+        const auto& res = this->Results[i].template Get<ResType>();
         vtkm::Id nCells = res.PolyLines.GetNumberOfCells();
         for (vtkm::Id j = 0; j < nCells; j++)
           numPtsPerCell[off++] = static_cast<vtkm::Id>(res.PolyLines.GetNumberOfPointsInCell(j));

From 5ffae611157701bdd95999ff8043245936103687 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 1 Aug 2022 13:43:28 -0400
Subject: [PATCH 093/104] Use CastAndCallForTypes with UnknownArray of seeds.

---
 vtkm/filter/flow/internal/ParticleAdvector.h | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/vtkm/filter/flow/internal/ParticleAdvector.h b/vtkm/filter/flow/internal/ParticleAdvector.h
index 02595d557..919d460d1 100644
--- a/vtkm/filter/flow/internal/ParticleAdvector.h
+++ b/vtkm/filter/flow/internal/ParticleAdvector.h
@@ -44,15 +44,15 @@ public:
                                          vtkm::FloatDefault stepSize,
                                          const vtkm::cont::UnknownArrayHandle& seeds)
   {
-    using ParticleArray = vtkm::cont::ArrayHandle<vtkm::Particle>;
-    using ChargedParticleArray = vtkm::cont::ArrayHandle<vtkm::ChargedParticle>;
+    using ParticleTypeList = vtkm::List<vtkm::Particle, vtkm::ChargedParticle>;
 
-    if (seeds.IsBaseComponentType<vtkm::Particle>())
-      return this->Execute(numSteps, stepSize, seeds.AsArrayHandle<ParticleArray>());
-    else if (seeds.IsBaseComponentType<vtkm::ChargedParticle>())
-      return this->Execute(numSteps, stepSize, seeds.AsArrayHandle<ChargedParticleArray>());
+    vtkm::cont::PartitionedDataSet result;
+    seeds.CastAndCallForTypes<ParticleTypeList, VTKM_DEFAULT_STORAGE_LIST>(
+      [&](const auto& concreteSeeds) {
+        result = this->Execute(numSteps, stepSize, concreteSeeds);
+      });
 
-    throw vtkm::cont::ErrorFilterExecution("Unsupported options in AdvectAlgorithm");
+    return result;
   }
 
 private:

From 898a3e09278b2cf25c330c3793e443cf0deb7926 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Mon, 1 Aug 2022 14:58:55 -0400
Subject: [PATCH 094/104] Move StreamSurface into NewFilterField

---
 vtkm/filter/flow/StreamSurface.cxx | 17 +++++++++++++++-
 vtkm/filter/flow/StreamSurface.h   | 31 ++++++++++++++++++++++++++----
 2 files changed, 43 insertions(+), 5 deletions(-)

diff --git a/vtkm/filter/flow/StreamSurface.cxx b/vtkm/filter/flow/StreamSurface.cxx
index d2ae9a426..23fec8b93 100644
--- a/vtkm/filter/flow/StreamSurface.cxx
+++ b/vtkm/filter/flow/StreamSurface.cxx
@@ -27,7 +27,22 @@ namespace flow
 
 VTKM_CONT vtkm::cont::DataSet StreamSurface::DoExecute(const vtkm::cont::DataSet& input)
 {
-  this->ValidateOptions();
+  //Validate inputs.
+  if (this->GetUseCoordinateSystemAsField())
+    throw vtkm::cont::ErrorFilterExecution("Coordinate system as field not supported");
+  if (this->Seeds.GetNumberOfValues() == 0)
+    throw vtkm::cont::ErrorFilterExecution("No seeds provided.");
+  if (!this->Seeds.IsBaseComponentType<vtkm::Particle>() &&
+      this->Seeds.IsBaseComponentType<vtkm::ChargedParticle>())
+    throw vtkm::cont::ErrorFilterExecution("Unsupported particle type in seed array.");
+  if (this->NumberOfSteps == 0)
+    throw vtkm::cont::ErrorFilterExecution("Number of steps not specified.");
+  if (this->StepSize == 0)
+    throw vtkm::cont::ErrorFilterExecution("Step size not specified.");
+  if (this->NumberOfSteps < 0)
+    throw vtkm::cont::ErrorFilterExecution("NumberOfSteps cannot be negative");
+  if (this->StepSize < 0)
+    throw vtkm::cont::ErrorFilterExecution("StepSize cannot be negative");
 
   if (!this->Seeds.IsBaseComponentType<vtkm::Particle>())
     throw vtkm::cont::ErrorFilterExecution("Unsupported seed type in StreamSurface filter.");
diff --git a/vtkm/filter/flow/StreamSurface.h b/vtkm/filter/flow/StreamSurface.h
index b3c77cd75..b1c56a37b 100644
--- a/vtkm/filter/flow/StreamSurface.h
+++ b/vtkm/filter/flow/StreamSurface.h
@@ -11,8 +11,8 @@
 #ifndef vtk_m_filter_flow_StreamSurface_h
 #define vtk_m_filter_flow_StreamSurface_h
 
+#include <vtkm/filter/NewFilterField.h>
 #include <vtkm/filter/flow/FlowTypes.h>
-#include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
 #include <vtkm/filter/flow/vtkm_filter_flow_export.h>
 
 namespace vtkm
@@ -27,11 +27,34 @@ namespace flow
 /// Takes as input a vector field and seed locations and generates the
 /// paths taken by the seeds through the vector field.
 
-class VTKM_FILTER_FLOW_EXPORT StreamSurface
-  : public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
+class VTKM_FILTER_FLOW_EXPORT StreamSurface : public vtkm::filter::NewFilterField
 {
-protected:
+public:
+  VTKM_CONT
+  void SetStepSize(vtkm::FloatDefault s) { this->StepSize = s; }
+
+  VTKM_CONT
+  void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; }
+
+  template <typename ParticleType>
+  VTKM_CONT void SetSeeds(vtkm::cont::ArrayHandle<ParticleType>& seeds)
+  {
+    this->Seeds = seeds;
+  }
+
+  template <typename ParticleType>
+  VTKM_CONT void SetSeeds(const std::vector<ParticleType>& seeds,
+                          vtkm::CopyFlag copyFlag = vtkm::CopyFlag::On)
+  {
+    this->Seeds = vtkm::cont::make_ArrayHandle(seeds, copyFlag);
+  }
+
+private:
   VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
+
+  vtkm::Id NumberOfSteps = 0;
+  vtkm::cont::UnknownArrayHandle Seeds;
+  vtkm::FloatDefault StepSize = 0;
 };
 
 }

From cd3fe3d47d7a238cc07604fa6fe91454eb8addd8 Mon Sep 17 00:00:00 2001
From: "Gunther H. Weber" <GHWeber@lbl.gov>
Date: Wed, 13 Jul 2022 11:27:56 -0700
Subject: [PATCH 095/104] Eliminate need for SpatialDecomposition in contour
 tree filters.

This commit address issue #713 and removes the need to pass information
about the spatial decomposition (block origins, block sizes, block index
and blocks per dimension) to the contour tree filter. Block origin
information is added to CellSetStructured (as GlobalPointSize) and the
distributed contour tree filter will get this information from
CellSetStructured instead of expecting it as parameters to the
constructor. Information about blocks per dimension and block indices
are computed from the information in CellSetStructure albeit requiring
global communication across all ranks. To avoid this communication cost,
the caller of the filter may explicitly specify this information via the
SetBlockIndices() method.
---
 .../contour_tree_augmented/ContourTreeApp.cxx |  38 ++-
 .../ContourTreeApp.cxx                        |  60 ++---
 vtkm/cont/CellSetStructured.h                 |  20 +-
 vtkm/cont/PartitionedDataSet.cxx              |  20 ++
 vtkm/cont/PartitionedDataSet.h                |  28 +-
 vtkm/filter/scalar_topology/CMakeLists.txt    |   1 +
 .../ContourTreeUniformAugmented.cxx           | 117 ++++----
 .../ContourTreeUniformAugmented.h             |  21 +-
 .../ContourTreeUniformDistributed.cxx         | 234 ++++++++++------
 .../ContourTreeUniformDistributed.h           |  52 ++--
 .../DistributedBranchDecompositionFilter.cxx  |  83 +++---
 .../DistributedBranchDecompositionFilter.h    |  17 +-
 .../scalar_topology/internal/CMakeLists.txt   |   2 +-
 .../internal/ComputeBlockIndices.cxx          | 255 ++++++++++++++++++
 .../internal/ComputeBlockIndices.h            |  98 +++++++
 .../internal/SpatialDecomposition.h           | 172 ------------
 ...stingContourTreeUniformDistributedFilter.h |  49 ++--
 ...estContourTreeUniformDistributedFilter.cxx |  10 +
 .../worklet/contourtree_augmented/Types.h     |  41 +++
 .../MultiBlockContourTreeHelper.h             |  49 ++--
 .../ConnectivityStructuredInternals.h         |  52 +++-
 .../UnitTestContourTreeUniformDistributed.cxx |  32 +--
 22 files changed, 913 insertions(+), 538 deletions(-)
 create mode 100644 vtkm/filter/scalar_topology/internal/ComputeBlockIndices.cxx
 create mode 100644 vtkm/filter/scalar_topology/internal/ComputeBlockIndices.h
 delete mode 100644 vtkm/filter/scalar_topology/internal/SpatialDecomposition.h

diff --git a/examples/contour_tree_augmented/ContourTreeApp.cxx b/examples/contour_tree_augmented/ContourTreeApp.cxx
index 96aca16a8..2ac66b8a1 100644
--- a/examples/contour_tree_augmented/ContourTreeApp.cxx
+++ b/examples/contour_tree_augmented/ContourTreeApp.cxx
@@ -548,14 +548,8 @@ int main(int argc, char* argv[])
                                                 static_cast<vtkm::Id>(dims[1]),
                                                 static_cast<vtkm::Id>(0));
   vtkm::cont::ArrayHandle<vtkm::Id3> localBlockIndices;
-  vtkm::cont::ArrayHandle<vtkm::Id3> localBlockOrigins;
-  vtkm::cont::ArrayHandle<vtkm::Id3> localBlockSizes;
   localBlockIndices.Allocate(blocksPerRank);
-  localBlockOrigins.Allocate(blocksPerRank);
-  localBlockSizes.Allocate(blocksPerRank);
   auto localBlockIndicesPortal = localBlockIndices.WritePortal();
-  auto localBlockOriginsPortal = localBlockOrigins.WritePortal();
-  auto localBlockSizesPortal = localBlockSizes.WritePortal();
 
   {
     vtkm::Id lastDimSize =
@@ -604,30 +598,29 @@ int main(int argc, char* argv[])
         vtkm::Vec<ValueType, 2> origin(0, blockIndex * blockSize);
         vtkm::Vec<ValueType, 2> spacing(1, 1);
         ds = dsb.Create(vdims, origin, spacing);
+        vtkm::cont::CellSetStructured<2> cs;
+        cs.SetPointDimensions(vdims);
+        cs.SetGlobalPointDimensions(vtkm::Id2{ globalSize[0], globalSize[1] });
+        cs.SetGlobalPointIndexStart(vtkm::Id2{ 0, blockIndex * blockSize });
+        ds.SetCellSet(cs);
 
-        localBlockIndicesPortal.Set(localBlockIndex, vtkm::Id3(blockIndex, 0, 0));
-        localBlockOriginsPortal.Set(localBlockIndex,
-                                    vtkm::Id3((blockStart / blockSliceSize), 0, 0));
-        localBlockSizesPortal.Set(localBlockIndex,
-                                  vtkm::Id3(currBlockSize, static_cast<vtkm::Id>(dims[0]), 0));
+        localBlockIndicesPortal.Set(localBlockIndex, vtkm::Id3(0, blockIndex, 0));
       }
       // 3D data
       else
       {
         vtkm::Id3 vdims;
-        vdims[0] = static_cast<vtkm::Id>(dims[1]);
-        vdims[1] = static_cast<vtkm::Id>(dims[0]);
+        vdims[0] = static_cast<vtkm::Id>(dims[0]);
+        vdims[1] = static_cast<vtkm::Id>(dims[1]);
         vdims[2] = static_cast<vtkm::Id>(currBlockSize);
-        vtkm::Vec<ValueType, 3> origin(0, 0, (blockIndex * blockSize));
+        vtkm::Vec<ValueType, 3> origin(0, 0, blockIndex * blockSize);
         vtkm::Vec<ValueType, 3> spacing(1, 1, 1);
         ds = dsb.Create(vdims, origin, spacing);
-
-        localBlockIndicesPortal.Set(localBlockIndex, vtkm::Id3(0, 0, blockIndex));
-        localBlockOriginsPortal.Set(localBlockIndex,
-                                    vtkm::Id3(0, 0, (blockStart / blockSliceSize)));
-        localBlockSizesPortal.Set(
-          localBlockIndex,
-          vtkm::Id3(static_cast<vtkm::Id>(dims[0]), static_cast<vtkm::Id>(dims[1]), currBlockSize));
+        vtkm::cont::CellSetStructured<3> cs;
+        cs.SetPointDimensions(vdims);
+        cs.SetGlobalPointDimensions(globalSize);
+        cs.SetGlobalPointIndexStart(vtkm::Id3{ 0, 0, blockIndex * blockSize });
+        ds.SetCellSet(cs);
       }
 
       std::vector<vtkm::Float32> subValues((values.begin() + blockStart),
@@ -648,8 +641,7 @@ int main(int argc, char* argv[])
                                                              computeRegularStructure);
 
 #ifdef WITH_MPI
-  filter.SetSpatialDecomposition(
-    blocksPerDim, globalSize, localBlockIndices, localBlockOrigins, localBlockSizes);
+  filter.SetBlockIndices(blocksPerDim, localBlockIndices);
 #endif
   filter.SetActiveField("values");
 
diff --git a/examples/contour_tree_distributed/ContourTreeApp.cxx b/examples/contour_tree_distributed/ContourTreeApp.cxx
index 2a0fabd47..a2cb3c4d7 100644
--- a/examples/contour_tree_distributed/ContourTreeApp.cxx
+++ b/examples/contour_tree_distributed/ContourTreeApp.cxx
@@ -401,14 +401,8 @@ int main(int argc, char* argv[])
   vtkm::Id3 globalSize;
   vtkm::Id3 blocksPerDim;
   vtkm::cont::ArrayHandle<vtkm::Id3> localBlockIndices;
-  vtkm::cont::ArrayHandle<vtkm::Id3> localBlockOrigins;
-  vtkm::cont::ArrayHandle<vtkm::Id3> localBlockSizes;
   localBlockIndices.Allocate(blocksPerRank);
-  localBlockOrigins.Allocate(blocksPerRank);
-  localBlockSizes.Allocate(blocksPerRank);
   auto localBlockIndicesPortal = localBlockIndices.WritePortal();
-  auto localBlockOriginsPortal = localBlockOrigins.WritePortal();
-  auto localBlockSizesPortal = localBlockSizes.WritePortal();
 
   // Read the pre-split data files
   if (preSplitFiles)
@@ -595,6 +589,11 @@ int main(int argc, char* argv[])
                                                 static_cast<ValueType>(offset[1]) };
         const vtkm::Vec<ValueType, 2> v_spacing{ 1, 1 };
         ds = dsb.Create(v_dims, v_origin, v_spacing);
+        vtkm::cont::CellSetStructured<2> cs;
+        cs.SetPointDimensions(v_dims);
+        cs.SetGlobalPointDimensions(vtkm::Id2{ globalSize[0], globalSize[1] });
+        cs.SetGlobalPointIndexStart(vtkm::Id2{ offset[0], offset[1] });
+        ds.SetCellSet(cs);
       }
       else
       {
@@ -607,6 +606,11 @@ int main(int argc, char* argv[])
                                                 static_cast<ValueType>(offset[2]) };
         vtkm::Vec<ValueType, 3> v_spacing(1, 1, 1);
         ds = dsb.Create(v_dims, v_origin, v_spacing);
+        vtkm::cont::CellSetStructured<3> cs;
+        cs.SetPointDimensions(v_dims);
+        cs.SetGlobalPointDimensions(globalSize);
+        cs.SetGlobalPointIndexStart(vtkm::Id3{ offset[0], offset[1], offset[2] });
+        ds.SetCellSet(cs);
       }
       ds.AddPointField("values", values);
       // and add to partition
@@ -617,14 +621,6 @@ int main(int argc, char* argv[])
         vtkm::Id3{ static_cast<vtkm::Id>(blockIndex[0]),
                    static_cast<vtkm::Id>(blockIndex[1]),
                    static_cast<vtkm::Id>(nDims == 3 ? blockIndex[2] : 0) });
-      localBlockOriginsPortal.Set(blockNo,
-                                  vtkm::Id3{ static_cast<vtkm::Id>(offset[0]),
-                                             static_cast<vtkm::Id>(offset[1]),
-                                             static_cast<vtkm::Id>(nDims == 3 ? offset[2] : 0) });
-      localBlockSizesPortal.Set(blockNo,
-                                vtkm::Id3{ static_cast<vtkm::Id>(dims[0]),
-                                           static_cast<vtkm::Id>(dims[1]),
-                                           static_cast<vtkm::Id>(nDims == 3 ? dims[2] : 0) });
 
       if (blockNo == 0)
       {
@@ -753,7 +749,6 @@ int main(int argc, char* argv[])
                             : vtkm::Id3(static_cast<vtkm::Id>(dims[0]),
                                         static_cast<vtkm::Id>(dims[1]),
                                         static_cast<vtkm::Id>(1));
-    std::cout << blocksPerDim << " " << globalSize << std::endl;
     {
       vtkm::Id lastDimSize =
         (nDims == 2) ? static_cast<vtkm::Id>(dims[1]) : static_cast<vtkm::Id>(dims[2]);
@@ -801,12 +796,12 @@ int main(int argc, char* argv[])
           vtkm::Vec<ValueType, 2> origin(0, blockIndex * blockSize);
           vtkm::Vec<ValueType, 2> spacing(1, 1);
           ds = dsb.Create(vdims, origin, spacing);
-
+          vtkm::cont::CellSetStructured<2> cs;
+          cs.SetPointDimensions(vdims);
+          cs.SetGlobalPointDimensions(vtkm::Id2{ globalSize[0], globalSize[1] });
+          cs.SetGlobalPointIndexStart(vtkm::Id2{ 0, (blockStart / blockSliceSize) });
+          ds.SetCellSet(cs);
           localBlockIndicesPortal.Set(localBlockIndex, vtkm::Id3(0, blockIndex, 0));
-          localBlockOriginsPortal.Set(localBlockIndex,
-                                      vtkm::Id3(0, (blockStart / blockSliceSize), 0));
-          localBlockSizesPortal.Set(localBlockIndex,
-                                    vtkm::Id3(static_cast<vtkm::Id>(dims[0]), currBlockSize, 0));
         }
         // 3D data
         else
@@ -818,14 +813,12 @@ int main(int argc, char* argv[])
           vtkm::Vec<ValueType, 3> origin(0, 0, (blockIndex * blockSize));
           vtkm::Vec<ValueType, 3> spacing(1, 1, 1);
           ds = dsb.Create(vdims, origin, spacing);
-
+          vtkm::cont::CellSetStructured<3> cs;
+          cs.SetPointDimensions(vdims);
+          cs.SetGlobalPointDimensions(globalSize);
+          cs.SetGlobalPointIndexStart(vtkm::Id3(0, 0, blockStart / blockSliceSize));
+          ds.SetCellSet(cs);
           localBlockIndicesPortal.Set(localBlockIndex, vtkm::Id3(0, 0, blockIndex));
-          localBlockOriginsPortal.Set(localBlockIndex,
-                                      vtkm::Id3(0, 0, (blockStart / blockSliceSize)));
-          localBlockSizesPortal.Set(localBlockIndex,
-                                    vtkm::Id3(static_cast<vtkm::Id>(dims[0]),
-                                              static_cast<vtkm::Id>(dims[1]),
-                                              currBlockSize));
         }
 
         std::vector<vtkm::Float32> subValues((values.begin() + blockStart),
@@ -863,13 +856,9 @@ int main(int argc, char* argv[])
   prevTime = currTime;
 
   // Convert the mesh of values into contour tree, pairs of vertex ids
-  vtkm::filter::ContourTreeUniformDistributed filter(blocksPerDim,
-                                                     globalSize,
-                                                     localBlockIndices,
-                                                     localBlockOrigins,
-                                                     localBlockSizes,
-                                                     timingsLogLevel,
-                                                     treeLogLevel);
+  vtkm::filter::scalar_topology::ContourTreeUniformDistributed filter(timingsLogLevel,
+                                                                      treeLogLevel);
+  filter.SetBlockIndices(blocksPerDim, localBlockIndices);
   filter.SetUseBoundaryExtremaOnly(useBoundaryExtremaOnly);
   filter.SetUseMarchingCubes(useMarchingCubes);
   filter.SetAugmentHierarchicalTree(augmentHierarchicalTree);
@@ -895,8 +884,7 @@ int main(int argc, char* argv[])
     {
       if (computeHierarchicalVolumetricBranchDecomposition)
       {
-        vtkm::filter::scalar_topology::DistributedBranchDecompositionFilter bd_filter(
-          blocksPerDim, globalSize, localBlockIndices, localBlockOrigins, localBlockSizes);
+        vtkm::filter::scalar_topology::DistributedBranchDecompositionFilter bd_filter;
         auto bd_result = bd_filter.Execute(result);
 
         for (vtkm::Id ds_no = 0; ds_no < result.GetNumberOfPartitions(); ++ds_no)
diff --git a/vtkm/cont/CellSetStructured.h b/vtkm/cont/CellSetStructured.h
index 26475b46e..6399c4ee4 100644
--- a/vtkm/cont/CellSetStructured.h
+++ b/vtkm/cont/CellSetStructured.h
@@ -51,6 +51,11 @@ public:
     this->Structure.SetPointDimensions(dimensions);
   }
 
+  void SetGlobalPointDimensions(SchedulingRangeType dimensions)
+  {
+    this->Structure.SetGlobalPointDimensions(dimensions);
+  }
+
   void SetGlobalPointIndexStart(SchedulingRangeType start)
   {
     this->Structure.SetGlobalPointIndexStart(start);
@@ -58,8 +63,18 @@ public:
 
   SchedulingRangeType GetPointDimensions() const { return this->Structure.GetPointDimensions(); }
 
+  SchedulingRangeType GetGlobalPointDimensions() const
+  {
+    return this->Structure.GetGlobalPointDimensions();
+  }
+
   SchedulingRangeType GetCellDimensions() const { return this->Structure.GetCellDimensions(); }
 
+  SchedulingRangeType GetGlobalCellDimensions() const
+  {
+    return this->Structure.GetGlobalCellDimensions();
+  }
+
   SchedulingRangeType GetGlobalPointIndexStart() const
   {
     return this->Structure.GetGlobalPointIndexStart();
@@ -225,17 +240,20 @@ public:
   static VTKM_CONT void save(BinaryBuffer& bb, const Type& cs)
   {
     vtkmdiy::save(bb, cs.GetPointDimensions());
+    vtkmdiy::save(bb, cs.GetGlobalPointDimensions());
     vtkmdiy::save(bb, cs.GetGlobalPointIndexStart());
   }
 
   static VTKM_CONT void load(BinaryBuffer& bb, Type& cs)
   {
-    typename Type::SchedulingRangeType dims, start;
+    typename Type::SchedulingRangeType dims, gdims, start;
     vtkmdiy::load(bb, dims);
+    vtkmdiy::load(bb, gdims);
     vtkmdiy::load(bb, start);
 
     cs = Type{};
     cs.SetPointDimensions(dims);
+    cs.SetGlobalPointDimensions(gdims);
     cs.SetGlobalPointIndexStart(start);
   }
 };
diff --git a/vtkm/cont/PartitionedDataSet.cxx b/vtkm/cont/PartitionedDataSet.cxx
index 9dbcb6e0d..761bde302 100644
--- a/vtkm/cont/PartitionedDataSet.cxx
+++ b/vtkm/cont/PartitionedDataSet.cxx
@@ -15,6 +15,13 @@
 #include <vtkm/cont/ErrorBadValue.h>
 #include <vtkm/cont/Field.h>
 #include <vtkm/cont/PartitionedDataSet.h>
+#include <vtkm/internal/Configure.h>
+
+// clang-format off
+VTKM_THIRDPARTY_PRE_INCLUDE
+#include <vtkm/thirdparty/diy/diy.h>
+VTKM_THIRDPARTY_POST_INCLUDE
+// clang-format on
 
 namespace vtkm
 {
@@ -73,6 +80,19 @@ vtkm::Id PartitionedDataSet::GetNumberOfPartitions() const
   return static_cast<vtkm::Id>(this->Partitions.size());
 }
 
+VTKM_CONT
+vtkm::Id PartitionedDataSet::GetGlobalNumberOfPartitions() const
+{
+#ifdef VTKM_ENABLE_MPI
+  auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
+  vtkm::Id globalSize = 0;
+  vtkmdiy::mpi::all_reduce(comm, GetNumberOfPartitions(), globalSize, std::plus<vtkm::Id>{});
+  return globalSize;
+#else
+  return GetNumberOfPartitions();
+#endif
+}
+
 VTKM_CONT
 const vtkm::cont::DataSet& PartitionedDataSet::GetPartition(vtkm::Id blockId) const
 {
diff --git a/vtkm/cont/PartitionedDataSet.h b/vtkm/cont/PartitionedDataSet.h
index 7152939ac..e2f4f465a 100644
--- a/vtkm/cont/PartitionedDataSet.h
+++ b/vtkm/cont/PartitionedDataSet.h
@@ -32,16 +32,16 @@ public:
   using reference = typename StorageVec::reference;
   using const_reference = typename StorageVec::const_reference;
 
-  /// create a new PartitionedDataSet containng a single DataSet @a ds
+  /// Create a new PartitionedDataSet containng a single DataSet @a ds.
   VTKM_CONT
   PartitionedDataSet(const vtkm::cont::DataSet& ds);
-  /// create a new PartitionedDataSet with the existing one @a src
+  /// Create a new PartitionedDataSet with the existing one @a src.
   VTKM_CONT
   PartitionedDataSet(const vtkm::cont::PartitionedDataSet& src);
-  /// create a new PartitionedDataSet with a DataSet vector @a partitions.
+  /// Create a new PartitionedDataSet with a DataSet vector @a partitions.
   VTKM_CONT
   explicit PartitionedDataSet(const std::vector<vtkm::cont::DataSet>& partitions);
-  /// create a new PartitionedDataSet with the capacity set to be @a size
+  /// Create a new PartitionedDataSet with the capacity set to be @a size.
   VTKM_CONT
   explicit PartitionedDataSet(vtkm::Id size);
 
@@ -53,33 +53,41 @@ public:
 
   VTKM_CONT
   ~PartitionedDataSet();
-  /// get the field @a field_name from partition @a partition_index
+  /// Get the field @a field_name from partition @a partition_index.
   VTKM_CONT
   vtkm::cont::Field GetField(const std::string& field_name, int partition_index) const;
 
+  /// Get number of DataSet objects stored in this PartitionedDataSet.
   VTKM_CONT
   vtkm::Id GetNumberOfPartitions() const;
 
+  /// Get number of partations across all MPI ranks.
+  /// @warning This method requires global communication (MPI_Allreduce) if MPI is enabled.
+  VTKM_CONT
+  vtkm::Id GetGlobalNumberOfPartitions() const;
+
+  /// Get the DataSet @a partId.
   VTKM_CONT
   const vtkm::cont::DataSet& GetPartition(vtkm::Id partId) const;
 
+  /// Get an STL vector of all DataSet objects stored in PartitionedDataSet.
   VTKM_CONT
   const std::vector<vtkm::cont::DataSet>& GetPartitions() const;
 
-  /// add DataSet @a ds to the end of the contained DataSet vector
+  /// Add DataSet @a ds to the end of the contained DataSet vector.
   VTKM_CONT
   void AppendPartition(const vtkm::cont::DataSet& ds);
 
-  /// add DataSet @a ds to position @a index of the contained DataSet vector
+  /// Add DataSet @a ds to position @a index of the contained DataSet vector.
   VTKM_CONT
   void InsertPartition(vtkm::Id index, const vtkm::cont::DataSet& ds);
 
-  /// replace the @a index positioned element of the contained DataSet vector
-  /// with @a ds
+  /// Replace the @a index positioned element of the contained DataSet vector
+  /// with @a ds.
   VTKM_CONT
   void ReplacePartition(vtkm::Id index, const vtkm::cont::DataSet& ds);
 
-  /// append the DataSet vector "partitions"  to the end of the contained one
+  /// Append the DataSet vector @a partitions to the end of the contained one.
   VTKM_CONT
   void AppendPartitions(const std::vector<vtkm::cont::DataSet>& partitions);
 
diff --git a/vtkm/filter/scalar_topology/CMakeLists.txt b/vtkm/filter/scalar_topology/CMakeLists.txt
index 44cee269d..01a938d26 100644
--- a/vtkm/filter/scalar_topology/CMakeLists.txt
+++ b/vtkm/filter/scalar_topology/CMakeLists.txt
@@ -16,6 +16,7 @@ set(scalar_topology_headers
 
 set(scalar_topology_sources
   internal/BranchDecompositionBlock.cxx
+  internal/ComputeBlockIndices.cxx
   internal/ComputeDistributedBranchDecompositionFunctor.cxx
   ContourTreeUniform.cxx
   ContourTreeUniformAugmented.cxx
diff --git a/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx b/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx
index 720bfa9d2..6bf2b7268 100644
--- a/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx
+++ b/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx
@@ -51,6 +51,7 @@
 //==============================================================================
 
 #include <vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h>
+#include <vtkm/filter/scalar_topology/internal/ComputeBlockIndices.h>
 #include <vtkm/filter/scalar_topology/worklet/ContourTreeUniformAugmented.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
 
@@ -83,12 +84,9 @@ ContourTreeAugmented::ContourTreeAugmented(bool useMarchingCubes,
   this->SetOutputFieldName("resultData");
 }
 
-void ContourTreeAugmented::SetSpatialDecomposition(
+void ContourTreeAugmented::SetBlockIndices(
   vtkm::Id3 blocksPerDim,
-  vtkm::Id3 globalSize,
-  const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
-  const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
-  const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes)
+  const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices)
 {
   if (this->MultiBlockTreeHelper)
   {
@@ -96,7 +94,7 @@ void ContourTreeAugmented::SetSpatialDecomposition(
   }
   this->MultiBlockTreeHelper =
     std::make_unique<vtkm::worklet::contourtree_distributed::MultiBlockContourTreeHelper>(
-      blocksPerDim, globalSize, localBlockIndices, localBlockOrigins, localBlockSizes);
+      blocksPerDim, localBlockIndices);
 }
 
 const vtkm::worklet::contourtree_augmented::ContourTree& ContourTreeAugmented::GetContourTree()
@@ -234,7 +232,7 @@ VTKM_CONT void ContourTreeAugmented::PreExecute(const vtkm::cont::PartitionedDat
 {
   if (this->MultiBlockTreeHelper)
   {
-    if (this->MultiBlockTreeHelper->GetGlobalNumberOfBlocks(input) !=
+    if (input.GetGlobalNumberOfPartitions() !=
         this->MultiBlockTreeHelper->GetGlobalNumberOfBlocks())
     {
       throw vtkm::cont::ErrorFilterExecution(
@@ -246,6 +244,12 @@ VTKM_CONT void ContourTreeAugmented::PreExecute(const vtkm::cont::PartitionedDat
         "Global number of block in MultiBlock dataset does not match the SpatialDecomposition");
     }
   }
+  else
+  {
+    // No block indices set -> compute information automatically later
+    this->MultiBlockTreeHelper =
+      std::make_unique<vtkm::worklet::contourtree_distributed::MultiBlockContourTreeHelper>(input);
+  }
 }
 
 //-----------------------------------------------------------------------------
@@ -268,10 +272,6 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(const vtkm::cont::Partitioned
   unsigned int compRegularStruct =
     (this->ComputeRegularStructure > 0) ? this->ComputeRegularStructure : 2;
 
-  auto localBlocksOriginPortal =
-    this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal();
-  auto localBlocksSizesPortal =
-    this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition.LocalBlockSizes.ReadPortal();
   for (std::size_t bi = 0; bi < static_cast<std::size_t>(input.GetNumberOfPartitions()); bi++)
   {
     // create the local contour tree mesh
@@ -279,20 +279,25 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(const vtkm::cont::Partitioned
     auto currBlock = input.GetPartition(static_cast<vtkm::Id>(bi));
     auto currField =
       currBlock.GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
+
+    vtkm::Id3 pointDimensions, globalPointDimensions, globalPointIndexStart;
+    currBlock.GetCellSet().CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
+      vtkm::worklet::contourtree_augmented::GetLocalAndGlobalPointDimensions(),
+      pointDimensions,
+      globalPointDimensions,
+      globalPointIndexStart);
+
     //const vtkm::cont::ArrayHandle<T,StorageType> &fieldData = currField.GetData().Cast<vtkm::cont::ArrayHandle<T,StorageType> >();
     vtkm::cont::ArrayHandle<T> fieldData;
     vtkm::cont::ArrayCopy(currField.GetData(), fieldData);
     auto currContourTreeMesh = vtkm::worklet::contourtree_distributed::MultiBlockContourTreeHelper::
-      ComputeLocalContourTreeMesh<T>(
-        this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal()
-          .Get(static_cast<vtkm::Id>(bi)),
-        this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition.LocalBlockSizes.ReadPortal().Get(
-          static_cast<vtkm::Id>(bi)),
-        this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition.GlobalSize,
-        fieldData,
-        MultiBlockTreeHelper->LocalContourTrees[bi],
-        MultiBlockTreeHelper->LocalSortOrders[bi],
-        compRegularStruct);
+      ComputeLocalContourTreeMesh<T>(globalPointIndexStart,
+                                     pointDimensions,
+                                     globalPointDimensions,
+                                     fieldData,
+                                     MultiBlockTreeHelper->LocalContourTrees[bi],
+                                     MultiBlockTreeHelper->LocalSortOrders[bi],
+                                     compRegularStruct);
     localContourTreeMeshes[bi] = currContourTreeMesh;
     // create the local data block structure
     localDataBlocks[bi] = new vtkm::worklet::contourtree_distributed::ContourTreeBlockData<T>();
@@ -303,10 +308,9 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(const vtkm::cont::Partitioned
     localDataBlocks[bi]->NeighborConnectivity = currContourTreeMesh->NeighborConnectivity;
     localDataBlocks[bi]->NeighborOffsets = currContourTreeMesh->NeighborOffsets;
     localDataBlocks[bi]->MaxNeighbors = currContourTreeMesh->MaxNeighbors;
-    localDataBlocks[bi]->BlockOrigin = localBlocksOriginPortal.Get(static_cast<vtkm::Id>(bi));
-    localDataBlocks[bi]->BlockSize = localBlocksSizesPortal.Get(static_cast<vtkm::Id>(bi));
-    localDataBlocks[bi]->GlobalSize =
-      this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition.GlobalSize;
+    localDataBlocks[bi]->BlockOrigin = globalPointIndexStart;
+    localDataBlocks[bi]->BlockSize = pointDimensions;
+    localDataBlocks[bi]->GlobalSize = globalPointDimensions;
     // We need to augment at least with the boundary vertices when running in parallel
     localDataBlocks[bi]->ComputeRegularStructure = compRegularStruct;
   }
@@ -320,33 +324,32 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(const vtkm::cont::Partitioned
 
   // Compute the gids for our local blocks
   using RegularDecomposer = vtkmdiy::RegularDecomposer<vtkmdiy::DiscreteBounds>;
-  const vtkm::filter::scalar_topology::internal::SpatialDecomposition& spatialDecomp =
-    this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition;
-  const auto numDims = spatialDecomp.NumberOfDimensions();
 
-  // ... division vector
-  RegularDecomposer::DivisionsVector diyDivisions(numDims);
-  for (vtkm::IdComponent d = 0;
-       d < static_cast<vtkm::IdComponent>(spatialDecomp.NumberOfDimensions());
-       ++d)
+  RegularDecomposer::DivisionsVector diyDivisions;
+  std::vector<int> vtkmdiyLocalBlockGids;
+  vtkmdiy::DiscreteBounds diyBounds(0);
+  if (this->MultiBlockTreeHelper->BlocksPerDimension[0] == -1)
   {
-    diyDivisions[d] = static_cast<int>(spatialDecomp.BlocksPerDimension[d]);
+    VTKM_LOG_S(vtkm::cont::LogLevel::Info,
+               "BlocksPerDimension not set. Computing block indices "
+               "from information in CellSetStructured.");
+    diyBounds = vtkm::filter::scalar_topology::internal::ComputeBlockIndices(
+      input, diyDivisions, vtkmdiyLocalBlockGids);
   }
-
-  // ... coordinates of local blocks
-  auto localBlockIndicesPortal = spatialDecomp.LocalBlockIndices.ReadPortal();
-  std::vector<vtkm::Id> vtkmdiyLocalBlockGids(static_cast<size_t>(input.GetNumberOfPartitions()));
-  for (vtkm::Id bi = 0; bi < input.GetNumberOfPartitions(); bi++)
+  else
   {
-    RegularDecomposer::DivisionsVector diyCoords(static_cast<size_t>(numDims));
-    auto currentCoords = localBlockIndicesPortal.Get(bi);
-    for (vtkm::IdComponent d = 0; d < numDims; ++d)
-    {
-      diyCoords[d] = static_cast<int>(currentCoords[d]);
-    }
-    vtkmdiyLocalBlockGids[static_cast<size_t>(bi)] =
-      RegularDecomposer::coords_to_gid(diyCoords, diyDivisions);
+    VTKM_LOG_S(vtkm::cont::LogLevel::Info,
+               "BlocksPerDimension set. Using information provided by caller.");
+    diyBounds = vtkm::filter::scalar_topology::internal::ComputeBlockIndices(
+      input,
+      this->MultiBlockTreeHelper->BlocksPerDimension,
+      this->MultiBlockTreeHelper->LocalBlockIndices,
+      diyDivisions,
+      vtkmdiyLocalBlockGids);
   }
+  int numDims = diyBounds.min.dimension();
+  int globalNumberOfBlocks =
+    std::accumulate(diyDivisions.cbegin(), diyDivisions.cend(), 1, std::multiplies<int>{});
 
   // Add my local blocks to the vtkmdiy master.
   for (std::size_t bi = 0; bi < static_cast<std::size_t>(input.GetNumberOfPartitions()); bi++)
@@ -361,16 +364,15 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(const vtkm::cont::Partitioned
   RegularDecomposer::BoolVector wrap(3, false);
   RegularDecomposer::CoordinateVector ghosts(3, 1);
   RegularDecomposer decomposer(static_cast<int>(numDims),
-                               spatialDecomp.GetVTKmDIYBounds(),
-                               static_cast<int>(spatialDecomp.GetGlobalNumberOfBlocks()),
+                               diyBounds,
+                               globalNumberOfBlocks,
                                shareFace,
                                wrap,
                                ghosts,
                                diyDivisions);
 
   // Define which blocks live on which rank so that vtkmdiy can manage them
-  vtkmdiy::DynamicAssigner assigner(
-    comm, static_cast<int>(size), static_cast<int>(spatialDecomp.GetGlobalNumberOfBlocks()));
+  vtkmdiy::DynamicAssigner assigner(comm, static_cast<int>(size), globalNumberOfBlocks);
   for (vtkm::Id bi = 0; bi < input.GetNumberOfPartitions(); bi++)
   {
     assigner.set_rank(static_cast<int>(rank),
@@ -394,6 +396,13 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(const vtkm::cont::Partitioned
 
   if (rank == 0)
   {
+    vtkm::Id3 dummy1, globalPointDimensions, dummy2;
+    vtkm::cont::DataSet firstDS = input.GetPartition(0);
+    firstDS.GetCellSet().CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
+      vtkm::worklet::contourtree_augmented::GetLocalAndGlobalPointDimensions(),
+      dummy1,
+      globalPointDimensions,
+      dummy2);
     // Now run the contour tree algorithm on the last block to compute the final tree
     vtkm::Id currNumIterations;
     vtkm::worklet::contourtree_augmented::ContourTree currContourTree;
@@ -412,12 +421,12 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(const vtkm::cont::Partitioned
     contourTreeMeshOut.MaxNeighbors = localDataBlocks[0]->MaxNeighbors;
     // Construct the mesh boundary exectuion object needed for boundary augmentation
     vtkm::Id3 minIdx(0, 0, 0);
-    vtkm::Id3 maxIdx = this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition.GlobalSize;
+    vtkm::Id3 maxIdx = globalPointDimensions;
     maxIdx[0] = maxIdx[0] - 1;
     maxIdx[1] = maxIdx[1] - 1;
     maxIdx[2] = maxIdx[2] > 0 ? (maxIdx[2] - 1) : 0;
-    auto meshBoundaryExecObj = contourTreeMeshOut.GetMeshBoundaryExecutionObject(
-      this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition.GlobalSize, minIdx, maxIdx);
+    auto meshBoundaryExecObj =
+      contourTreeMeshOut.GetMeshBoundaryExecutionObject(globalPointDimensions, minIdx, maxIdx);
     // Run the worklet to compute the final contour tree
     worklet.Run(
       contourTreeMeshOut.SortedValues, // Unused param. Provide something to keep API happy
diff --git a/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h b/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h
index 0b5dc342c..466b75c90 100644
--- a/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h
+++ b/vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h
@@ -114,19 +114,24 @@ public:
   ///
   /// Note: Only used when running on a multi-block dataset.
   /// @param[in] blocksPerDim  Number of data blocks used in each data dimension
-  /// @param[in] globalSize  Global extends of the input mesh (i.e., number of mesh points in each dimension)
   /// @param[in] localBlockIndices  Array with the (x,y,z) index of each local data block with
   ///                               with respect to blocksPerDim
-  /// @param[in] localBlockOrigins  Array with the (x,y,z) origin (with regard to mesh index) of each
-  ///                               local data block
-  /// @param[in] localBlockSizes    Array with the sizes (i.e., extends in number of mesh points) of each
-  ///                               local data block
   VTKM_CONT
+  void SetBlockIndices(vtkm::Id3 blocksPerDim,
+                       const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices);
+
+  VTKM_CONT
+  VTKM_DEPRECATED(1.9,
+                  "Set PointSize, GlobalPointOrigin, and GlobalPointSize in CellSetStructured and "
+                  "optionally use SetBlockIndices.")
   void SetSpatialDecomposition(vtkm::Id3 blocksPerDim,
-                               vtkm::Id3 globalSize,
+                               vtkm::Id3,
                                const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
-                               const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
-                               const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes);
+                               const vtkm::cont::ArrayHandle<vtkm::Id3>&,
+                               const vtkm::cont::ArrayHandle<vtkm::Id3>&)
+  {
+    SetBlockIndices(blocksPerDim, localBlockIndices);
+  }
 
   //@{
   /// Get the contour tree computed by the filter
diff --git a/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.cxx b/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.cxx
index 3ccbdbc2d..d237dd8b0 100644
--- a/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.cxx
+++ b/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.cxx
@@ -51,6 +51,7 @@
 //==============================================================================
 
 // vtkm includes
+#include <vtkm/cont/CellSetStructured.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/cont/Timer.h>
 
@@ -61,7 +62,7 @@
 #include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundaryContourTreeMesh.h>
 
 // distributed contour tree includes
-#include <vtkm/filter/scalar_topology/internal/SpatialDecomposition.h>
+#include <vtkm/filter/scalar_topology/internal/ComputeBlockIndices.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_distributed/BoundaryTree.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_distributed/BoundaryTreeMaker.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_distributed/CombineHyperSweepBlockFunctor.h>
@@ -165,10 +166,10 @@ void SaveHierarchicalTreeDot(
 //-----------------------------------------------------------------------------
 ContourTreeUniformDistributed::ContourTreeUniformDistributed(
   vtkm::Id3 blocksPerDim,
-  vtkm::Id3 globalSize,
+  vtkm::Id3, // globalSize, -> Now in CellSetStructured
   const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
-  const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
-  const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes,
+  const vtkm::cont::ArrayHandle<vtkm::Id3>&, // localBlockOrigins, -> Use from CellSetStructured
+  const vtkm::cont::ArrayHandle<vtkm::Id3>&, // localBlockSizes, -> Use from CellSetStructured
   vtkm::cont::LogLevel timingsLogLevel,
   vtkm::cont::LogLevel treeLogLevel)
   : UseBoundaryExtremaOnly(true)
@@ -177,19 +178,33 @@ ContourTreeUniformDistributed::ContourTreeUniformDistributed(
   , SaveDotFiles(false)
   , TimingsLogLevel(timingsLogLevel)
   , TreeLogLevel(treeLogLevel)
-  , MultiBlockSpatialDecomposition(blocksPerDim,
-                                   globalSize,
-                                   localBlockIndices,
-                                   localBlockOrigins,
-                                   localBlockSizes)
-  , LocalMeshes(static_cast<std::size_t>(localBlockSizes.GetNumberOfValues()))
-  , LocalContourTrees(static_cast<std::size_t>(localBlockSizes.GetNumberOfValues()))
-  , LocalBoundaryTrees(static_cast<std::size_t>(localBlockSizes.GetNumberOfValues()))
-  , LocalInteriorForests(static_cast<std::size_t>(localBlockSizes.GetNumberOfValues()))
+  , BlocksPerDimension(blocksPerDim)
+  , LocalBlockIndices(localBlockIndices)
+  , LocalMeshes()
+  , LocalContourTrees()
+  , LocalBoundaryTrees()
+  , LocalInteriorForests()
 {
   this->SetOutputFieldName("resultData");
 }
 
+ContourTreeUniformDistributed::ContourTreeUniformDistributed(vtkm::cont::LogLevel timingsLogLevel,
+                                                             vtkm::cont::LogLevel treeLogLevel)
+  : UseBoundaryExtremaOnly(true)
+  , UseMarchingCubes(false)
+  , AugmentHierarchicalTree(false)
+  , SaveDotFiles(false)
+  , TimingsLogLevel(timingsLogLevel)
+  , TreeLogLevel(treeLogLevel)
+  , BlocksPerDimension(vtkm::Id3{ -1, -1, -1 })
+  , LocalBlockIndices()
+  , LocalMeshes()
+  , LocalContourTrees()
+  , LocalBoundaryTrees()
+  , LocalInteriorForests()
+{
+  this->SetOutputFieldName("resultData");
+}
 
 //-----------------------------------------------------------------------------
 // Functions used in PrepareForExecution() to compute the local contour
@@ -237,7 +252,7 @@ void ContourTreeUniformDistributed::ComputeLocalTree(
 template <typename T, typename StorageType, typename MeshType, typename MeshBoundaryExecType>
 void ContourTreeUniformDistributed::ComputeLocalTreeImpl(
   const vtkm::Id blockIndex,
-  const vtkm::cont::DataSet&, // input,
+  const vtkm::cont::DataSet& ds, // input,
   const vtkm::cont::ArrayHandle<T, StorageType>& field,
   MeshType& mesh,
   MeshBoundaryExecType& meshBoundaryExecObject)
@@ -278,10 +293,14 @@ void ContourTreeUniformDistributed::ComputeLocalTreeImpl(
   // Create an IdRelabeler since we are using a DataSetMesh type here, we don't need
   // the IdRelabeler for the BRACT construction when we are using a ContourTreeMesh.
 
+  vtkm::Id3 pointDimensions, globalPointDimensions, globalPointIndexStart;
+  ds.GetCellSet().CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
+    vtkm::worklet::contourtree_augmented::GetLocalAndGlobalPointDimensions(),
+    pointDimensions,
+    globalPointDimensions,
+    globalPointIndexStart);
   auto localToGlobalIdRelabeler = vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler(
-    this->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal().Get(blockIndex),
-    this->MultiBlockSpatialDecomposition.LocalBlockSizes.ReadPortal().Get(blockIndex),
-    this->MultiBlockSpatialDecomposition.GlobalSize);
+    globalPointIndexStart, pointDimensions, globalPointDimensions);
   // Initialize the BoundaryTreeMaker
   auto boundaryTreeMaker =
     vtkm::worklet::contourtree_distributed::BoundaryTreeMaker<MeshType, MeshBoundaryExecType>(
@@ -322,9 +341,9 @@ void ContourTreeUniformDistributed::ComputeLocalTreeImpl(
           "Before Fan In",
           mesh,
           field,
-          this->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal().Get(blockIndex),
-          this->MultiBlockSpatialDecomposition.LocalBlockSizes.ReadPortal().Get(blockIndex),
-          this->MultiBlockSpatialDecomposition.GlobalSize);
+          globalPointIndexStart,
+          pointDimensions,
+          globalPointDimensions);
       bractFile << bractString << std::endl;
     }
 
@@ -461,18 +480,40 @@ vtkm::cont::DataSet ContourTreeUniformDistributed::DoExecute(const vtkm::cont::D
 VTKM_CONT void ContourTreeUniformDistributed::PreExecute(
   const vtkm::cont::PartitionedDataSet& input)
 {
-  if (vtkm::filter::scalar_topology::internal::SpatialDecomposition::GetGlobalNumberOfBlocks(
-        input) != this->MultiBlockSpatialDecomposition.GetGlobalNumberOfBlocks())
+  // TODO/FIXME: The following may be too expensive for a "sanity" check as it
+  // requires global communication
+  auto globalNumberOfPartitions = input.GetGlobalNumberOfPartitions();
+
+  if (globalNumberOfPartitions < 2)
   {
-    throw vtkm::cont::ErrorFilterExecution(
-      "Global number of blocks in MultiBlock dataset does not match the SpatialDecomposition");
+    throw vtkm::cont::ErrorFilterExecution("ContourTreeUniformDistributed filter expects a "
+                                           "PartitionedDataSet with at least two partitions.");
   }
-  if (this->MultiBlockSpatialDecomposition.GetLocalNumberOfBlocks() !=
-      input.GetNumberOfPartitions())
+
+  if (this->BlocksPerDimension[0] != -1)
   {
-    throw vtkm::cont::ErrorFilterExecution(
-      "Local number of blocks in MultiBlock dataset does not match the SpatialDecomposition");
+    if (this->BlocksPerDimension[1] < 1 || this->BlocksPerDimension[2] < 1)
+    {
+      throw vtkm::cont::ErrorFilterExecution("Invalid input BlocksPerDimension.");
+    }
+    if (globalNumberOfPartitions !=
+        this->BlocksPerDimension[0] * this->BlocksPerDimension[1] * this->BlocksPerDimension[2])
+    {
+      throw vtkm::cont::ErrorFilterExecution("Global number of blocks in data set does not match "
+                                             "expected value based on BlocksPerDimension");
+    }
+    if (this->LocalBlockIndices.GetNumberOfValues() != input.GetNumberOfPartitions())
+    {
+      throw vtkm::cont::ErrorFilterExecution("Local number of partitions in data set does not "
+                                             "match number of specified blocks indices.");
+    }
   }
+
+  // Allocate vectors
+  this->LocalMeshes.resize(static_cast<std::size_t>(input.GetGlobalNumberOfPartitions()));
+  this->LocalContourTrees.resize(static_cast<std::size_t>(input.GetGlobalNumberOfPartitions()));
+  this->LocalBoundaryTrees.resize(static_cast<std::size_t>(input.GetGlobalNumberOfPartitions()));
+  this->LocalInteriorForests.resize(static_cast<std::size_t>(input.GetGlobalNumberOfPartitions()));
 }
 
 vtkm::cont::PartitionedDataSet ContourTreeUniformDistributed::DoExecutePartitions(
@@ -546,15 +587,6 @@ VTKM_CONT void ContourTreeUniformDistributed::PostExecute(
   vtkm::cont::Timer timer;
   timer.Start();
 
-  // We are running in parallel and need to merge the contour tree in PostExecute
-  // TODO/FIXME: This filter should only be used in a parallel setting with more
-  // than one block. Is there a better way to enforce this? thrown an exception
-  // instead of an empty return? What is the appropriate exception?
-  if (this->MultiBlockSpatialDecomposition.GetGlobalNumberOfBlocks() == 1)
-  {
-    return;
-  }
-
   auto field = // TODO/FIXME: Correct for more than one block per rank?
     input.GetPartition(0).GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
 
@@ -602,12 +634,15 @@ inline VTKM_CONT void ContourTreeUniformDistributed::ComputeVolumeMetric(
   inputContourTreeMaster.foreach (
     [&](DistributedContourTreeBlockData* currInBlock, const vtkmdiy::Master::ProxyWithLink&) {
       vtkm::Id blockNo = currInBlock->LocalBlockNo;
+      const vtkm::cont::DataSet& currDS = hierarchicalTreeOutputDataSet[blockNo];
       // The block size and origin may be modified during the FanIn so we need to use the
       // size and origin from the original decomposition instead of looking it up in the currInBlock
-      auto currBlockSize =
-        this->MultiBlockSpatialDecomposition.LocalBlockSizes.ReadPortal().Get(blockNo);
-      auto currBlockOrigin =
-        this->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal().Get(blockNo);
+      vtkm::Id3 pointDimensions, globalPointDimensions, globalPointIndexStart;
+      currDS.GetCellSet().CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
+        vtkm::worklet::contourtree_augmented::GetLocalAndGlobalPointDimensions(),
+        pointDimensions,
+        globalPointDimensions,
+        globalPointIndexStart);
 
       // NOTE: Use dummy link to make DIY happy. The dummy link is never used, since all
       //       communication is via RegularDecomposer, which sets up its own links. No need
@@ -618,9 +653,9 @@ inline VTKM_CONT void ContourTreeUniformDistributed::ComputeVolumeMetric(
         currInBlock->GlobalBlockId,
         new HyperSweepBlock(blockNo,
                             currInBlock->GlobalBlockId,
-                            currBlockOrigin,
-                            currBlockSize,
-                            this->MultiBlockSpatialDecomposition.GlobalSize,
+                            globalPointIndexStart,
+                            pointDimensions,
+                            globalPointDimensions,
                             *currInBlock->HierarchicalAugmenter.AugmentedTree),
         new vtkmdiy::Link());
     });
@@ -774,6 +809,7 @@ inline VTKM_CONT void ContourTreeUniformDistributed::ComputeVolumeMetric(
     });
 }
 
+
 //-----------------------------------------------------------------------------
 template <typename FieldType>
 VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
@@ -809,30 +845,32 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
 
   // 1.1.2 Compute the gids for our local blocks
   using RegularDecomposer = vtkmdiy::RegularDecomposer<vtkmdiy::DiscreteBounds>;
-  const auto& spatialDecomp = this->MultiBlockSpatialDecomposition;
-  const auto numDims = spatialDecomp.NumberOfDimensions();
 
-  // ... compute division vector for global domain
-  RegularDecomposer::DivisionsVector diyDivisions(numDims);
-  for (vtkm::IdComponent d = 0; d < static_cast<vtkm::IdComponent>(numDims); ++d)
+  RegularDecomposer::DivisionsVector diyDivisions;
+  std::vector<int> vtkmdiyLocalBlockGids;
+  vtkmdiy::DiscreteBounds diyBounds(0);
+  if (this->BlocksPerDimension[0] == -1)
   {
-    diyDivisions[d] = static_cast<int>(spatialDecomp.BlocksPerDimension[d]);
+    VTKM_LOG_S(vtkm::cont::LogLevel::Info,
+               "BlocksPerDimension not set. Computing block indices "
+               "from information in CellSetStructured.");
+    diyBounds = vtkm::filter::scalar_topology::internal::ComputeBlockIndices(
+      input, diyDivisions, vtkmdiyLocalBlockGids);
   }
-
-  // ... compute coordinates of local blocks
-  auto localBlockIndicesPortal = spatialDecomp.LocalBlockIndices.ReadPortal();
-  std::vector<int> vtkmdiyLocalBlockGids(static_cast<size_t>(input.GetNumberOfPartitions()));
-  for (vtkm::Id bi = 0; bi < input.GetNumberOfPartitions(); bi++)
+  else
   {
-    RegularDecomposer::DivisionsVector diyCoords(static_cast<size_t>(numDims));
-    auto currentCoords = localBlockIndicesPortal.Get(bi);
-    for (vtkm::IdComponent d = 0; d < numDims; ++d)
-    {
-      diyCoords[d] = static_cast<int>(currentCoords[d]);
-    }
-    vtkmdiyLocalBlockGids[static_cast<size_t>(bi)] =
-      RegularDecomposer::coords_to_gid(diyCoords, diyDivisions);
+    VTKM_LOG_S(vtkm::cont::LogLevel::Info,
+               "BlocksPerDimension set. Using information provided by caller.");
+    diyBounds =
+      vtkm::filter::scalar_topology::internal::ComputeBlockIndices(input,
+                                                                   this->BlocksPerDimension,
+                                                                   this->LocalBlockIndices,
+                                                                   diyDivisions,
+                                                                   vtkmdiyLocalBlockGids);
   }
+  int numDims = diyBounds.min.dimension();
+  int globalNumberOfBlocks =
+    std::accumulate(diyDivisions.cbegin(), diyDivisions.cend(), 1, std::multiplies<int>{});
 
   // Record time to compute the local block ids
   timingsStream << "    " << std::setw(38) << std::left << "Compute Block Ids and Local Links"
@@ -840,16 +878,28 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
   timer.Start();
 
   // 1.1.3 Setup the block data for DIY and add it to master
+  // Note: globalPointDimensions is defined outside the loop since it is needed later.
+  // It may be set multiple times in the loop, but always to the same value.
+  vtkm::Id3 globalPointDimensions;
   for (vtkm::Id bi = 0; bi < input.GetNumberOfPartitions(); bi++)
   {
+    // Get the input block and associated cell set information
+    auto currBlock = input.GetPartition(static_cast<vtkm::Id>(bi));
+    vtkm::Id3 pointDimensions, globalPointIndexStart;
+    currBlock.GetCellSet().CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
+      vtkm::worklet::contourtree_augmented::GetLocalAndGlobalPointDimensions(),
+      pointDimensions,
+      globalPointDimensions,
+      globalPointIndexStart);
+
     // Create the local data block structure and set extents
     auto newBlock = new DistributedContourTreeBlockData();
 
     // Copy global block id into the local data block for use in the hierarchical augmentation
     newBlock->GlobalBlockId = vtkmdiyLocalBlockGids[bi];
     newBlock->LocalBlockNo = bi;
-    newBlock->BlockOrigin = spatialDecomp.LocalBlockOrigins.ReadPortal().Get(bi);
-    newBlock->BlockSize = spatialDecomp.LocalBlockSizes.ReadPortal().Get(bi);
+    newBlock->BlockOrigin = globalPointIndexStart;
+    newBlock->BlockSize = pointDimensions;
 
     // Save local tree information for fan out; TODO/FIXME: Try to avoid copy
     newBlock->ContourTrees.push_back(this->LocalContourTrees[bi]);
@@ -868,15 +918,10 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
     auto transformedIndex = vtkm::cont::make_ArrayHandleTransform(
       permutedSortOrder,
       vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler(
-        this->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal().Get(
-          static_cast<vtkm::Id>(bi)),
-        this->MultiBlockSpatialDecomposition.LocalBlockSizes.ReadPortal().Get(
-          static_cast<vtkm::Id>(bi)),
-        this->MultiBlockSpatialDecomposition.GlobalSize));
+        globalPointIndexStart, pointDimensions, globalPointDimensions));
     vtkm::cont::Algorithm::Copy(transformedIndex, localGlobalMeshIndex);
 
     // ... get data values
-    auto currBlock = input.GetPartition(static_cast<vtkm::Id>(bi));
     auto currField =
       currBlock.GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
     vtkm::cont::ArrayHandle<FieldType> fieldData;
@@ -942,16 +987,15 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
   RegularDecomposer::BoolVector wrap(3, false);
   RegularDecomposer::CoordinateVector ghosts(3, 1);
   RegularDecomposer decomposer(static_cast<int>(numDims),
-                               spatialDecomp.GetVTKmDIYBounds(),
-                               static_cast<int>(spatialDecomp.GetGlobalNumberOfBlocks()),
+                               diyBounds,
+                               globalNumberOfBlocks,
                                shareFace,
                                wrap,
                                ghosts,
                                diyDivisions);
 
   // Define which blocks live on which rank so that vtkmdiy can manage them
-  vtkmdiy::DynamicAssigner assigner(
-    comm, static_cast<int>(size), static_cast<int>(spatialDecomp.GetGlobalNumberOfBlocks()));
+  vtkmdiy::DynamicAssigner assigner(comm, static_cast<int>(size), globalNumberOfBlocks);
   for (vtkm::Id bi = 0; bi < input.GetNumberOfPartitions(); bi++)
   {
     assigner.set_rank(static_cast<int>(rank), vtkmdiyLocalBlockGids[static_cast<size_t>(bi)]);
@@ -984,7 +1028,7 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
   timer.Start();
   // 1.3 Perform fan-in reduction
   const vtkm::worklet::contourtree_distributed::ComputeDistributedContourTreeFunctor<FieldType>
-    computeDistributedContourTreeFunctor(this->MultiBlockSpatialDecomposition.GlobalSize,
+    computeDistributedContourTreeFunctor(globalPointDimensions,
                                          this->UseBoundaryExtremaOnly,
                                          this->TimingsLogLevel,
                                          this->TreeLogLevel);
@@ -1061,17 +1105,22 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
         grafter(&(this->LocalMeshes[static_cast<std::size_t>(blockData->LocalBlockNo)]),
                 blockData->ContourTrees[0],
                 &(blockData->InteriorForests[0]));
-    auto currBlock = input.GetPartition(blockData->LocalBlockNo);
+    vtkm::cont::DataSet currBlock = input.GetPartition(blockData->LocalBlockNo);
     auto currField =
       currBlock.GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
     vtkm::cont::ArrayHandle<FieldType> fieldData;
     vtkm::cont::ArrayCopy(currField.GetData(), fieldData);
+
+    vtkm::Id3 pointDimensions, globalPointIndexStart;
+    // globalPointDimensions already defined in parent scope
+    currBlock.GetCellSet().CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
+      vtkm::worklet::contourtree_augmented::GetLocalAndGlobalPointDimensions(),
+      pointDimensions,
+      globalPointDimensions,
+      globalPointIndexStart);
+
     auto localToGlobalIdRelabeler = vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler(
-      this->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal().Get(
-        blockData->LocalBlockNo),
-      this->MultiBlockSpatialDecomposition.LocalBlockSizes.ReadPortal().Get(
-        blockData->LocalBlockNo),
-      this->MultiBlockSpatialDecomposition.GlobalSize);
+      globalPointIndexStart, pointDimensions, globalPointDimensions);
     grafter.GraftInteriorForests(
       0, blockData->HierarchicalTree, fieldData, &localToGlobalIdRelabeler);
 
@@ -1155,9 +1204,30 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
     // Add the information to the output data set
     blockHierarchcialTree.AddToVTKMDataSet(hierarchicalTreeOutputDataSet[blockData->LocalBlockNo]);
 
+    // Save information required to set up DIY
+    vtkm::cont::ArrayHandle<vtkm::Id> vtkmGlobalBlockIdAH;
+    vtkmGlobalBlockIdAH.Allocate(1);
+    auto vtkmGlobalBlockIdWP = vtkmGlobalBlockIdAH.WritePortal();
+    vtkmGlobalBlockIdWP.Set(0, blockData->GlobalBlockId);
+    vtkm::cont::Field vtkmGlobalBlockIdField(
+      "vtkmGlobalBlockId", vtkm::cont::Field::Association::WholeMesh, vtkmGlobalBlockIdAH);
+    hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(vtkmGlobalBlockIdField);
+    vtkm::cont::ArrayHandle<vtkm::Id> vtkmBlocksPerDimensionAH;
+    vtkmBlocksPerDimensionAH.Allocate(3);
+    auto vtkmBlocksPerDimensionWP = vtkmBlocksPerDimensionAH.WritePortal();
+    vtkmBlocksPerDimensionWP.Set(0, this->BlocksPerDimension[0]);
+    vtkmBlocksPerDimensionWP.Set(1, this->BlocksPerDimension[1]);
+    vtkmBlocksPerDimensionWP.Set(2, this->BlocksPerDimension[2]);
+    vtkm::cont::Field vtkmBlocksPerDimensionField("vtkmBlocksPerDimension",
+                                                  vtkm::cont::Field::Association::WholeMesh,
+                                                  vtkmBlocksPerDimensionAH);
+    hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(vtkmBlocksPerDimensionField);
+
     // Copy cell set from input data set. This is mainly to ensure that the output data set
     // has a defined cell set. Without one, serialization for DIY does not work properly.
     // Having the extents of the input data set may also help in other use cases.
+    // For example, the ComputeVolume method gets information from this cell set as will
+    // the branch decomposition filter.
     hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].SetCellSet(
       input.GetPartition(blockData->LocalBlockNo).GetCellSet());
 
diff --git a/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.h b/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.h
index d173bb60c..5f915d250 100644
--- a/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.h
+++ b/vtkm/filter/scalar_topology/ContourTreeUniformDistributed.h
@@ -56,7 +56,6 @@
 
 #include <vtkm/Types.h>
 #include <vtkm/cont/ArrayHandle.h>
-#include <vtkm/filter/scalar_topology/internal/SpatialDecomposition.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ContourTree.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/DataSetMesh.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_distributed/BoundaryTree.h>
@@ -113,14 +112,20 @@ public:
   /// @param[in] treeLogLevel Set the vtkm::cont:LogLevel to be used to record metadata information
   ///                         about the various trees computed as part of the hierarchical contour tree compute
   VTKM_CONT
-  ContourTreeUniformDistributed(
-    vtkm::Id3 blocksPerDim, // TODO/FIXME: Possibly pass SpatialDecomposition object instead
-    vtkm::Id3 globalSize,
-    const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
-    const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
-    const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes,
-    vtkm::cont::LogLevel timingsLogLevel = vtkm::cont::LogLevel::Perf,
-    vtkm::cont::LogLevel treeLogLevel = vtkm::cont::LogLevel::Info);
+  VTKM_DEPRECATED(
+    1.9,
+    "Use default constructor and set PointSize, GlobalPointIndexStart, and GlobalPointSize in "
+    "CellSetStructured. Optionally use `SetBlockIndices` accessor (if information is available).")
+  ContourTreeUniformDistributed(vtkm::Id3 blocksPerDim,
+                                vtkm::Id3 globalSize,
+                                const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
+                                const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
+                                const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes,
+                                vtkm::cont::LogLevel timingsLogLevel = vtkm::cont::LogLevel::Perf,
+                                vtkm::cont::LogLevel treeLogLevel = vtkm::cont::LogLevel::Info);
+
+  ContourTreeUniformDistributed(vtkm::cont::LogLevel timingsLogLevel = vtkm::cont::LogLevel::Perf,
+                                vtkm::cont::LogLevel treeLogLevel = vtkm::cont::LogLevel::Info);
 
   VTKM_CONT void SetUseBoundaryExtremaOnly(bool useBoundaryExtremaOnly)
   {
@@ -141,6 +146,13 @@ public:
     this->AugmentHierarchicalTree = augmentHierarchicalTree;
   }
 
+  VTKM_CONT void SetBlockIndices(vtkm::Id3 blocksPerDim,
+                                 const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices)
+  {
+    this->BlocksPerDimension = blocksPerDim;
+    vtkm::cont::ArrayCopy(localBlockIndices, this->LocalBlockIndices);
+  }
+
   VTKM_CONT bool GetAugmentHierarchicalTree() { return this->AugmentHierarchicalTree; }
 
   VTKM_CONT void SetSaveDotFiles(bool saveDotFiles) { this->SaveDotFiles = saveDotFiles; }
@@ -213,8 +225,11 @@ private:
   /// Log level to be used for outputting metadata about the trees. Default is vtkm::cont::LogLevel::Info
   vtkm::cont::LogLevel TreeLogLevel = vtkm::cont::LogLevel::Info;
 
-  /// Information about the spatial decomposition
-  vtkm::filter::scalar_topology::internal::SpatialDecomposition MultiBlockSpatialDecomposition;
+  /// Information about block decomposition TODO/FIXME: Remove need for this information
+  // ... Number of blocks along each dimension
+  vtkm::Id3 BlocksPerDimension;
+  // ... Index of the local blocks in x,y,z, i.e., in i,j,k mesh coordinates
+  vtkm::cont::ArrayHandle<vtkm::Id3> LocalBlockIndices;
 
   /// Intermediate results (one per local data block)...
   /// ... local mesh information needed at end of fan out
@@ -240,28 +255,23 @@ class VTKM_DEPRECATED(1.8, "Use vtkm::filter::scalar_topology::ContourTreeUnifor
   using scalar_topology::ContourTreeUniformDistributed::ContourTreeUniformDistributed;
 
   ContourTreeUniformDistributed(vtkm::Id3 blocksPerDim,
-                                vtkm::Id3 globalSize,
+                                vtkm::Id3,
                                 const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
-                                const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
-                                const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes,
+                                const vtkm::cont::ArrayHandle<vtkm::Id3>&,
+                                const vtkm::cont::ArrayHandle<vtkm::Id3>&,
                                 bool useBoundaryExtremaOnly = true,
                                 bool useMarchingCubes = false,
                                 bool augmentHierarchicalTree = false,
                                 bool saveDotFiles = false,
                                 vtkm::cont::LogLevel timingsLogLevel = vtkm::cont::LogLevel::Perf,
                                 vtkm::cont::LogLevel treeLogLevel = vtkm::cont::LogLevel::Info)
-    : vtkm::filter::scalar_topology::ContourTreeUniformDistributed(blocksPerDim,
-                                                                   globalSize,
-                                                                   localBlockIndices,
-                                                                   localBlockOrigins,
-                                                                   localBlockSizes,
-                                                                   timingsLogLevel,
-                                                                   treeLogLevel)
+    : vtkm::filter::scalar_topology::ContourTreeUniformDistributed(timingsLogLevel, treeLogLevel)
   {
     this->SetUseBoundaryExtremaOnly(useBoundaryExtremaOnly);
     this->SetUseMarchingCubes(useMarchingCubes);
     this->SetAugmentHierarchicalTree(augmentHierarchicalTree);
     this->SetSaveDotFiles(saveDotFiles);
+    this->SetBlockIndices(blocksPerDim, localBlockIndices);
     this->SetOutputFieldName("resultData");
   }
 };
diff --git a/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx b/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx
index 22fc3b6a9..f2adc22cc 100644
--- a/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx
+++ b/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx
@@ -36,16 +36,11 @@ namespace scalar_topology
 // not need to pass it sperately (or check if it can already be derived from
 // information stored in PartitionedDataSet)
 VTKM_CONT DistributedBranchDecompositionFilter::DistributedBranchDecompositionFilter(
-  vtkm::Id3 blocksPerDim,
-  vtkm::Id3 globalSize,
-  const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
-  const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
-  const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes)
-  : MultiBlockSpatialDecomposition(blocksPerDim,
-                                   globalSize,
-                                   localBlockIndices,
-                                   localBlockOrigins,
-                                   localBlockSizes)
+  vtkm::Id3,
+  vtkm::Id3,
+  const vtkm::cont::ArrayHandle<vtkm::Id3>&,
+  const vtkm::cont::ArrayHandle<vtkm::Id3>&,
+  const vtkm::cont::ArrayHandle<vtkm::Id3>&)
 {
 }
 
@@ -80,52 +75,59 @@ VTKM_CONT vtkm::cont::PartitionedDataSet DistributedBranchDecompositionFilter::D
                                               BranchDecompositionBlock::Destroy);
 
   timingsStream << "    " << std::setw(60) << std::left
-                << "Create DIY Master (Branch Decomposition)"
+                << "Create DIY Master and Assigner (Branch Decomposition)"
                 << ": " << timer.GetElapsedTime() << " seconds" << std::endl;
   timer.Start();
 
   // Compute global ids (gids) for our local blocks
-  using RegularDecomposer = vtkmdiy::RegularDecomposer<vtkmdiy::DiscreteBounds>;
-  int globalNumberOfBlocks =
-    static_cast<int>(this->MultiBlockSpatialDecomposition.GetGlobalNumberOfBlocks());
-  int numDims = static_cast<int>(this->MultiBlockSpatialDecomposition.NumberOfDimensions());
+  // TODO/FIXME: Is there a better way to set this up?
+  auto firstDS = input.GetPartition(0);
+  vtkm::Id3 firstPointDimensions, firstGlobalPointDimensions, firstGlobalPointIndexStart;
+  firstDS.GetCellSet().CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
+    vtkm::worklet::contourtree_augmented::GetLocalAndGlobalPointDimensions(),
+    firstPointDimensions,
+    firstGlobalPointDimensions,
+    firstGlobalPointIndexStart);
+  int numDims = firstGlobalPointDimensions[2] > 1 ? 3 : 2;
+  auto vtkmBlocksPerDimensionRP = input.GetPartition(0)
+                                    .GetField("vtkmBlocksPerDimension")
+                                    .GetData()
+                                    .AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>()
+                                    .ReadPortal();
 
   // ... compute division vector for global domain
+  using RegularDecomposer = vtkmdiy::RegularDecomposer<vtkmdiy::DiscreteBounds>;
   RegularDecomposer::DivisionsVector diyDivisions(numDims);
+  vtkmdiy::DiscreteBounds diyBounds(numDims);
+  int globalNumberOfBlocks = 1;
+
   for (vtkm::IdComponent d = 0; d < static_cast<vtkm::IdComponent>(numDims); ++d)
   {
-    diyDivisions[d] = static_cast<int>(this->MultiBlockSpatialDecomposition.BlocksPerDimension[d]);
-  }
-
-  // ... compute coordinates of local blocks
-  std::vector<int> vtkmdiyLocalBlockGids(static_cast<size_t>(input.GetNumberOfPartitions()));
-
-  auto localBlockIndicesPortal =
-    this->MultiBlockSpatialDecomposition.LocalBlockIndices.ReadPortal();
-  for (vtkm::Id bi = 0; bi < input.GetNumberOfPartitions(); bi++)
-  {
-    RegularDecomposer::DivisionsVector diyCoords(static_cast<size_t>(numDims));
-    auto currentCoords = localBlockIndicesPortal.Get(bi);
-    for (vtkm::IdComponent d = 0; d < numDims; ++d)
-    {
-      diyCoords[d] = static_cast<int>(currentCoords[d]);
-    }
-    vtkmdiyLocalBlockGids[static_cast<size_t>(bi)] =
-      RegularDecomposer::coords_to_gid(diyCoords, diyDivisions);
+    diyDivisions[d] = static_cast<int>(vtkmBlocksPerDimensionRP.Get(d));
+    globalNumberOfBlocks *= diyDivisions[d];
+    diyBounds.min[d] = 0;
+    diyBounds.max[d] = static_cast<int>(firstGlobalPointDimensions[d]);
   }
 
   // Record time to compute the local block ids
   timingsStream << "    " << std::setw(60) << std::left
-                << "Compute Block Ids and Local Links (Branch Decomposition)"
+                << "Get DIY Information (Branch Decomposition)"
                 << ": " << timer.GetElapsedTime() << " seconds" << std::endl;
   timer.Start();
 
+
   // Initialize branch decomposition computation from data in PartitionedDataSet blocks
+  vtkmdiy::DynamicAssigner assigner(comm, size, globalNumberOfBlocks);
   for (vtkm::Id localBlockIndex = 0; localBlockIndex < input.GetNumberOfPartitions();
        ++localBlockIndex)
   {
-    int globalBlockId = vtkmdiyLocalBlockGids[localBlockIndex];
     const vtkm::cont::DataSet& ds = input.GetPartition(localBlockIndex);
+    int globalBlockId = static_cast<int>(
+      vtkm::cont::ArrayGetValue(0,
+                                ds.GetField("vtkmGlobalBlockId")
+                                  .GetData()
+                                  .AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>()));
+
     BranchDecompositionBlock* newBlock =
       new BranchDecompositionBlock(localBlockIndex, globalBlockId, ds);
     // NOTE: Use dummy link to make DIY happy. The dummy link is never used, since all
@@ -134,6 +136,9 @@ VTKM_CONT vtkm::cont::PartitionedDataSet DistributedBranchDecompositionFilter::D
     // NOTE: Since we passed a "Destroy" function to DIY master, it will own the local data
     //       blocks and delete them when done.
     branch_decomposition_master.add(globalBlockId, newBlock, new vtkmdiy::Link());
+
+    // Tell assigner that this block lives on this rank so that DIY can manage blocks
+    assigner.set_rank(rank, globalBlockId);
   }
 
   // Log time to copy the data to the HyperSweepBlock data objects
@@ -146,19 +151,15 @@ VTKM_CONT vtkm::cont::PartitionedDataSet DistributedBranchDecompositionFilter::D
   RegularDecomposer::BoolVector wrap(3, false);
   RegularDecomposer::CoordinateVector ghosts(3, 1);
   RegularDecomposer decomposer(numDims,
-                               this->MultiBlockSpatialDecomposition.GetVTKmDIYBounds(),
+                               diyBounds,
                                static_cast<int>(globalNumberOfBlocks),
                                shareFace,
                                wrap,
                                ghosts,
                                diyDivisions);
 
-  // Define which blocks live on which rank so that vtkmdiy can manage them
-  vtkmdiy::DynamicAssigner assigner(comm, size, globalNumberOfBlocks);
-
   for (vtkm::Id bi = 0; bi < input.GetNumberOfPartitions(); bi++)
   {
-    assigner.set_rank(rank, vtkmdiyLocalBlockGids[static_cast<size_t>(bi)]);
   }
 
   timingsStream << "    " << std::setw(60) << std::left
@@ -196,7 +197,7 @@ VTKM_CONT vtkm::cont::PartitionedDataSet DistributedBranchDecompositionFilter::D
         ds.GetField("DependentVolume").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
 
       // Get global size and compute total volume from it
-      const auto& globalSize = this->MultiBlockSpatialDecomposition.GlobalSize;
+      const auto& globalSize = firstGlobalPointDimensions;
       vtkm::Id totalVolume = globalSize[0] * globalSize[1] * globalSize[2];
 
       // Compute local best up and down paths by volume
diff --git a/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.h b/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.h
index fc6458694..244bbfa71 100644
--- a/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.h
+++ b/vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.h
@@ -45,8 +45,6 @@
 #include <vtkm/filter/NewFilterField.h>
 #include <vtkm/filter/scalar_topology/vtkm_filter_scalar_topology_export.h>
 
-#include <vtkm/filter/scalar_topology/internal/SpatialDecomposition.h>
-
 namespace vtkm
 {
 namespace filter
@@ -59,20 +57,17 @@ class VTKM_FILTER_SCALAR_TOPOLOGY_EXPORT DistributedBranchDecompositionFilter
   : public vtkm::filter::NewFilter
 {
 public:
-  VTKM_CONT DistributedBranchDecompositionFilter(
-    vtkm::Id3 blocksPerDim,
-    vtkm::Id3 globalSize,
-    const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
-    const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
-    const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes);
+  VTKM_CONT DistributedBranchDecompositionFilter() = default;
+  VTKM_CONT DistributedBranchDecompositionFilter(vtkm::Id3,
+                                                 vtkm::Id3,
+                                                 const vtkm::cont::ArrayHandle<vtkm::Id3>&,
+                                                 const vtkm::cont::ArrayHandle<vtkm::Id3>&,
+                                                 const vtkm::cont::ArrayHandle<vtkm::Id3>&);
 
 private:
   VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet&) override;
   VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData) override;
-
-  /// Information about the spatial decomposition
-  vtkm::filter::scalar_topology::internal::SpatialDecomposition MultiBlockSpatialDecomposition;
 };
 
 } // namespace scalar_topology
diff --git a/vtkm/filter/scalar_topology/internal/CMakeLists.txt b/vtkm/filter/scalar_topology/internal/CMakeLists.txt
index 6585e20c7..896c847f5 100644
--- a/vtkm/filter/scalar_topology/internal/CMakeLists.txt
+++ b/vtkm/filter/scalar_topology/internal/CMakeLists.txt
@@ -10,8 +10,8 @@
 
 set(headers
   BranchDecompositionBlock.h
+  ComputeBlockIndices.h
   ComputeDistributedBranchDecompositionFunctor.h
-  SpatialDecomposition.h
   )
 #-----------------------------------------------------------------------------
 
diff --git a/vtkm/filter/scalar_topology/internal/ComputeBlockIndices.cxx b/vtkm/filter/scalar_topology/internal/ComputeBlockIndices.cxx
new file mode 100644
index 000000000..ff881c797
--- /dev/null
+++ b/vtkm/filter/scalar_topology/internal/ComputeBlockIndices.cxx
@@ -0,0 +1,255 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+// Copyright (c) 2018, The Regents of the University of California, through
+// Lawrence Berkeley National Laboratory (subject to receipt of any required approvals
+// from the U.S. Dept. of Energy).  All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// (1) Redistributions of source code must retain the above copyright notice, this
+//     list of conditions and the following disclaimer.
+//
+// (2) Redistributions in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+// (3) Neither the name of the University of California, Lawrence Berkeley National
+//     Laboratory, U.S. Dept. of Energy nor the names of its contributors may be
+//     used to endorse or promote products derived from this software without
+//     specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//=============================================================================
+//
+//  This code is an extension of the algorithm presented in the paper:
+//  Parallel Peak Pruning for Scalable SMP Contour Tree Computation.
+//  Hamish Carr, Gunther Weber, Christopher Sewell, and James Ahrens.
+//  Proceedings of the IEEE Symposium on Large Data Analysis and Visualization
+//  (LDAV), October 2016, Baltimore, Maryland.
+//
+//  The PPP2 algorithm and software were jointly developed by
+//  Hamish Carr (University of Leeds), Gunther H. Weber (LBNL), and
+//  Oliver Ruebel (LBNL)
+//==============================================================================
+
+#include <algorithm>
+#include <vtkm/cont/CellSetStructured.h>
+#include <vtkm/cont/DataSet.h>
+#include <vtkm/cont/EnvironmentTracker.h>
+#include <vtkm/filter/scalar_topology/internal/ComputeBlockIndices.h>
+#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/CopyIntoCombinedArrayWorklet.h>
+
+namespace // anonymous namespace for local helper classes
+{
+
+struct OriginsBlock
+{
+  std::vector<int> Origins;
+  OriginsBlock(const std::vector<int>& origins)
+    : Origins(origins)
+  {
+  }
+  static void Destroy(void* b) { delete static_cast<OriginsBlock*>(b); }
+};
+
+struct MergeOriginsFunctor
+{
+  void operator()(OriginsBlock* b,
+                  const vtkmdiy::ReduceProxy& rp,     // communication proxy
+                  const vtkmdiy::RegularSwapPartners& // partners of the current block (unused)
+  ) const
+  {
+    const auto selfid = rp.gid();
+
+    std::vector<int> incoming;
+    rp.incoming(incoming);
+    for (const int ingid : incoming)
+    {
+      if (ingid != selfid)
+      {
+        std::vector<int> incoming_origins;
+        rp.dequeue(ingid, incoming_origins);
+
+        std::vector<int> merged_origins;
+        std::merge(incoming_origins.begin(),
+                   incoming_origins.end(),
+                   b->Origins.begin(),
+                   b->Origins.end(),
+                   std::inserter(merged_origins, merged_origins.begin()));
+        auto last = std::unique(merged_origins.begin(), merged_origins.end());
+        merged_origins.erase(last, merged_origins.end());
+        std::swap(merged_origins, b->Origins);
+      }
+    }
+    for (int cc = 0; cc < rp.out_link().size(); ++cc)
+    {
+      auto target = rp.out_link().target(cc);
+      if (target.gid != selfid)
+      {
+        rp.enqueue(target, b->Origins);
+      }
+    }
+  }
+};
+
+}
+namespace vtkm
+{
+namespace filter
+{
+namespace scalar_topology
+{
+namespace internal
+{
+
+VTKM_CONT vtkmdiy::DiscreteBounds ComputeBlockIndices(const vtkm::cont::PartitionedDataSet& input,
+                                                      DiscreteBoundsDivisionVector& diyDivisions,
+                                                      std::vector<int>& diyLocalBlockGids)
+{
+  auto firstDS = input.GetPartition(0);
+  vtkm::Id3 dummy1, firstGlobalPointDimensions, dummy2;
+  firstDS.GetCellSet().CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
+    vtkm::worklet::contourtree_augmented::GetLocalAndGlobalPointDimensions(),
+    dummy1,
+    firstGlobalPointDimensions,
+    dummy2);
+  int numDims = firstGlobalPointDimensions[2] > 1 ? 3 : 2;
+
+  diyDivisions.clear();
+  vtkmdiy::DiscreteBounds diyBounds(numDims);
+  std::vector<DiscreteBoundsDivisionVector> diyBlockCoords(input.GetNumberOfPartitions());
+
+  for (vtkm::IdComponent d = 0; d < numDims; ++d)
+  {
+    // Set bounds for this dimension
+    diyBounds.min[d] = 0;
+    diyBounds.max[d] = static_cast<int>(firstGlobalPointDimensions[d]);
+
+    // Get the list of origins along current coordinate axis
+    std::vector<int> local_origins;
+
+    for (vtkm::Id ds_no = 0; ds_no < input.GetNumberOfPartitions(); ++ds_no)
+    {
+      vtkm::Id3 globalPointIndexStart;
+      input.GetPartition(ds_no)
+        .GetCellSet()
+        .CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
+          vtkm::worklet::contourtree_augmented::GetLocalAndGlobalPointDimensions(),
+          dummy1,
+          dummy2,
+          globalPointIndexStart);
+
+      local_origins.push_back(static_cast<int>(globalPointIndexStart[d]));
+    }
+
+    // Sort and remove duplicates
+    OriginsBlock* origins_block = new OriginsBlock(local_origins);
+    std::sort(origins_block->Origins.begin(), origins_block->Origins.end());
+    auto last = std::unique(origins_block->Origins.begin(), origins_block->Origins.end());
+    origins_block->Origins.erase(last, origins_block->Origins.end());
+
+    // Create global list of origins across all ranks
+    auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
+    auto rank = comm.rank();
+    auto size = comm.size();
+    vtkmdiy::Master master(comm, 1, -1, 0, OriginsBlock::Destroy);
+    master.add(rank, origins_block, new vtkmdiy::Link);
+    vtkmdiy::ContiguousAssigner assigner(size, size);
+    vtkmdiy::DiscreteBounds bounds(1);
+    bounds.min[0] = 0;
+    bounds.max[0] = size - 1;
+    vtkmdiy::RegularDecomposer<vtkmdiy::DiscreteBounds> decomposer(1, bounds, size);
+    vtkmdiy::RegularSwapPartners partners(decomposer, 2, true);
+    vtkmdiy::reduce(master, assigner, partners, MergeOriginsFunctor{});
+
+    // Number of blocks/divisions along axis is number of unique origins along this axis
+    diyDivisions.push_back(static_cast<int>(origins_block->Origins.size()));
+
+    // Block index aling this axis is the index of the origin in that list
+    for (vtkm::Id ds_no = 0; ds_no < input.GetNumberOfPartitions(); ++ds_no)
+    {
+      diyBlockCoords[ds_no].push_back(static_cast<int>(std::find(origins_block->Origins.begin(),
+                                                                 origins_block->Origins.end(),
+                                                                 local_origins[ds_no]) -
+                                                       origins_block->Origins.begin()));
+    }
+  }
+
+  // Compute global block IDs
+  diyLocalBlockGids.clear();
+  for (vtkm::Id ds_no = 0; ds_no < input.GetNumberOfPartitions(); ++ds_no)
+  {
+    diyLocalBlockGids.push_back(vtkmdiy::RegularDecomposer<vtkmdiy::DiscreteBounds>::coords_to_gid(
+      diyBlockCoords[ds_no], diyDivisions));
+  }
+
+  return diyBounds;
+}
+
+VTKM_CONT vtkmdiy::DiscreteBounds ComputeBlockIndices(
+  const vtkm::cont::PartitionedDataSet& input,
+  vtkm::Id3 blocksPerDim,
+  const vtkm::cont::ArrayHandle<vtkm::Id3>& blockIndices,
+  DiscreteBoundsDivisionVector& diyDivisions,
+  std::vector<int>& diyLocalBlockGids)
+{
+  auto firstDS = input.GetPartition(0);
+  vtkm::Id3 dummy1, firstGlobalPointDimensions, dummy2;
+  firstDS.GetCellSet().CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
+    vtkm::worklet::contourtree_augmented::GetLocalAndGlobalPointDimensions(),
+    dummy1,
+    firstGlobalPointDimensions,
+    dummy2);
+  int numDims = firstGlobalPointDimensions[2] > 1 ? 3 : 2;
+
+  diyDivisions.clear();
+  vtkmdiy::DiscreteBounds diyBounds(numDims);
+  for (vtkm::IdComponent d = 0; d < numDims; ++d)
+  {
+    // Set bounds for this dimension
+    diyBounds.min[d] = 0;
+    diyBounds.max[d] = static_cast<int>(firstGlobalPointDimensions[d]);
+    diyDivisions.push_back(static_cast<int>(blocksPerDim[d]));
+  }
+
+  // Compute global block IDs
+  diyLocalBlockGids.clear();
+  auto blockIndicesPortal = blockIndices.ReadPortal();
+  for (vtkm::Id ds_no = 0; ds_no < input.GetNumberOfPartitions(); ++ds_no)
+  {
+    auto currBlockIndices = blockIndicesPortal.Get(ds_no);
+    DiscreteBoundsDivisionVector diyBlockCoords(numDims);
+    for (vtkm::IdComponent d = 0; d < numDims; ++d)
+    {
+      diyBlockCoords[d] = static_cast<int>(currBlockIndices[d]);
+    }
+
+    diyLocalBlockGids.push_back(vtkmdiy::RegularDecomposer<vtkmdiy::DiscreteBounds>::coords_to_gid(
+      diyBlockCoords, diyDivisions));
+  }
+
+  return diyBounds;
+}
+
+} // namespace internal
+} // namespace scalar_topology
+} // namespace filter
+} // namespace vtkm
diff --git a/vtkm/filter/scalar_topology/internal/ComputeBlockIndices.h b/vtkm/filter/scalar_topology/internal/ComputeBlockIndices.h
new file mode 100644
index 000000000..1b492e9b5
--- /dev/null
+++ b/vtkm/filter/scalar_topology/internal/ComputeBlockIndices.h
@@ -0,0 +1,98 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+// Copyright (c) 2018, The Regents of the University of California, through
+// Lawrence Berkeley National Laboratory (subject to receipt of any required approvals
+// from the U.S. Dept. of Energy).  All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// (1) Redistributions of source code must retain the above copyright notice, this
+//     list of conditions and the following disclaimer.
+//
+// (2) Redistributions in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+// (3) Neither the name of the University of California, Lawrence Berkeley National
+//     Laboratory, U.S. Dept. of Energy nor the names of its contributors may be
+//     used to endorse or promote products derived from this software without
+//     specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//=============================================================================
+//
+//  This code is an extension of the algorithm presented in the paper:
+//  Parallel Peak Pruning for Scalable SMP Contour Tree Computation.
+//  Hamish Carr, Gunther Weber, Christopher Sewell, and James Ahrens.
+//  Proceedings of the IEEE Symposium on Large Data Analysis and Visualization
+//  (LDAV), October 2016, Baltimore, Maryland.
+//
+//  The PPP2 algorithm and software were jointly developed by
+//  Hamish Carr (University of Leeds), Gunther H. Weber (LBNL), and
+//  Oliver Ruebel (LBNL)
+//==============================================================================
+
+#ifndef vtk_m_filter_scalar_topology_internal_ComputeBlockIndices_h_
+#define vtk_m_filter_scalar_topology_internal_ComputeBlockIndices_h_
+
+#include <vector>
+
+#include <vtkm/Types.h>
+#include <vtkm/cont/ArrayHandle.h>
+#include <vtkm/cont/PartitionedDataSet.h>
+
+// DIY includes
+// clang-format off
+VTKM_THIRDPARTY_PRE_INCLUDE
+#include <vtkm/thirdparty/diy/Configure.h>
+#include <vtkm/thirdparty/diy/diy.h>
+VTKM_THIRDPARTY_POST_INCLUDE
+// clang-format on
+
+namespace vtkm
+{
+namespace filter
+{
+namespace scalar_topology
+{
+namespace internal
+{
+
+using DiscreteBoundsDivisionVector =
+  vtkmdiy::RegularDecomposer<vtkmdiy::DiscreteBounds>::DivisionsVector;
+
+VTKM_CONT vtkmdiy::DiscreteBounds ComputeBlockIndices(const vtkm::cont::PartitionedDataSet& input,
+                                                      DiscreteBoundsDivisionVector& diyDivisions,
+                                                      std::vector<int>& diyLocalBlockGids);
+
+VTKM_CONT vtkmdiy::DiscreteBounds ComputeBlockIndices(
+  const vtkm::cont::PartitionedDataSet& input,
+  vtkm::Id3 blocksPerDim,
+  const vtkm::cont::ArrayHandle<vtkm::Id3>& blockIndices,
+  DiscreteBoundsDivisionVector& diyDivisions,
+  std::vector<int>& diyLocalBlockGids);
+
+} // namespace internal
+} // namespace scalar_topology
+} // namespace filter
+} // namespace vtkm
+
+#endif
diff --git a/vtkm/filter/scalar_topology/internal/SpatialDecomposition.h b/vtkm/filter/scalar_topology/internal/SpatialDecomposition.h
deleted file mode 100644
index 5ab7ab689..000000000
--- a/vtkm/filter/scalar_topology/internal/SpatialDecomposition.h
+++ /dev/null
@@ -1,172 +0,0 @@
-//============================================================================
-//  Copyright (c) Kitware, Inc.
-//  All rights reserved.
-//  See LICENSE.txt for details.
-//
-//  This software is distributed WITHOUT ANY WARRANTY; without even
-//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-//  PURPOSE.  See the above copyright notice for more information.
-//============================================================================
-// Copyright (c) 2018, The Regents of the University of California, through
-// Lawrence Berkeley National Laboratory (subject to receipt of any required approvals
-// from the U.S. Dept. of Energy).  All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-// (1) Redistributions of source code must retain the above copyright notice, this
-//     list of conditions and the following disclaimer.
-//
-// (2) Redistributions in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-// (3) Neither the name of the University of California, Lawrence Berkeley National
-//     Laboratory, U.S. Dept. of Energy nor the names of its contributors may be
-//     used to endorse or promote products derived from this software without
-//     specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-//=============================================================================
-//
-//  This code is an extension of the algorithm presented in the paper:
-//  Parallel Peak Pruning for Scalable SMP Contour Tree Computation.
-//  Hamish Carr, Gunther Weber, Christopher Sewell, and James Ahrens.
-//  Proceedings of the IEEE Symposium on Large Data Analysis and Visualization
-//  (LDAV), October 2016, Baltimore, Maryland.
-//
-//  The PPP2 algorithm and software were jointly developed by
-//  Hamish Carr (University of Leeds), Gunther H. Weber (LBNL), and
-//  Oliver Ruebel (LBNL)
-//==============================================================================
-
-#ifndef vtk_m_filter_scalar_topology_internal_SpatialDecomposition_h
-#define vtk_m_filter_scalar_topology_internal_SpatialDecomposition_h
-
-#include <vtkm/Types.h>
-#include <vtkm/cont/BoundsCompute.h>
-#include <vtkm/cont/BoundsGlobalCompute.h>
-#include <vtkm/cont/EnvironmentTracker.h>
-#include <vtkm/cont/PartitionedDataSet.h>
-
-#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
-
-// clang-format off
-VTKM_THIRDPARTY_PRE_INCLUDE
-#include <vtkm/thirdparty/diy/diy.h>
-VTKM_THIRDPARTY_POST_INCLUDE
-// clang-format on
-
-namespace vtkm
-{
-namespace filter
-{
-namespace scalar_topology
-{
-namespace internal
-{
-
-// --- Helper class to store the spatial decomposition defined by the PartitionedDataSet input data
-class SpatialDecomposition
-{
-public:
-  VTKM_CONT
-  SpatialDecomposition(vtkm::Id3 blocksPerDim,
-                       vtkm::Id3 globalSize,
-                       const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
-                       const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
-                       const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes)
-    : BlocksPerDimension(blocksPerDim)
-    , GlobalSize(globalSize)
-    , LocalBlockIndices(localBlockIndices)
-    , LocalBlockOrigins(localBlockOrigins)
-    , LocalBlockSizes(localBlockSizes)
-  {
-  }
-
-  inline vtkmdiy::DiscreteBounds GetVTKmDIYBounds() const
-  {
-    if (this->NumberOfDimensions() == 2)
-    {
-      vtkmdiy::DiscreteBounds domain(2);
-      domain.min[0] = domain.min[1] = 0;
-      domain.max[0] = static_cast<int>(this->GlobalSize[0]);
-      domain.max[1] = static_cast<int>(this->GlobalSize[1]);
-      return domain;
-    }
-    else
-    {
-      vtkmdiy::DiscreteBounds domain(3);
-      domain.min[0] = domain.min[1] = domain.min[2] = 0;
-      domain.max[0] = static_cast<int>(this->GlobalSize[0]);
-      domain.max[1] = static_cast<int>(this->GlobalSize[1]);
-      domain.max[2] = static_cast<int>(this->GlobalSize[2]);
-      return domain;
-    }
-  }
-
-  inline vtkm::Id NumberOfDimensions() const { return GlobalSize[2] > 1 ? 3 : 2; }
-
-  inline vtkm::Id GetGlobalNumberOfBlocks() const
-  {
-    return BlocksPerDimension[0] * BlocksPerDimension[1] * BlocksPerDimension[2];
-  }
-
-  inline vtkm::Id GetLocalNumberOfBlocks() const { return LocalBlockSizes.GetNumberOfValues(); }
-
-  inline static vtkm::Bounds GetGlobalBounds(const vtkm::cont::PartitionedDataSet& input)
-  {
-    // Get the  spatial bounds  of a multi -block  data  set
-    vtkm::Bounds bounds = vtkm::cont::BoundsGlobalCompute(input);
-    return bounds;
-  }
-
-  inline static vtkm::Bounds GetLocalBounds(const vtkm::cont::PartitionedDataSet& input)
-  {
-    // Get the spatial bounds  of a multi -block  data  set
-    vtkm::Bounds bounds = vtkm::cont::BoundsCompute(input);
-    return bounds;
-  }
-
-  inline static vtkm::Id GetGlobalNumberOfBlocks(const vtkm::cont::PartitionedDataSet& input)
-  {
-    auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
-    vtkm::Id localSize = input.GetNumberOfPartitions();
-    vtkm::Id globalSize = 0;
-#ifdef VTKM_ENABLE_MPI
-    vtkmdiy::mpi::all_reduce(comm, localSize, globalSize, std::plus<vtkm::Id>{});
-#else
-    globalSize = localSize;
-#endif
-    return globalSize;
-  }
-
-  // Number of blocks along each dimension
-  vtkm::Id3 BlocksPerDimension;
-  // Size of the global mesh
-  vtkm::Id3 GlobalSize;
-  // Index of the local blocks in x,y,z, i.e., in i,j,k mesh coordinates
-  vtkm::cont::ArrayHandle<vtkm::Id3> LocalBlockIndices;
-  // Origin of the local blocks in mesh index space
-  vtkm::cont::ArrayHandle<vtkm::Id3> LocalBlockOrigins;
-  // Size of each local block in x, y,z
-  vtkm::cont::ArrayHandle<vtkm::Id3> LocalBlockSizes;
-};
-
-
-} // internal
-} // namespace scalar_topology
-} // namespace filter
-} // namespace vtkm
-
-#endif
diff --git a/vtkm/filter/scalar_topology/testing/TestingContourTreeUniformDistributedFilter.h b/vtkm/filter/scalar_topology/testing/TestingContourTreeUniformDistributedFilter.h
index 2747866c2..431ef376a 100644
--- a/vtkm/filter/scalar_topology/testing/TestingContourTreeUniformDistributedFilter.h
+++ b/vtkm/filter/scalar_topology/testing/TestingContourTreeUniformDistributedFilter.h
@@ -203,12 +203,22 @@ inline vtkm::cont::DataSet CreateSubDataSet(const vtkm::cont::DataSet& ds,
   {
     vtkm::Id2 dimensions{ blockSize[0], blockSize[1] };
     vtkm::cont::DataSet dataSet = dsb.Create(dimensions);
+    vtkm::cont::CellSetStructured<2> cellSet;
+    cellSet.SetPointDimensions(dimensions);
+    cellSet.SetGlobalPointDimensions(vtkm::Id2{ globalSize[0], globalSize[1] });
+    cellSet.SetGlobalPointIndexStart(vtkm::Id2{ blockOrigin[0], blockOrigin[1] });
+    dataSet.SetCellSet(cellSet);
     dataSet.AddField(permutedField);
     return dataSet;
   }
   else
   {
     vtkm::cont::DataSet dataSet = dsb.Create(blockSize);
+    vtkm::cont::CellSetStructured<3> cellSet;
+    cellSet.SetPointDimensions(blockSize);
+    cellSet.SetGlobalPointDimensions(globalSize);
+    cellSet.SetGlobalPointIndexStart(blockOrigin);
+    dataSet.SetCellSet(cellSet);
     dataSet.AddField(permutedField);
     return dataSet;
   }
@@ -241,7 +251,8 @@ inline vtkm::cont::PartitionedDataSet RunContourTreeDUniformDistributed(
   int numberOfRanks,
   bool augmentHierarchicalTree,
   bool computeHierarchicalVolumetricBranchDecomposition,
-  vtkm::Id3& globalSize)
+  vtkm::Id3& globalSize,
+  bool passBlockIndices = true)
 {
   // Get dimensions of data set
   vtkm::cont::CastAndCall(
@@ -267,15 +278,9 @@ inline vtkm::cont::PartitionedDataSet RunContourTreeDUniformDistributed(
   // Created partitioned (split) data set
   vtkm::cont::PartitionedDataSet pds;
   vtkm::cont::ArrayHandle<vtkm::Id3> localBlockIndices;
-  vtkm::cont::ArrayHandle<vtkm::Id3> localBlockOrigins;
-  vtkm::cont::ArrayHandle<vtkm::Id3> localBlockSizes;
   localBlockIndices.Allocate(blocksOnThisRank);
-  localBlockOrigins.Allocate(blocksOnThisRank);
-  localBlockSizes.Allocate(blocksOnThisRank);
 
   auto localBlockIndicesPortal = localBlockIndices.WritePortal();
-  auto localBlockOriginsPortal = localBlockOrigins.WritePortal();
-  auto localBlockSizesPortal = localBlockSizes.WritePortal();
 
   for (vtkm::Id blockNo = 0; blockNo < blocksOnThisRank; ++blockNo)
   {
@@ -283,20 +288,17 @@ inline vtkm::cont::PartitionedDataSet RunContourTreeDUniformDistributed(
     std::tie(blockIndex, blockOrigin, blockSize) =
       ComputeBlockExtents(globalSize, blocksPerAxis, startBlockNo + blockNo);
     pds.AppendPartition(CreateSubDataSet(ds, blockOrigin, blockSize, fieldName));
-    localBlockOriginsPortal.Set(blockNo, blockOrigin);
-    localBlockSizesPortal.Set(blockNo, blockSize);
     localBlockIndicesPortal.Set(blockNo, blockIndex);
   }
 
   // Run the contour tree analysis
   vtkm::filter::scalar_topology::ContourTreeUniformDistributed filter(
-    blocksPerAxis,
-    globalSize,
-    localBlockIndices,
-    localBlockOrigins,
-    localBlockSizes,
-    vtkm::cont::LogLevel::UserVerboseLast,
-    vtkm::cont::LogLevel::UserVerboseLast);
+    vtkm::cont::LogLevel::UserVerboseLast, vtkm::cont::LogLevel::UserVerboseLast);
+
+  if (passBlockIndices)
+  {
+    filter.SetBlockIndices(blocksPerAxis, localBlockIndices);
+  }
 
   filter.SetUseMarchingCubes(useMarchingCubes);
   // Freudenthal: Only use boundary extrema; MC: use all points on boundary
@@ -310,8 +312,7 @@ inline vtkm::cont::PartitionedDataSet RunContourTreeDUniformDistributed(
   {
     using vtkm::filter::scalar_topology::DistributedBranchDecompositionFilter;
 
-    DistributedBranchDecompositionFilter bd_filter(
-      blocksPerAxis, globalSize, localBlockIndices, localBlockOrigins, localBlockSizes);
+    DistributedBranchDecompositionFilter bd_filter;
     result = bd_filter.Execute(result);
   }
 
@@ -387,7 +388,8 @@ inline vtkm::cont::PartitionedDataSet RunContourTreeDUniformDistributed(
   int rank = 0,
   int numberOfRanks = 1,
   bool augmentHierarchicalTree = false,
-  bool computeHierarchicalVolumetricBranchDecomposition = false)
+  bool computeHierarchicalVolumetricBranchDecomposition = false,
+  bool passBlockIndices = true)
 {
   vtkm::Id3 globalSize;
 
@@ -399,7 +401,8 @@ inline vtkm::cont::PartitionedDataSet RunContourTreeDUniformDistributed(
                                            numberOfRanks,
                                            augmentHierarchicalTree,
                                            computeHierarchicalVolumetricBranchDecomposition,
-                                           globalSize);
+                                           globalSize,
+                                           passBlockIndices);
 }
 
 inline void TestContourTreeUniformDistributed8x9(int nBlocks, int rank = 0, int size = 1)
@@ -575,7 +578,8 @@ inline void TestContourTreeFile(std::string ds_filename,
                                 int rank = 0,
                                 int size = 1,
                                 bool augmentHierarchicalTree = false,
-                                bool computeHierarchicalVolumetricBranchDecomposition = false)
+                                bool computeHierarchicalVolumetricBranchDecomposition = false,
+                                bool passBlockIndices = true)
 {
   if (rank == 0)
   {
@@ -611,7 +615,8 @@ inline void TestContourTreeFile(std::string ds_filename,
                                       size,
                                       augmentHierarchicalTree,
                                       computeHierarchicalVolumetricBranchDecomposition,
-                                      globalSize);
+                                      globalSize,
+                                      passBlockIndices);
 
   if (rank == 0)
   {
diff --git a/vtkm/filter/scalar_topology/testing/UnitTestContourTreeUniformDistributedFilter.cxx b/vtkm/filter/scalar_topology/testing/UnitTestContourTreeUniformDistributedFilter.cxx
index 35e878c32..e37194004 100644
--- a/vtkm/filter/scalar_topology/testing/UnitTestContourTreeUniformDistributedFilter.cxx
+++ b/vtkm/filter/scalar_topology/testing/UnitTestContourTreeUniformDistributedFilter.cxx
@@ -112,6 +112,16 @@ public:
                         1,
                         true,
                         false);
+    TestContourTreeFile(Testing::DataPath("rectilinear/vanc.vtk"),
+                        "var",
+                        Testing::RegressionImagePath("vanc.augment_hierarchical_tree.ct_txt"),
+                        4,
+                        false,
+                        0,
+                        1,
+                        true,
+                        false,
+                        false);
   }
 };
 }
diff --git a/vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h b/vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h
index f9752a05f..1927b3831 100644
--- a/vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h
+++ b/vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h
@@ -328,6 +328,47 @@ struct GetPointDimensions
   }
 };
 
+
+struct GetLocalAndGlobalPointDimensions
+{
+  void operator()(const vtkm::cont::CellSetStructured<2>& cells,
+                  vtkm::Id3& pointDimensions,
+                  vtkm::Id3& globalPointDimensions,
+                  vtkm::Id3& globalPointIndexStart) const
+  {
+    vtkm::Id2 pointDimensions2D = cells.GetPointDimensions();
+    pointDimensions[0] = pointDimensions2D[0];
+    pointDimensions[1] = pointDimensions2D[1];
+    pointDimensions[2] = 1;
+    vtkm::Id2 globalPointDimensions2D = cells.GetGlobalPointDimensions();
+    globalPointDimensions[0] = globalPointDimensions2D[0];
+    globalPointDimensions[1] = globalPointDimensions2D[1];
+    globalPointDimensions[2] = 1;
+    vtkm::Id2 pointIndexStart2D = cells.GetGlobalPointIndexStart();
+    globalPointIndexStart[0] = pointIndexStart2D[0];
+    globalPointIndexStart[1] = pointIndexStart2D[1];
+    globalPointIndexStart[2] = 0;
+  }
+  void operator()(const vtkm::cont::CellSetStructured<3>& cells,
+                  vtkm::Id3& pointDimensions,
+                  vtkm::Id3& globalPointDimensions,
+                  vtkm::Id3& globalPointIndexStart) const
+  {
+    pointDimensions = cells.GetPointDimensions();
+    globalPointDimensions = cells.GetGlobalPointDimensions();
+    globalPointIndexStart = cells.GetGlobalPointIndexStart();
+  }
+  //@}
+
+
+  ///  Raise ErrorBadValue if the input cell set is not a vtkm::cont::CellSetStructured<2> or <3>
+  template <typename T>
+  void operator()(const T&, vtkm::Id3&, vtkm::Id3&, vtkm::Id3&) const
+  {
+    throw vtkm::cont::ErrorBadValue("Expected 2D or 3D structured cell cet! ");
+  }
+};
+
 } // namespace contourtree_augmented
 } // worklet
 } // vtkm
diff --git a/vtkm/filter/scalar_topology/worklet/contourtree_distributed/MultiBlockContourTreeHelper.h b/vtkm/filter/scalar_topology/worklet/contourtree_distributed/MultiBlockContourTreeHelper.h
index ba9095521..5aad7f3ae 100644
--- a/vtkm/filter/scalar_topology/worklet/contourtree_distributed/MultiBlockContourTreeHelper.h
+++ b/vtkm/filter/scalar_topology/worklet/contourtree_distributed/MultiBlockContourTreeHelper.h
@@ -53,15 +53,12 @@
 #ifndef vtk_m_worklet_contourtree_distributed_multiblockcontourtreehelper_h
 #define vtk_m_worklet_contourtree_distributed_multiblockcontourtreehelper_h
 
-#include <vtkm/filter/scalar_topology/internal/SpatialDecomposition.h>
-
 #include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
 
 #include <vtkm/Types.h>
 #include <vtkm/cont/BoundsCompute.h>
 #include <vtkm/cont/BoundsGlobalCompute.h>
-//#include <vtkm/cont/AssignerPartitionedDataSet.h>
 #include <vtkm/cont/ErrorFilterExecution.h>
 #include <vtkm/cont/PartitionedDataSet.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h>
@@ -79,19 +76,21 @@ class MultiBlockContourTreeHelper
 public:
   VTKM_CONT
   MultiBlockContourTreeHelper(vtkm::Id3 blocksPerDim,
-                              vtkm::Id3 globalSize,
-                              const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
-                              const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
-                              const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes)
-    : MultiBlockSpatialDecomposition(blocksPerDim,
-                                     globalSize,
-                                     localBlockIndices,
-                                     localBlockOrigins,
-                                     localBlockSizes)
+                              const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices)
+    : BlocksPerDimension(blocksPerDim)
+    , LocalBlockIndices(localBlockIndices)
+    , LocalContourTrees(static_cast<size_t>(localBlockIndices.GetNumberOfValues()))
+    , LocalSortOrders(static_cast<size_t>(localBlockIndices.GetNumberOfValues()))
+  {
+  }
+
+  VTKM_CONT
+  MultiBlockContourTreeHelper(const vtkm::cont::PartitionedDataSet& input)
+    : BlocksPerDimension(-1, -1, -1)
+    , LocalBlockIndices()
+    , LocalContourTrees(static_cast<size_t>(input.GetNumberOfPartitions()))
+    , LocalSortOrders(static_cast<size_t>(input.GetNumberOfPartitions()))
   {
-    vtkm::Id localNumBlocks = this->GetLocalNumberOfBlocks();
-    LocalContourTrees.resize(static_cast<std::size_t>(localNumBlocks));
-    LocalSortOrders.resize(static_cast<std::size_t>(localNumBlocks));
   }
 
   VTKM_CONT
@@ -118,25 +117,12 @@ public:
 
   inline vtkm::Id GetLocalNumberOfBlocks() const
   {
-    return this->MultiBlockSpatialDecomposition.GetLocalNumberOfBlocks();
+    return static_cast<vtkm::Id>(this->LocalContourTrees.size());
   }
 
   inline vtkm::Id GetGlobalNumberOfBlocks() const
   {
-    return this->MultiBlockSpatialDecomposition.GetGlobalNumberOfBlocks();
-  }
-
-  inline static vtkm::Id GetGlobalNumberOfBlocks(const vtkm::cont::PartitionedDataSet& input)
-  {
-    auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
-    vtkm::Id localSize = input.GetNumberOfPartitions();
-    vtkm::Id globalSize = 0;
-#ifdef VTKM_ENABLE_MPI
-    vtkmdiy::mpi::all_reduce(comm, localSize, globalSize, std::plus<vtkm::Id>{});
-#else
-    globalSize = localSize;
-#endif
-    return globalSize;
+    return this->BlocksPerDimension[0] * this->BlocksPerDimension[1] * this->BlocksPerDimension[2];
   }
 
   // Used to compute the local contour tree mesh in after DoExecute. I.e., the function is
@@ -198,7 +184,8 @@ public:
     }
   }
 
-  vtkm::filter::scalar_topology::internal::SpatialDecomposition MultiBlockSpatialDecomposition;
+  vtkm::Id3 BlocksPerDimension;
+  vtkm::cont::ArrayHandle<vtkm::Id3> LocalBlockIndices;
   std::vector<vtkm::worklet::contourtree_augmented::ContourTree> LocalContourTrees;
   std::vector<vtkm::worklet::contourtree_augmented::IdArrayType> LocalSortOrders;
 }; // end MultiBlockContourTreeHelper
diff --git a/vtkm/internal/ConnectivityStructuredInternals.h b/vtkm/internal/ConnectivityStructuredInternals.h
index 5240850ae..7e2e0717a 100644
--- a/vtkm/internal/ConnectivityStructuredInternals.h
+++ b/vtkm/internal/ConnectivityStructuredInternals.h
@@ -37,15 +37,24 @@ public:
   VTKM_EXEC_CONT
   void SetPointDimensions(vtkm::Id dimensions) { this->PointDimensions = dimensions; }
 
+  VTKM_EXEC_CONT
+  void SetGlobalPointDimensions(vtkm::Id dimensions) { this->GlobalPointDimensions = dimensions; }
+
   VTKM_EXEC_CONT
   void SetGlobalPointIndexStart(vtkm::Id start) { this->GlobalPointIndexStart = start; }
 
   VTKM_EXEC_CONT
   vtkm::Id GetPointDimensions() const { return this->PointDimensions; }
 
+  VTKM_EXEC_CONT
+  vtkm::Id GetGlobalPointDimensions() const { return this->GlobalPointDimensions; }
+
   VTKM_EXEC_CONT
   vtkm::Id GetCellDimensions() const { return this->PointDimensions - 1; }
 
+  VTKM_EXEC_CONT
+  vtkm::Id GetGlobalCellDimensions() const { return this->GlobalPointDimensions - 1; }
+
   VTKM_EXEC_CONT
   SchedulingRangeType GetSchedulingRange(vtkm::TopologyElementTagCell) const
   {
@@ -138,12 +147,15 @@ public:
   void PrintSummary(std::ostream& out) const
   {
     out << "   UniformConnectivity<1> ";
-    out << "this->PointDimensions[" << this->PointDimensions << "] ";
+    out << "PointDimensions[" << this->PointDimensions << "] ";
+    out << "GlobalPointDimensions[" << this->GlobalPointDimensions << "] ";
+    out << "GlobalPointIndexStart[" << this->GlobalPointIndexStart << "] ";
     out << "\n";
   }
 
 private:
   vtkm::Id PointDimensions = 0;
+  vtkm::Id GlobalPointDimensions = 0;
   vtkm::Id GlobalPointIndexStart = 0;
 };
 
@@ -157,15 +169,24 @@ public:
   VTKM_EXEC_CONT
   void SetPointDimensions(vtkm::Id2 dims) { this->PointDimensions = dims; }
 
+  VTKM_EXEC_CONT
+  void SetGlobalPointDimensions(vtkm::Id2 dims) { this->GlobalPointDimensions = dims; }
+
   VTKM_EXEC_CONT
   void SetGlobalPointIndexStart(vtkm::Id2 start) { this->GlobalPointIndexStart = start; }
 
   VTKM_EXEC_CONT
   const vtkm::Id2& GetPointDimensions() const { return this->PointDimensions; }
 
+  VTKM_EXEC_CONT
+  const vtkm::Id2& GetGlobalPointDimensions() const { return this->GlobalPointDimensions; }
+
   VTKM_EXEC_CONT
   vtkm::Id2 GetCellDimensions() const { return this->PointDimensions - vtkm::Id2(1); }
 
+  VTKM_EXEC_CONT
+  vtkm::Id2 GetGlobalCellDimensions() const { return this->GlobalPointDimensions - vtkm::Id2(1); }
+
   VTKM_EXEC_CONT
   vtkm::Id GetNumberOfPoints() const { return vtkm::ReduceProduct(this->GetPointDimensions()); }
 
@@ -303,12 +324,18 @@ public:
   void PrintSummary(std::ostream& out) const
   {
     out << "   UniformConnectivity<2> ";
-    out << "pointDim[" << this->PointDimensions[0] << " " << this->PointDimensions[1] << "] ";
+    out << "PointDimensions[" << this->PointDimensions[0] << " " << this->PointDimensions[1]
+        << "] ";
+    out << "GlobalPointDimensions[" << this->GlobalPointDimensions[0] << " "
+        << this->GlobalPointDimensions[1] << "] ";
+    out << "GlobalPointIndexStart[" << this->GlobalPointIndexStart[0] << " "
+        << this->GlobalPointIndexStart[1] << "] ";
     out << std::endl;
   }
 
 private:
   vtkm::Id2 PointDimensions = { 0, 0 };
+  vtkm::Id2 GlobalPointDimensions = { 0, 0 };
   vtkm::Id2 GlobalPointIndexStart = { 0, 0 };
 };
 
@@ -327,15 +354,28 @@ public:
     this->CellDim01 = (dims[0] - 1) * (dims[1] - 1);
   }
 
+  VTKM_EXEC_CONT
+  void SetGlobalPointDimensions(vtkm::Id3 dims)
+  {
+    this->GlobalPointDimensions = dims;
+    this->GlobalCellDimensions = dims - vtkm::Id3(1);
+  }
+
   VTKM_EXEC_CONT
   void SetGlobalPointIndexStart(vtkm::Id3 start) { this->GlobalPointIndexStart = start; }
 
   VTKM_EXEC_CONT
   const vtkm::Id3& GetPointDimensions() const { return this->PointDimensions; }
 
+  VTKM_EXEC_CONT
+  const vtkm::Id3& GetGlobalPointDimensions() const { return this->GlobalPointDimensions; }
+
   VTKM_EXEC_CONT
   const vtkm::Id3& GetCellDimensions() const { return this->CellDimensions; }
 
+  VTKM_EXEC_CONT
+  const vtkm::Id3& GetGlobalCellDimensions() const { return this->GlobalCellDimensions; }
+
   VTKM_EXEC_CONT
   vtkm::Id GetNumberOfPoints() const { return vtkm::ReduceProduct(this->PointDimensions); }
 
@@ -466,8 +506,12 @@ public:
   void PrintSummary(std::ostream& out) const
   {
     out << "   UniformConnectivity<3> ";
-    out << "pointDim[" << this->PointDimensions[0] << " " << this->PointDimensions[1] << " "
+    out << "PointDimensions[" << this->PointDimensions[0] << " " << this->PointDimensions[1] << " "
         << this->PointDimensions[2] << "] ";
+    out << "GlobalPointDimensions[" << this->GlobalPointDimensions[0] << " "
+        << this->GlobalPointDimensions[1] << " " << this->GlobalPointDimensions[2] << "] ";
+    out << "GlobalPointIndexStart[" << this->GlobalPointIndexStart[0] << " "
+        << this->GlobalPointIndexStart[1] << " " << this->GlobalPointIndexStart[2] << "] ";
     out << std::endl;
   }
 
@@ -509,6 +553,8 @@ public:
 
 private:
   vtkm::Id3 PointDimensions = { 0, 0, 0 };
+  vtkm::Id3 GlobalPointDimensions = { 0, 0, 0 };
+  vtkm::Id3 GlobalCellDimensions = { 0, 0, 0 };
   vtkm::Id3 GlobalPointIndexStart = { 0, 0, 0 };
   vtkm::Id3 CellDimensions = { 0, 0, 0 };
   vtkm::Id CellDim01 = 0;
diff --git a/vtkm/worklet/testing/UnitTestContourTreeUniformDistributed.cxx b/vtkm/worklet/testing/UnitTestContourTreeUniformDistributed.cxx
index 41e773088..e5c68258f 100644
--- a/vtkm/worklet/testing/UnitTestContourTreeUniformDistributed.cxx
+++ b/vtkm/worklet/testing/UnitTestContourTreeUniformDistributed.cxx
@@ -55,7 +55,6 @@
 
 #include <vtkm/cont/testing/MakeTestDataSet.h>
 #include <vtkm/cont/testing/Testing.h>
-#include <vtkm/filter/scalar_topology/internal/SpatialDecomposition.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/DataSetMesh.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
 #include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
@@ -154,7 +153,6 @@ void TestHierarchicalHyperSweeper()
                                        "misc/8x9test_HierarchicalAugmentedTree_Block2.dat",
                                        "misc/8x9test_HierarchicalAugmentedTree_Block3.dat" };
   vtkm::Id3 globalSize{ 9, 8, 1 };
-  vtkm::Id3 blocksPerDim{ 2, 2, 1 };
   vtkm::Id3 sizes[numBlocks] = { { 5, 4, 1 }, { 5, 5, 1 }, { 5, 4, 1 }, { 5, 5, 1 } };
   vtkm::Id3 origins[numBlocks] = { { 0, 0, 0 }, { 0, 3, 0 }, { 4, 0, 0 }, { 4, 3, 0 } };
   vtkm::Id3 blockIndices[numBlocks] = { { 0, 0, 0 }, { 0, 1, 0 }, { 1, 0, 0 }, { 1, 1, 0 } };
@@ -174,14 +172,6 @@ void TestHierarchicalHyperSweeper()
     vtkm::cont::make_ArrayHandle<vtkm::Id>({ 6, 9, 18, 24, 46, 72, 2 })
   };
 
-  // Create spatial decomposition
-  vtkm::filter::scalar_topology::internal::SpatialDecomposition spatialDecomp(
-    blocksPerDim,
-    globalSize,
-    vtkm::cont::make_ArrayHandle(blockIndices, numBlocks, vtkm::CopyFlag::Off),
-    vtkm::cont::make_ArrayHandle(origins, numBlocks, vtkm::CopyFlag::Off),
-    vtkm::cont::make_ArrayHandle(sizes, numBlocks, vtkm::CopyFlag::Off));
-
   // Load trees
   vtkm::worklet::contourtree_distributed::HierarchicalContourTree<vtkm::FloatDefault>
     hct[numBlocks];
@@ -209,22 +199,21 @@ void TestHierarchicalHyperSweeper()
   RegularDecomposer::CoordinateVector ghosts(3, 1);
   RegularDecomposer::DivisionsVector diyDivisions{ 2, 2, 1 }; // HARDCODED FOR TEST
 
-  int numDims = static_cast<int>(globalSize[2] > 1 ? 3 : 2);
-  RegularDecomposer decomposer(numDims,
-                               spatialDecomp.GetVTKmDIYBounds(),
-                               static_cast<int>(spatialDecomp.GetGlobalNumberOfBlocks()),
-                               shareFace,
-                               wrap,
-                               ghosts,
-                               diyDivisions);
+  int numDims = 2;
+  vtkmdiy::DiscreteBounds diyBounds(2);
+  diyBounds.min[0] = diyBounds.min[1] = 0;
+  diyBounds.max[0] = static_cast<int>(globalSize[0]);
+  diyBounds.max[1] = static_cast<int>(globalSize[1]);
+
+  RegularDecomposer decomposer(
+    numDims, diyBounds, numBlocks, shareFace, wrap, ghosts, diyDivisions);
 
   // ... coordinates of local blocks
-  auto localBlockIndicesPortal = spatialDecomp.LocalBlockIndices.ReadPortal();
   std::vector<int> vtkmdiyLocalBlockGids(numBlocks);
   for (vtkm::Id bi = 0; bi < numBlocks; bi++)
   {
     RegularDecomposer::DivisionsVector diyCoords(static_cast<size_t>(numDims));
-    auto currentCoords = localBlockIndicesPortal.Get(bi);
+    auto currentCoords = blockIndices[bi];
     for (vtkm::IdComponent d = 0; d < numDims; ++d)
     {
       diyCoords[d] = static_cast<int>(currentCoords[d]);
@@ -234,8 +223,7 @@ void TestHierarchicalHyperSweeper()
   }
 
   // Define which blocks live on which rank so that vtkmdiy can manage them
-  vtkmdiy::DynamicAssigner assigner(
-    comm, comm.size(), static_cast<int>(spatialDecomp.GetGlobalNumberOfBlocks()));
+  vtkmdiy::DynamicAssigner assigner(comm, comm.size(), numBlocks);
   for (vtkm::Id bi = 0; bi < numBlocks; bi++)
   {
     assigner.set_rank(static_cast<int>(rank),

From 25c62250816a137ef2e7b945881897151315c076 Mon Sep 17 00:00:00 2001
From: Dave Pugmire <dpugmire@gmail.com>
Date: Wed, 3 Aug 2022 11:56:34 -0400
Subject: [PATCH 096/104] Use ScatterCounting instead of ScatterPermutation.

---
 .../filter/geometry_refinement/worklet/Tube.h | 23 ++++++++-----------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/vtkm/filter/geometry_refinement/worklet/Tube.h b/vtkm/filter/geometry_refinement/worklet/Tube.h
index cc4c0c377..22be15f6e 100644
--- a/vtkm/filter/geometry_refinement/worklet/Tube.h
+++ b/vtkm/filter/geometry_refinement/worklet/Tube.h
@@ -18,7 +18,7 @@
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/UnknownCellSet.h>
 #include <vtkm/worklet/DispatcherMapTopology.h>
-#include <vtkm/worklet/ScatterPermutation.h>
+#include <vtkm/worklet/ScatterCounting.h>
 #include <vtkm/worklet/WorkletMapField.h>
 #include <vtkm/worklet/WorkletMapTopology.h>
 
@@ -146,11 +146,11 @@ public:
                                     _3 polylineOffset,
                                     _4 outNormals);
     using InputDomain = _1;
-    using ScatterType = vtkm::worklet::ScatterPermutation<>;
+    using ScatterType = vtkm::worklet::ScatterCounting;
     VTKM_CONT
-    static ScatterType MakeScatter(const vtkm::cont::ArrayHandle<vtkm::Id>& validIds)
+    static ScatterType MakeScatter(const vtkm::cont::ArrayHandle<vtkm::Id>& validCell)
     {
-      return ScatterType(validIds);
+      return ScatterType(validCell);
     }
 
     template <typename InPointsType, typename PointIndexType>
@@ -322,11 +322,11 @@ public:
                                     _7 outPts,
                                     _8 outPointSrcIdx);
     using InputDomain = _1;
-    using ScatterType = vtkm::worklet::ScatterPermutation<>;
+    using ScatterType = vtkm::worklet::ScatterCounting;
     VTKM_CONT
-    static ScatterType MakeScatter(const vtkm::cont::ArrayHandle<vtkm::Id>& validIds)
+    static ScatterType MakeScatter(const vtkm::cont::ArrayHandle<vtkm::Id>& validCell)
     {
-      return ScatterType(validIds);
+      return ScatterType(validCell);
     }
 
     template <typename CellShapeTag,
@@ -654,16 +654,11 @@ public:
     vtkm::cont::Algorithm::ScanExclusive(numTubeConnIds, tubeConnOffsets);
     vtkm::cont::Algorithm::ScanExclusive(segPerPolyline, segOffset);
 
-    //Skip any cells marked invalid.
-    vtkm::cont::ArrayHandle<vtkm::Id> validIds;
-    vtkm::cont::Algorithm::CopyIf(
-      vtkm::cont::ArrayHandleIndex(cellset.GetNumberOfCells()), validCell, validIds);
-
     //Generate normals at each point on all polylines
     NormalsType normals;
     normals.Allocate(totalPolylinePts);
     vtkm::worklet::DispatcherMapTopology<GenerateNormals> genNormalsDisp(
-      GenerateNormals::MakeScatter(validIds));
+      GenerateNormals::MakeScatter(validCell));
     genNormalsDisp.Invoke(cellset, coords, polylinePtOffset, normals);
 
     //Generate the tube points
@@ -671,7 +666,7 @@ public:
     this->OutputPointSourceIndex.Allocate(totalTubePts);
     GeneratePoints genPts(this->Capping, this->NumSides, this->Radius);
     vtkm::worklet::DispatcherMapTopology<GeneratePoints> genPtsDisp(
-      genPts, GeneratePoints::MakeScatter(validIds));
+      genPts, GeneratePoints::MakeScatter(validCell));
     genPtsDisp.Invoke(cellset,
                       coords,
                       normals,

From 27305faff3da8c59053fadadb666ad663d1ec8d3 Mon Sep 17 00:00:00 2001
From: Li-Ta Lo <ollie@lanl.gov>
Date: Wed, 3 Aug 2022 10:05:03 -0600
Subject: [PATCH 097/104] Privatize NewFilterParticleAdvection::DoExecute

---
 vtkm/filter/flow/NewFilterParticleAdvection.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index a5e54738d..0cae7a30b 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -64,7 +64,6 @@ public:
   void SetUseThreadedAlgorithm(bool val) { this->UseThreadedAlgorithm = val; }
 
 protected:
-  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
   VTKM_CONT virtual void ValidateOptions() const;
 
   VTKM_CONT virtual vtkm::filter::flow::FlowResultType GetResultType() const
@@ -82,6 +81,7 @@ protected:
     vtkm::filter::flow::VectorFieldType::VELOCITY_FIELD_TYPE;
 
 private:
+  VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
 };
 
 }

From d1d97ec05721b6fe7c8ae19dddf9bcf8f33278f8 Mon Sep 17 00:00:00 2001
From: Li-Ta Lo <ollie@lanl.gov>
Date: Wed, 3 Aug 2022 11:15:35 -0600
Subject: [PATCH 098/104] make NewFilterParticleAdvection::GetResultType pure

---
 vtkm/filter/flow/NewFilterParticleAdvection.h | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/vtkm/filter/flow/NewFilterParticleAdvection.h b/vtkm/filter/flow/NewFilterParticleAdvection.h
index a5e54738d..83f932dc0 100644
--- a/vtkm/filter/flow/NewFilterParticleAdvection.h
+++ b/vtkm/filter/flow/NewFilterParticleAdvection.h
@@ -67,10 +67,7 @@ protected:
   VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
   VTKM_CONT virtual void ValidateOptions() const;
 
-  VTKM_CONT virtual vtkm::filter::flow::FlowResultType GetResultType() const
-  {
-    return vtkm::filter::flow::FlowResultType::UNKNOWN_TYPE;
-  }
+  VTKM_CONT virtual vtkm::filter::flow::FlowResultType GetResultType() const = 0;
 
   vtkm::Id NumberOfSteps = 0;
   vtkm::cont::UnknownArrayHandle Seeds;

From d75b826476231995d2df6d25e2c005f23fe4fd27 Mon Sep 17 00:00:00 2001
From: Vicente Adolfo Bolea Sanchez <vicente.bolea@kitware.com>
Date: Tue, 12 Jul 2022 16:03:01 -0400
Subject: [PATCH 099/104] CI: provide ccache at build time

---
 .gitlab/ci/config/ccache.cmake | 61 ++++++++++++++++++++++++++++++++++
 .gitlab/ci/macos.yml           |  4 +++
 2 files changed, 65 insertions(+)
 create mode 100644 .gitlab/ci/config/ccache.cmake

diff --git a/.gitlab/ci/config/ccache.cmake b/.gitlab/ci/config/ccache.cmake
new file mode 100644
index 000000000..375bfce3c
--- /dev/null
+++ b/.gitlab/ci/config/ccache.cmake
@@ -0,0 +1,61 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##============================================================================
+
+cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
+
+set(version 4.6.1)
+set(arch x86_64)
+
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+  set(sha256sum da1e1781bc1c4b019216fa16391af3e1daaee7e7f49a8ec9b0cdc8a1d05c50e2)
+  set(base_url https://github.com/ccache/ccache/releases/download)
+  set(platform linux)
+  set(extension tar.xz)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+  set(sha256sum 3e36ba8c80fbf7f2b95fe0227b9dd1ca6143d721aab052caf0d5729769138059)
+  set(full_url https://gitlab.kitware.com/utils/ci-utilities/-/package_files/534/download)
+  set(filename ccache)
+  set(extension tar.gz)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+  set(sha256sum a6c6311973aa3d2aae22424895f2f968e5d661be003b25f1bd854a5c0cd57563)
+  set(base_url https://github.com/ccache/ccache/releases/download)
+  set(platform windows)
+  set(extension zip)
+else()
+  message(FATAL_ERROR "Unrecognized platform ${CMAKE_HOST_SYSTEM_NAME}")
+endif()
+
+if(NOT DEFINED filename)
+  set(filename "ccache-${version}-${platform}-${arch}")
+endif()
+
+set(tarball "${filename}.${extension}")
+
+if(NOT DEFINED full_url)
+  set(full_url "${base_url}/v${version}/${tarball}")
+endif()
+
+file(DOWNLOAD
+  "${full_url}" .gitlab/${tarball}
+  EXPECTED_HASH SHA256=${sha256sum}
+  SHOW_PROGRESS
+  )
+
+execute_process(
+  COMMAND ${CMAKE_COMMAND} -E tar xf ${tarball}
+  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/.gitlab
+  RESULT_VARIABLE extract_results
+  )
+
+if(extract_results)
+  message(FATAL_ERROR "Extracting `${tarball}` failed: ${extract_results}.")
+endif()
+
+file(RENAME .gitlab/${filename} .gitlab/ccache)
diff --git a/.gitlab/ci/macos.yml b/.gitlab/ci/macos.yml
index 682f0e2e8..a6614c4a7 100644
--- a/.gitlab/ci/macos.yml
+++ b/.gitlab/ci/macos.yml
@@ -42,7 +42,11 @@ test:macos_xcode13:
   before_script:
     - .gitlab/ci/config/cmake.sh
     - export PATH=$PWD/.gitlab/cmake/bin:$PATH
+    - "cmake -VV -P .gitlab/ci/config/ccache.cmake"
+    - export PATH=$PWD/.gitlab/ccache:$PATH
     - "cmake --version"
+    - "ccache --version"
+    - "ninja --version"
     - "cmake -V -P .gitlab/ci/config/fetch_vtkm_tags.cmake"
     - "cmake -V -P .gitlab/ci/config/gitlab_ci_setup.cmake"
     - "ctest -VV -S .gitlab/ci/ctest_configure.cmake"

From adcda947f159ef25e1a42ce356c0f760b2252922 Mon Sep 17 00:00:00 2001
From: Vicente Adolfo Bolea Sanchez <vicente.bolea@kitware.com>
Date: Wed, 13 Jul 2022 15:45:59 -0400
Subject: [PATCH 100/104] CI: provide ninja at build time

---
 .gitlab-ci.yml                |  5 +++-
 .gitlab/ci/config/ninja.cmake | 44 +++++++++++++++++++++++++++++++++++
 .gitlab/ci/macos.yml          |  7 +++++-
 3 files changed, 54 insertions(+), 2 deletions(-)
 create mode 100644 .gitlab/ci/config/ninja.cmake

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index e9c796e90..519d1e97e 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -164,8 +164,9 @@ stages:
   interruptible: true
   before_script:
     - *install_cmake
-    - .gitlab/ci/config/sccache.sh
+    - "cmake -VV -P .gitlab/ci/config/ninja.cmake"
     - export PATH=$PWD/.gitlab:$PATH
+    - .gitlab/ci/config/sccache.sh
     - SCCACHE_IDLE_TIMEOUT=0 sccache --start-server
     - sccache --show-stats
     - .gitlab/ci/config/google_benchmarks.sh
@@ -185,6 +186,8 @@ stages:
   interruptible: true
   before_script:
     - *install_cmake
+    - "cmake -VV -P .gitlab/ci/config/ninja.cmake"
+    - export PATH=$PWD/.gitlab:$PATH
   script:
     - "ctest $CTEST_TIMEOUT -VV -S .gitlab/ci/ctest_test.cmake"
   extends:
diff --git a/.gitlab/ci/config/ninja.cmake b/.gitlab/ci/config/ninja.cmake
new file mode 100644
index 000000000..8d7d141c8
--- /dev/null
+++ b/.gitlab/ci/config/ninja.cmake
@@ -0,0 +1,44 @@
+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##============================================================================
+
+cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
+
+set(version 1.11.0)
+
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
+  set(sha256sum 9726e730d5b8599f82654dc80265e64a10a8a817552c34153361ed0c017f9f02)
+  set(platform linux)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+  set(sha256sum 21915277db59756bfc61f6f281c1f5e3897760b63776fd3d360f77dd7364137f)
+  set(platform mac)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+  set(sha256sum d0ee3da143211aa447e750085876c9b9d7bcdd637ab5b2c5b41349c617f22f3b)
+  set(platform win)
+else()
+  message(FATAL_ERROR "Unrecognized platform ${CMAKE_HOST_SYSTEM_NAME}")
+endif()
+
+set(tarball "ninja-${platform}.zip")
+
+file(DOWNLOAD
+  "https://github.com/ninja-build/ninja/releases/download/v${version}/${tarball}" .gitlab/${tarball}
+  EXPECTED_HASH SHA256=${sha256sum}
+  SHOW_PROGRESS
+  )
+
+execute_process(
+  COMMAND ${CMAKE_COMMAND} -E tar xf ${tarball}
+  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/.gitlab
+  RESULT_VARIABLE extract_results
+  )
+
+if(extract_results)
+  message(FATAL_ERROR "Extracting `${tarball}` failed: ${extract_results}.")
+endif()
diff --git a/.gitlab/ci/macos.yml b/.gitlab/ci/macos.yml
index a6614c4a7..6badbab88 100644
--- a/.gitlab/ci/macos.yml
+++ b/.gitlab/ci/macos.yml
@@ -44,6 +44,8 @@ test:macos_xcode13:
     - export PATH=$PWD/.gitlab/cmake/bin:$PATH
     - "cmake -VV -P .gitlab/ci/config/ccache.cmake"
     - export PATH=$PWD/.gitlab/ccache:$PATH
+    - "cmake -VV -P .gitlab/ci/config/ninja.cmake"
+    - export PATH=$PWD/.gitlab:$PATH
     - "cmake --version"
     - "ccache --version"
     - "ninja --version"
@@ -63,8 +65,11 @@ test:macos_xcode13:
   interruptible: true
   before_script:
     - .gitlab/ci/config/cmake.sh
-    - export PATH=$PWD/.gitlab/cmake/bin:$PATH
+    - export PATH=.gitlab/cmake/bin:$PATH
+    - "cmake -VV -P .gitlab/ci/config/ninja.cmake"
+    - export PATH=$PWD/.gitlab:$PATH
     - cmake --version
+    - ninja --version
   script:
     - "ctest $CTEST_TIMEOUT -VV -S .gitlab/ci/ctest_test.cmake"
   extends:

From 525610ad7308311def9419737b0632979f3158ca Mon Sep 17 00:00:00 2001
From: Vicente Adolfo Bolea Sanchez <vicente.bolea@kitware.com>
Date: Wed, 3 Aug 2022 13:06:26 -0400
Subject: [PATCH 101/104] windows: provide ccache and ninja on runtime

---
 .gitlab/ci/windows10.yml | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/.gitlab/ci/windows10.yml b/.gitlab/ci/windows10.yml
index f96dbf007..7d8b278a7 100644
--- a/.gitlab/ci/windows10.yml
+++ b/.gitlab/ci/windows10.yml
@@ -29,8 +29,12 @@
     - Invoke-Expression -Command .gitlab/ci/config/cmake.ps1
     - Invoke-Expression -Command .gitlab/ci/config/vcvarsall.ps1
     - $pwdpath = $pwd.Path
-    - Set-Item -Force -Path "env:PATH" -Value "$pwdpath\.gitlab;$pwdpath\.gitlab\cmake\bin;$env:PATH"
+    - Set-Item -Force -Path "env:PATH" -Value "$pwdpath\.gitlab\cmake\bin;$env:PATH"
     - "cmake --version"
+    - "cmake -V -P .gitlab/ci/config/ccache.cmake"
+    - Set-Item -Force -Path "env:PATH" -Value "$pwdpath\.gitlab\ccache;$env:PATH"
+    - "cmake -V -P .gitlab/ci/config/ninja.cmake"
+    - Set-Item -Force -Path "env:PATH" -Value "$pwdpath\.gitlab;$env:PATH"
     - "cmake -V -P .gitlab/ci/config/gitlab_ci_setup.cmake"
     - "ctest -VV -S .gitlab/ci/ctest_configure.cmake"
   script:
@@ -67,7 +71,10 @@
     - Invoke-Expression -Command .gitlab/ci/config/cmake.ps1
     - Invoke-Expression -Command .gitlab/ci/config/vcvarsall.ps1
     - $pwdpath = $pwd.Path
-    - Set-Item -Force -Path "env:PATH" -Value "$pwdpath\.gitlab;$pwdpath\.gitlab\cmake\bin;$env:PATH"
+    - Set-Item -Force -Path "env:PATH" -Value "$pwdpath\.gitlab\cmake\bin;$env:PATH"
+    - "cmake --version"
+    - "cmake -V -P .gitlab/ci/config/ninja.cmake"
+    - Set-Item -Force -Path "env:PATH" -Value "$pwdpath\.gitlab;$env:PATH"
   script:
     - "ctest -VV -S .gitlab/ci/ctest_test.cmake"
 

From 5a2da0cd8906b543bdaa131791c5d85f0b540035 Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <morelandkd@ornl.gov>
Date: Thu, 4 Aug 2022 06:18:57 -0600
Subject: [PATCH 102/104] Fix type comparison on OSX for UnknownArrayHandle
 base component type

This is an addition to commit e312c5435651f326f530a976d3faf3752350911e,
which corrects type comparison on OSX for typeids created in different
translation units. That missed the type correction for the
`BaseComponentType` of `UnknownArrayHandle`.
---
 vtkm/cont/UnknownArrayHandle.cxx | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/vtkm/cont/UnknownArrayHandle.cxx b/vtkm/cont/UnknownArrayHandle.cxx
index 3cde57a99..4fcfb555d 100644
--- a/vtkm/cont/UnknownArrayHandle.cxx
+++ b/vtkm/cont/UnknownArrayHandle.cxx
@@ -95,7 +95,17 @@ bool UnknownAHComponentInfo::operator==(const UnknownAHComponentInfo& rhs)
   else
   {
     // Needs optimization based on platform. OSX cannot compare typeid across translation units?
-    return this->Type == rhs.Type;
+    bool typesEqual = (this->Type == rhs.Type);
+
+    // Could use optimization based on platform. OSX cannot compare typeid across translation
+    // units, so we have to also check the names. (Why doesn't the == operator above do that?)
+    // Are there other platforms that behave similarly?
+    if (!typesEqual)
+    {
+      typesEqual = (std::strcmp(this->Type.name(), rhs.Type.name()) == 0);
+    }
+
+    return typesEqual;
   }
 }
 
@@ -151,7 +161,7 @@ VTKM_CONT bool UnknownArrayHandle::IsBaseComponentTypeImpl(
     return false;
   }
 
-  // Needs optimization based on platform. OSX cannot compare typeid across translation units?
+  // Note that detail::UnknownAHComponentInfo has a custom operator==
   return this->Container->BaseComponentType == type;
 }
 

From dd3fc9781161670dad7f52247e29a1d7c87edce7 Mon Sep 17 00:00:00 2001
From: Vicente Adolfo Bolea Sanchez <vicente.bolea@kitware.com>
Date: Thu, 4 Aug 2022 13:20:24 -0400
Subject: [PATCH 103/104] cmake: skip find_package(TBB) if already loaded

---
 CMake/VTKmDeviceAdapters.cmake | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/CMake/VTKmDeviceAdapters.cmake b/CMake/VTKmDeviceAdapters.cmake
index 13b6935f9..3fe03a850 100644
--- a/CMake/VTKmDeviceAdapters.cmake
+++ b/CMake/VTKmDeviceAdapters.cmake
@@ -42,7 +42,11 @@ function(vtkm_extract_real_library library real_library)
 endfunction()
 
 if(VTKm_ENABLE_TBB AND NOT TARGET vtkm::tbb)
-  find_package(TBB REQUIRED)
+  # Skip find_package(TBB) if we already have it
+  if (NOT TARGET TBB::tbb)
+    find_package(TBB REQUIRED)
+  endif()
+
   add_library(vtkmTBB INTERFACE)
   add_library(vtkm::tbb ALIAS vtkmTBB)
   target_link_libraries(vtkmTBB INTERFACE TBB::tbb)

From c30c35571fb141b2168d2840494dbc2544c66194 Mon Sep 17 00:00:00 2001
From: Vicente Adolfo Bolea Sanchez <vicente.bolea@kitware.com>
Date: Thu, 4 Aug 2022 13:58:01 -0400
Subject: [PATCH 104/104] Revert "Disable loading the TBBConfig.cmake file"

This reverts commit a8825db59a7235c9d267ac4f909bd2eebb25cb40.
---
 CMake/FindTBB.cmake | 49 +++++++++++++++++++++------------------------
 1 file changed, 23 insertions(+), 26 deletions(-)

diff --git a/CMake/FindTBB.cmake b/CMake/FindTBB.cmake
index 95cc79586..bd7563131 100644
--- a/CMake/FindTBB.cmake
+++ b/CMake/FindTBB.cmake
@@ -70,32 +70,29 @@
 
 # Use TBBConfig.cmake if possible.
 
-# Disabling this as it running the TBBConfig.cmake on dragnipur is
-# causing a CMake error. I don't know if this is an install problem
-# or an issue with version 2018.0.
-# set(_tbb_find_quiet)
-# if (TBB_FIND_QUIETLY)
-#   set(_tbb_find_quiet QUIET)
-# endif ()
-# set(_tbb_find_components)
-# set(_tbb_find_optional_components)
-# foreach (_tbb_find_component IN LISTS TBB_FIND_COMPONENTS)
-#   if (TBB_FIND_REQUIRED_${_tbb_find_component})
-#     list(APPEND _tbb_find_components "${_tbb_find_component}")
-#   else ()
-#     list(APPEND _tbb_find_optional_components "${_tbb_find_component}")
-#   endif ()
-# endforeach ()
-# unset(_tbb_find_component)
-# find_package(TBB CONFIG ${_tbb_find_quiet}
-#   COMPONENTS ${_tbb_find_components}
-#   OPTIONAL_COMPONENTS ${_tbb_find_optional_components})
-# unset(_tbb_find_quiet)
-# unset(_tbb_find_components)
-# unset(_tbb_find_optional_components)
-# if (TBB_FOUND)
-#   return ()
-# endif ()
+set(_tbb_find_quiet)
+if (TBB_FIND_QUIETLY)
+  set(_tbb_find_quiet QUIET)
+endif ()
+set(_tbb_find_components)
+set(_tbb_find_optional_components)
+foreach (_tbb_find_component IN LISTS TBB_FIND_COMPONENTS)
+  if (TBB_FIND_REQUIRED_${_tbb_find_component})
+    list(APPEND _tbb_find_components "${_tbb_find_component}")
+  else ()
+    list(APPEND _tbb_find_optional_components "${_tbb_find_component}")
+  endif ()
+endforeach ()
+unset(_tbb_find_component)
+find_package(TBB CONFIG ${_tbb_find_quiet}
+  COMPONENTS ${_tbb_find_components}
+  OPTIONAL_COMPONENTS ${_tbb_find_optional_components})
+unset(_tbb_find_quiet)
+unset(_tbb_find_components)
+unset(_tbb_find_optional_components)
+if (TBB_FOUND)
+  return ()
+endif ()
 
 #====================================================
 # Fix the library path in case it is a linker script