diff --git a/docs/changelog/hide-particle-members.md b/docs/changelog/hide-particle-members.md
new file mode 100644
index 000000000..eeeaf4d9b
--- /dev/null
+++ b/docs/changelog/hide-particle-members.md
@@ -0,0 +1,11 @@
+# Particle class members are hidden
+
+The member variables of the `vtkm::Particle` classes are now hidden. This
+means that external code will not be directly able to access member
+variables like `Pos`, `Time`, and `ID`. Instead, these need to be retrieved
+and changed through accessor methods.
+
+This follows standard C++ principles. It also helps us future-proof the
+classes. It means that we can provide subclasses or alternate forms of
+`Particle` that operate differently. It also makes it possible to change
+interfaces while maintaining a deprecated interface.
diff --git a/examples/particle_advection/ParticleAdvection.cxx b/examples/particle_advection/ParticleAdvection.cxx
index 64172d152..cc2885918 100644
--- a/examples/particle_advection/ParticleAdvection.cxx
+++ b/examples/particle_advection/ParticleAdvection.cxx
@@ -66,10 +66,10 @@ int main(int argc, char** argv)
     vtkm::FloatDefault rx = (vtkm::FloatDefault)rand() / (vtkm::FloatDefault)RAND_MAX;
     vtkm::FloatDefault ry = (vtkm::FloatDefault)rand() / (vtkm::FloatDefault)RAND_MAX;
     vtkm::FloatDefault rz = (vtkm::FloatDefault)rand() / (vtkm::FloatDefault)RAND_MAX;
-    p.Pos[0] = static_cast<vtkm::FloatDefault>(bounds.X.Min + rx * bounds.X.Length());
-    p.Pos[1] = static_cast<vtkm::FloatDefault>(bounds.Y.Min + ry * bounds.Y.Length());
-    p.Pos[2] = static_cast<vtkm::FloatDefault>(bounds.Z.Min + rz * bounds.Z.Length());
-    p.ID = i;
+    p.SetPosition({ static_cast<vtkm::FloatDefault>(bounds.X.Min + rx * bounds.X.Length()),
+                    static_cast<vtkm::FloatDefault>(bounds.Y.Min + ry * bounds.Y.Length()),
+                    static_cast<vtkm::FloatDefault>(bounds.Z.Min + rz * bounds.Z.Length()) });
+    p.SetID(i);
     seeds.push_back(p);
   }
   auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off);
diff --git a/examples/temporal_advection/TemporalAdvection.cxx b/examples/temporal_advection/TemporalAdvection.cxx
index 141833e6b..bb765dda2 100644
--- a/examples/temporal_advection/TemporalAdvection.cxx
+++ b/examples/temporal_advection/TemporalAdvection.cxx
@@ -87,8 +87,8 @@ int main(int argc, char** argv)
   for (vtkm::Id i = 0; i < numPts; i++)
   {
     vtkm::Particle p;
-    p.Pos = ptsPortal.Get(i);
-    p.ID = i;
+    p.SetPosition(ptsPortal.Get(i));
+    p.SetID(i);
     seedPortal.Set(i, p);
   }
 
diff --git a/vtkm/Particle.h b/vtkm/Particle.h
index 1708c3ab0..015bca388 100644
--- a/vtkm/Particle.h
+++ b/vtkm/Particle.h
@@ -99,7 +99,7 @@ public:
            const vtkm::Id& numSteps = 0,
            const vtkm::ParticleStatus& status = vtkm::ParticleStatus(),
            const vtkm::FloatDefault& time = 0)
-    : Pos(p)
+    : Position(p)
     , ID(id)
     , NumSteps(numSteps)
     , Status(status)
@@ -109,7 +109,7 @@ public:
 
   VTKM_EXEC_CONT
   Particle(const vtkm::Particle& p)
-    : Pos(p.Pos)
+    : Position(p.Position)
     , ID(p.ID)
     , NumSteps(p.NumSteps)
     , Status(p.Status)
@@ -125,6 +125,22 @@ public:
     // troublesome with CUDA __host__ __device__ markup.
   }
 
+  VTKM_EXEC_CONT const vtkm::Vec3f& GetPosition() const { return this->Position; }
+  VTKM_EXEC_CONT void SetPosition(const vtkm::Vec3f& position) { this->Position = position; }
+
+  VTKM_EXEC_CONT vtkm::Id GetID() const { return this->ID; }
+  VTKM_EXEC_CONT void SetID(vtkm::Id id) { this->ID = id; }
+
+  VTKM_EXEC_CONT vtkm::Id GetNumberOfSteps() const { return this->NumSteps; }
+  VTKM_EXEC_CONT void SetNumberOfSteps(vtkm::Id numSteps) { this->NumSteps = numSteps; }
+
+  VTKM_EXEC_CONT vtkm::ParticleStatus GetStatus() const { return this->Status; }
+  VTKM_EXEC_CONT vtkm::ParticleStatus& GetStatus() { return this->Status; }
+  VTKM_EXEC_CONT void SetStatus(vtkm::ParticleStatus status) { this->Status = status; }
+
+  VTKM_EXEC_CONT vtkm::FloatDefault GetTime() const { return this->Time; }
+  VTKM_EXEC_CONT void SetTime(vtkm::FloatDefault time) { this->Time = time; }
+
   VTKM_EXEC_CONT
   vtkm::Vec3f Velocity(const vtkm::VecVariable<vtkm::Vec3f, 2>& vectors,
                        const vtkm::FloatDefault& vtkmNotUsed(length))
@@ -139,22 +155,24 @@ public:
   vtkm::Vec3f GetEvaluationPosition(const vtkm::FloatDefault& deltaT) const
   {
     (void)deltaT; // unused for a general particle advection case
-    return this->Pos;
+    return this->Position;
   }
 
   inline VTKM_CONT friend std::ostream& operator<<(std::ostream& out, const vtkm::Particle& p)
   {
-    out << "v(" << p.Time << ") = " << p.Pos << ", ID: " << p.ID << ", NumSteps: " << p.NumSteps
-        << ", Status: " << p.Status;
+    out << "v(" << p.Time << ") = " << p.Position << ", ID: " << p.ID
+        << ", NumSteps: " << p.NumSteps << ", Status: " << p.Status;
     return out;
   }
 
-  vtkm::Vec3f Pos;
+private:
+  vtkm::Vec3f Position;
   vtkm::Id ID = -1;
   vtkm::Id NumSteps = 0;
   vtkm::ParticleStatus Status;
   vtkm::FloatDefault Time = 0;
 
+public:
   static size_t Sizeof()
   {
     constexpr std::size_t sz = sizeof(vtkm::Vec3f) // Pos
@@ -183,7 +201,7 @@ public:
                   const vtkm::Id& numSteps = 0,
                   const vtkm::ParticleStatus& status = vtkm::ParticleStatus(),
                   const vtkm::FloatDefault& time = 0)
-    : Pos(position)
+    : Position(position)
     , ID(id)
     , NumSteps(numSteps)
     , Status(status)
@@ -195,6 +213,22 @@ public:
   {
   }
 
+  VTKM_EXEC_CONT const vtkm::Vec3f& GetPosition() const { return this->Position; }
+  VTKM_EXEC_CONT void SetPosition(const vtkm::Vec3f& position) { this->Position = position; }
+
+  VTKM_EXEC_CONT vtkm::Id GetID() const { return this->ID; }
+  VTKM_EXEC_CONT void SetID(vtkm::Id id) { this->ID = id; }
+
+  VTKM_EXEC_CONT vtkm::Id GetNumberOfSteps() const { return this->NumSteps; }
+  VTKM_EXEC_CONT void SetNumberOfSteps(vtkm::Id numSteps) { this->NumSteps = numSteps; }
+
+  VTKM_EXEC_CONT vtkm::ParticleStatus GetStatus() const { return this->Status; }
+  VTKM_EXEC_CONT vtkm::ParticleStatus& GetStatus() { return this->Status; }
+  VTKM_EXEC_CONT void SetStatus(vtkm::ParticleStatus status) { this->Status = status; }
+
+  VTKM_EXEC_CONT vtkm::FloatDefault GetTime() const { return this->Time; }
+  VTKM_EXEC_CONT void SetTime(vtkm::FloatDefault time) { this->Time = time; }
+
   VTKM_EXEC_CONT
   vtkm::Float64 Gamma(vtkm::Vec3f momentum, bool reciprocal = false) const
   {
@@ -248,24 +282,23 @@ public:
     // Translation is in -ve Z direction,
     // this needs to be a parameter.
     auto translation = this->NumSteps * deltaT * SPEED_OF_LIGHT * vtkm::Vec3f{ 0., 0., -1.0 };
-    return this->Pos + translation;
+    return this->Position + 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;
+    out << "v(" << p.Time << ") = " << p.Position << ", ID: " << p.ID
+        << ", NumSteps: " << p.NumSteps << ", Status: " << p.Status;
     return out;
   }
 
-  vtkm::Vec3f Pos;
+private:
+  vtkm::Vec3f Position;
   vtkm::Id ID = -1;
   vtkm::Id NumSteps = 0;
   vtkm::ParticleStatus Status;
   vtkm::FloatDefault Time = 0;
-
-private:
   vtkm::Float64 Mass;
   vtkm::Float64 Charge;
   vtkm::Float64 Weighting;
@@ -303,20 +336,34 @@ struct Serialization<vtkm::Particle>
 public:
   static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::Particle& p)
   {
-    vtkmdiy::save(bb, p.Pos);
-    vtkmdiy::save(bb, p.ID);
-    vtkmdiy::save(bb, p.NumSteps);
-    vtkmdiy::save(bb, p.Status);
-    vtkmdiy::save(bb, p.Time);
+    vtkmdiy::save(bb, p.GetPosition());
+    vtkmdiy::save(bb, p.GetID());
+    vtkmdiy::save(bb, p.GetNumberOfSteps());
+    vtkmdiy::save(bb, p.GetStatus());
+    vtkmdiy::save(bb, p.GetTime());
   }
 
   static VTKM_CONT void load(BinaryBuffer& bb, vtkm::Particle& p)
   {
-    vtkmdiy::load(bb, p.Pos);
-    vtkmdiy::load(bb, p.ID);
-    vtkmdiy::load(bb, p.NumSteps);
-    vtkmdiy::load(bb, p.Status);
-    vtkmdiy::load(bb, p.Time);
+    vtkm::Vec3f pos;
+    vtkmdiy::load(bb, pos);
+    p.SetPosition(pos);
+
+    vtkm::Id id;
+    vtkmdiy::load(bb, id);
+    p.SetID(id);
+
+    vtkm::Id numSteps;
+    vtkmdiy::load(bb, numSteps);
+    p.SetNumberOfSteps(numSteps);
+
+    vtkm::ParticleStatus status;
+    vtkmdiy::load(bb, status);
+    p.SetStatus(status);
+
+    vtkm::FloatDefault time;
+    vtkmdiy::load(bb, time);
+    p.SetTime(time);
   }
 };
 
@@ -326,7 +373,7 @@ struct Serialization<vtkm::ChargedParticle>
 public:
   static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::ChargedParticle& e)
   {
-    vtkmdiy::save(bb, e.Pos);
+    vtkmdiy::save(bb, e.Position);
     vtkmdiy::save(bb, e.ID);
     vtkmdiy::save(bb, e.NumSteps);
     vtkmdiy::save(bb, e.Status);
@@ -339,7 +386,7 @@ public:
 
   static VTKM_CONT void load(BinaryBuffer& bb, vtkm::ChargedParticle& e)
   {
-    vtkmdiy::load(bb, e.Pos);
+    vtkmdiy::load(bb, e.Position);
     vtkmdiy::load(bb, e.ID);
     vtkmdiy::load(bb, e.NumSteps);
     vtkmdiy::load(bb, e.Status);
diff --git a/vtkm/cont/ParticleArrayCopy.hxx b/vtkm/cont/ParticleArrayCopy.hxx
index 8901d5104..33e7b0697 100644
--- a/vtkm/cont/ParticleArrayCopy.hxx
+++ b/vtkm/cont/ParticleArrayCopy.hxx
@@ -29,14 +29,14 @@ template <typename ParticleType>
 struct ExtractPositionFunctor
 {
   VTKM_EXEC_CONT
-  vtkm::Vec3f operator()(const ParticleType& p) const { return p.Pos; }
+  vtkm::Vec3f operator()(const ParticleType& p) const { return p.GetPosition(); }
 };
 
 template <typename ParticleType>
 struct ExtractTerminatedFunctor
 {
   VTKM_EXEC_CONT
-  bool operator()(const ParticleType& p) const { return p.Status.CheckTerminate(); }
+  bool operator()(const ParticleType& p) const { return p.GetStatus().CheckTerminate(); }
 };
 
 template <typename ParticleType>
@@ -56,11 +56,11 @@ struct CopyParticleAllWorklet : public vtkm::worklet::WorkletMapField
                             vtkm::ParticleStatus& outStatus,
                             vtkm::FloatDefault& outTime) const
   {
-    outPos = inParticle.Pos;
-    outID = inParticle.ID;
-    outSteps = inParticle.NumSteps;
-    outStatus = inParticle.Status;
-    outTime = inParticle.Time;
+    outPos = inParticle.GetPosition();
+    outID = inParticle.GetID();
+    outSteps = inParticle.GetNumberOfSteps();
+    outStatus = inParticle.GetStatus();
+    outTime = inParticle.GetTime();
   }
 };
 
diff --git a/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx b/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx
index 4054270cf..e3f74fccd 100644
--- a/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx
+++ b/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx
@@ -45,7 +45,7 @@ void TestParticleArrayCopy()
       {
         auto p = pPortal.Get(j);
         auto pt = pos.ReadPortal().Get(j);
-        VTKM_TEST_ASSERT(p.Pos == pt, "Positions do not match");
+        VTKM_TEST_ASSERT(p.GetPosition() == pt, "Positions do not match");
       }
     }
     else //Test copy everything
@@ -62,11 +62,11 @@ void TestParticleArrayCopy()
       {
         auto p = pPortal.Get(j);
         auto pt = pos.ReadPortal().Get(j);
-        VTKM_TEST_ASSERT(p.Pos == pt, "Positions do not match");
-        VTKM_TEST_ASSERT(p.ID == ids.ReadPortal().Get(j), "IDs do not match");
-        VTKM_TEST_ASSERT(p.NumSteps == steps.ReadPortal().Get(j), "Steps do not match");
-        VTKM_TEST_ASSERT(p.Status == status.ReadPortal().Get(j), "Status do not match");
-        VTKM_TEST_ASSERT(p.Time == ptime.ReadPortal().Get(j), "Times do not match");
+        VTKM_TEST_ASSERT(p.GetPosition() == pt, "Positions do not match");
+        VTKM_TEST_ASSERT(p.GetID() == ids.ReadPortal().Get(j), "IDs do not match");
+        VTKM_TEST_ASSERT(p.GetNumberOfSteps() == steps.ReadPortal().Get(j), "Steps do not match");
+        VTKM_TEST_ASSERT(p.GetStatus() == status.ReadPortal().Get(j), "Status do not match");
+        VTKM_TEST_ASSERT(p.GetTime() == ptime.ReadPortal().Get(j), "Times do not match");
       }
     }
   }
@@ -106,7 +106,7 @@ void TestParticleArrayCopy()
     {
       auto p = portal.Get(i);
       auto pRes = resPortal.Get(resIdx);
-      VTKM_TEST_ASSERT(p.Pos == pRes, "Positions do not match");
+      VTKM_TEST_ASSERT(p.GetPosition() == pRes, "Positions do not match");
       resIdx++;
     }
   }
diff --git a/vtkm/filter/flow/Lagrangian.cxx b/vtkm/filter/flow/Lagrangian.cxx
index 864e5bf90..fdb3e6c76 100644
--- a/vtkm/filter/flow/Lagrangian.cxx
+++ b/vtkm/filter/flow/Lagrangian.cxx
@@ -45,10 +45,10 @@ public:
   template <typename ValidityType>
   VTKM_EXEC void operator()(const vtkm::Particle& end_point, ValidityType& res) const
   {
-    vtkm::Id steps = end_point.NumSteps;
+    vtkm::Id steps = end_point.GetNumberOfSteps();
     if (steps > 0 && res == 1)
     {
-      if (bounds.Contains(end_point.Pos))
+      if (bounds.Contains(end_point.GetPosition()))
       {
         res = 1;
       }
@@ -79,9 +79,9 @@ public:
                             const vtkm::Particle& start_point,
                             DisplacementType& res) const
   {
-    res[0] = end_point.Pos[0] - start_point.Pos[0];
-    res[1] = end_point.Pos[1] - start_point.Pos[1];
-    res[2] = end_point.Pos[2] - start_point.Pos[2];
+    res[0] = end_point.GetPosition()[0] - start_point.GetPosition()[0];
+    res[1] = end_point.GetPosition()[1] - start_point.GetPosition()[1];
+    res[2] = end_point.GetPosition()[2] - start_point.GetPosition()[2];
   }
 };
 
diff --git a/vtkm/filter/flow/LagrangianStructures.cxx b/vtkm/filter/flow/LagrangianStructures.cxx
index e1cea5861..0a2a57f90 100644
--- a/vtkm/filter/flow/LagrangianStructures.cxx
+++ b/vtkm/filter/flow/LagrangianStructures.cxx
@@ -57,7 +57,7 @@ public:
 
   VTKM_EXEC void operator()(const vtkm::Particle& particle, vtkm::Vec3f& pt) const
   {
-    pt = particle.Pos;
+    pt = particle.GetPosition();
   }
 };
 
@@ -72,8 +72,8 @@ public:
                             const vtkm::Vec3f& seed,
                             vtkm::Particle& particle) const
   {
-    particle.ID = index;
-    particle.Pos = seed;
+    particle.SetID(index);
+    particle.SetPosition(seed);
   }
 };
 
diff --git a/vtkm/filter/flow/internal/AdvectAlgorithm.h b/vtkm/filter/flow/internal/AdvectAlgorithm.h
index 33d38d4b5..b2fe6a97a 100644
--- a/vtkm/filter/flow/internal/AdvectAlgorithm.h
+++ b/vtkm/filter/flow/internal/AdvectAlgorithm.h
@@ -75,7 +75,7 @@ public:
     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::vector<vtkm::Id> ids = this->BoundsMap.FindBlocks(p.GetPosition());
 
       if (!ids.empty() && this->BoundsMap.FindRank(ids[0]) == this->Rank)
       {
@@ -155,7 +155,7 @@ public:
     auto bit = blockIds.begin();
     while (pit != particles.end() && bit != blockIds.end())
     {
-      this->ParticleBlockIDsMap[pit->ID] = *bit;
+      this->ParticleBlockIDsMap[pit->GetID()] = *bit;
       pit++;
       bit++;
     }
@@ -170,12 +170,12 @@ public:
     if (this->Active.empty())
       return false;
 
-    blockId = this->ParticleBlockIDsMap[this->Active.front().ID][0];
+    blockId = this->ParticleBlockIDsMap[this->Active.front().GetID()][0];
     auto it = this->Active.begin();
     while (it != this->Active.end())
     {
       auto p = *it;
-      if (blockId == this->ParticleBlockIDsMap[p.ID][0])
+      if (blockId == this->ParticleBlockIDsMap[p.GetID()][0])
       {
         particles.emplace_back(p);
         it = this->Active.erase(it);
diff --git a/vtkm/filter/flow/internal/DataSetIntegrator.h b/vtkm/filter/flow/internal/DataSetIntegrator.h
index 0356e8628..554288f3b 100644
--- a/vtkm/filter/flow/internal/DataSetIntegrator.h
+++ b/vtkm/filter/flow/internal/DataSetIntegrator.h
@@ -161,32 +161,32 @@ VTKM_CONT inline void DataSetIntegrator<Derived>::ClassifyParticles(
   {
     auto p = portal.Get(i);
 
-    if (p.Status.CheckTerminate())
+    if (p.GetStatus().CheckTerminate())
     {
       dsiInfo.TermIdx.emplace_back(i);
-      dsiInfo.TermID.emplace_back(p.ID);
+      dsiInfo.TermID.emplace_back(p.GetID());
     }
     else
     {
-      const auto& it = dsiInfo.ParticleBlockIDsMap.find(p.ID);
+      const auto& it = dsiInfo.ParticleBlockIDsMap.find(p.GetID());
       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())
+      if (p.GetStatus().CheckSpatialBounds() && !p.GetStatus().CheckTookAnySteps())
         newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
       else
-        newIDs = dsiInfo.BoundsMap.FindBlocks(p.Pos, currBIDs);
+        newIDs = dsiInfo.BoundsMap.FindBlocks(p.GetPosition(), currBIDs);
 
       //reset the particle status.
-      p.Status = vtkm::ParticleStatus();
+      p.GetStatus() = vtkm::ParticleStatus();
 
       if (newIDs.empty()) //No blocks, we're done.
       {
-        p.Status.SetTerminate();
+        p.GetStatus().SetTerminate();
         dsiInfo.TermIdx.emplace_back(i);
-        dsiInfo.TermID.emplace_back(p.ID);
+        dsiInfo.TermID.emplace_back(p.GetID());
       }
       else
       {
@@ -210,12 +210,12 @@ VTKM_CONT inline void DataSetIntegrator<Derived>::ClassifyParticles(
         if (dstRank == this->Rank)
         {
           dsiInfo.A.emplace_back(p);
-          dsiInfo.IdMapA[p.ID] = newIDs;
+          dsiInfo.IdMapA[p.GetID()] = newIDs;
         }
         else
         {
           dsiInfo.I.emplace_back(p);
-          dsiInfo.IdMapI[p.ID] = newIDs;
+          dsiInfo.IdMapI[p.GetID()] = newIDs;
         }
       }
       portal.Set(i, p);
diff --git a/vtkm/filter/flow/internal/ParticleMessenger.h b/vtkm/filter/flow/internal/ParticleMessenger.h
index 3f010432e..04f9a123d 100644
--- a/vtkm/filter/flow/internal/ParticleMessenger.h
+++ b/vtkm/filter/flow/internal/ParticleMessenger.h
@@ -174,9 +174,9 @@ void ParticleMessenger<ParticleType>::SerialExchange(
 {
   for (auto& p : outData)
   {
-    const auto& bids = outBlockIDsMap.find(p.ID)->second;
+    const auto& bids = outBlockIDsMap.find(p.GetID())->second;
     inData.emplace_back(p);
-    inDataBlockIDsMap[p.ID] = bids;
+    inDataBlockIDsMap[p.GetID()] = bids;
   }
 }
 
@@ -205,7 +205,7 @@ void ParticleMessenger<ParticleType>::Exchange(
 
   for (const auto& p : outData)
   {
-    const auto& bids = outBlockIDsMap.find(p.ID)->second;
+    const auto& bids = outBlockIDsMap.find(p.GetID())->second;
     int dstRank = this->BoundsMap.FindRank(bids[0]);
     sendData[dstRank].emplace_back(std::make_pair(p, bids));
   }
@@ -227,7 +227,7 @@ void ParticleMessenger<ParticleType>::Exchange(
         const auto& p = v.first;
         const auto& bids = v.second;
         inData.emplace_back(p);
-        inDataBlockIDsMap[p.ID] = bids;
+        inDataBlockIDsMap[p.GetID()] = bids;
       }
 
     for (const auto& m : msgData)
diff --git a/vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx b/vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx
index 480d9551b..a53d31441 100644
--- a/vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx
+++ b/vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx
@@ -85,13 +85,15 @@ void ValidateReceivedParticles(
     const auto& reqP = particles[static_cast<std::size_t>(sendRank)][i];
     const auto& p = recvP[i].first;
 
-    VTKM_TEST_ASSERT(p.Pos == reqP.Pos, "Received particle has wrong Position.");
-    VTKM_TEST_ASSERT(p.Time == reqP.Time, "Received particle has wrong Time.");
-    VTKM_TEST_ASSERT(p.ID == reqP.ID, "Received particle has wrong ID.");
-    VTKM_TEST_ASSERT(p.NumSteps == reqP.NumSteps, "Received particle has wrong NumSteps.");
+    VTKM_TEST_ASSERT(p.GetPosition() == reqP.GetPosition(),
+                     "Received particle has wrong Position.");
+    VTKM_TEST_ASSERT(p.GetTime() == reqP.GetTime(), "Received particle has wrong Time.");
+    VTKM_TEST_ASSERT(p.GetID() == reqP.GetID(), "Received particle has wrong ID.");
+    VTKM_TEST_ASSERT(p.GetNumberOfSteps() == reqP.GetNumberOfSteps(),
+                     "Received particle has wrong NumSteps.");
 
-    VTKM_TEST_ASSERT(p.Pos == reqP.Pos && p.Time == reqP.Time && p.ID == reqP.ID &&
-                       p.NumSteps == reqP.NumSteps,
+    VTKM_TEST_ASSERT(p.GetPosition() == reqP.GetPosition() && p.GetTime() == reqP.GetTime() &&
+                       p.GetID() == reqP.GetID() && p.GetNumberOfSteps() == reqP.GetNumberOfSteps(),
                      "Received particle has wrong values.");
 
     const auto& reqBids = particleBlockIds[static_cast<std::size_t>(sendRank)][i];
@@ -153,12 +155,10 @@ void TestParticleMessenger()
     for (int p = 0; p < nP; p++)
     {
       vtkm::Particle particle;
-      particle.Pos[0] = floatDist(generator);
-      particle.Pos[1] = floatDist(generator);
-      particle.Pos[2] = floatDist(generator);
-      particle.Time = floatDist(generator);
-      particle.ID = pid++;
-      particle.NumSteps = nStepsDist(generator);
+      particle.SetPosition({ floatDist(generator), floatDist(generator), floatDist(generator) });
+      particle.SetTime(floatDist(generator));
+      particle.SetID(pid++);
+      particle.SetNumberOfSteps(nStepsDist(generator));
       pvec.push_back(particle);
 
       std::vector<vtkm::Id> bids(bidDist(generator));
diff --git a/vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx b/vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx
index c33ee6d38..fafcbea42 100644
--- a/vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx
+++ b/vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx
@@ -147,7 +147,7 @@ public:
                             vtkm::Vec3f& pointOut) const
   {
     vtkm::VecVariable<vtkm::Vec3f, 2> values;
-    status = evaluator.Evaluate(pointIn.Pos, pointIn.Time, values);
+    status = evaluator.Evaluate(pointIn.GetPosition(), pointIn.GetTime(), values);
     pointOut = values[0];
   }
 };
@@ -228,7 +228,7 @@ void ValidateIntegrator(const IntegratorType& integrator,
     vtkm::Vec3f result = resultsPortal.Get(index);
     VTKM_TEST_ASSERT(status.CheckOk(), "Error in evaluator for " + msg);
     if (status.CheckSpatialBounds())
-      VTKM_TEST_ASSERT(result == pointsPortal.Get(index).Pos,
+      VTKM_TEST_ASSERT(result == pointsPortal.Get(index).GetPosition(),
                        "Error in evaluator result for [OUTSIDE SPATIAL]" + msg);
     else
       VTKM_TEST_ASSERT(result == expStepResults[static_cast<size_t>(index)],
@@ -322,7 +322,7 @@ void TestEvaluators()
 
         GenerateRandomParticles(pointIns, 38, interiorBounds);
         for (auto& p : pointIns)
-          stepResult.push_back(p.Pos + vec * stepSize);
+          stepResult.push_back(p.GetPosition() + vec * stepSize);
 
         vtkm::Range xRange, yRange, zRange;
 
@@ -414,14 +414,16 @@ void TestGhostCellEvaluators()
     for (vtkm::Id i = 0; i < numSeeds; i++)
     {
       const auto& p = posPortal.Get(i);
-      VTKM_TEST_ASSERT(p.Status.CheckSpatialBounds(), "Particle did not leave the dataset.");
-      VTKM_TEST_ASSERT(p.Status.CheckInGhostCell(), "Particle did not end up in ghost cell.");
+      VTKM_TEST_ASSERT(p.GetStatus().CheckSpatialBounds(), "Particle did not leave the dataset.");
+      VTKM_TEST_ASSERT(p.GetStatus().CheckInGhostCell(), "Particle did not end up in ghost cell.");
 
       //Particles that start in a ghost cell should take no steps.
-      if (p.ID == 0 || p.ID == 1 || p.ID == 2)
-        VTKM_TEST_ASSERT(p.NumSteps == 0, "Particle in ghost cell should *not* take any steps");
-      else if (p.ID == 3)
-        VTKM_TEST_ASSERT(p.NumSteps == 21, "Wrong number of steps for particle with ghost cells");
+      if (p.GetID() == 0 || p.GetID() == 1 || p.GetID() == 2)
+        VTKM_TEST_ASSERT(p.GetNumberOfSteps() == 0,
+                         "Particle in ghost cell should *not* take any steps");
+      else if (p.GetID() == 3)
+        VTKM_TEST_ASSERT(p.GetNumberOfSteps() == 21,
+                         "Wrong number of steps for particle with ghost cells");
     }
   }
 }
@@ -436,8 +438,8 @@ void ValidateParticleAdvectionResult(
   auto portal = res.Particles.ReadPortal();
   for (vtkm::Id i = 0; i < nSeeds; i++)
   {
-    auto stepsTaken = portal.Get(i).NumSteps;
-    auto status = portal.Get(i).Status;
+    auto stepsTaken = portal.Get(i).GetNumberOfSteps();
+    auto status = portal.Get(i).GetStatus();
     VTKM_TEST_ASSERT(stepsTaken <= maxSteps, "Too many steps taken in particle advection");
     if (stepsTaken == maxSteps)
       VTKM_TEST_ASSERT(status.CheckTerminate(), "Particle expected to be terminated");
@@ -456,8 +458,9 @@ void ValidateStreamlineResult(const vtkm::worklet::flow::StreamlineResult<vtkm::
   auto portal = res.Particles.ReadPortal();
   for (vtkm::Id i = 0; i < nSeeds; i++)
   {
-    VTKM_TEST_ASSERT(portal.Get(i).NumSteps <= maxSteps, "Too many steps taken in streamline");
-    VTKM_TEST_ASSERT(portal.Get(i).Status.CheckOk(), "Bad status in streamline");
+    VTKM_TEST_ASSERT(portal.Get(i).GetNumberOfSteps() <= maxSteps,
+                     "Too many steps taken in streamline");
+    VTKM_TEST_ASSERT(portal.Get(i).GetStatus().CheckOk(), "Bad status in streamline");
   }
   VTKM_TEST_ASSERT(res.Particles.GetNumberOfValues() == nSeeds,
                    "Number of output particles does not match input.");
@@ -556,7 +559,7 @@ void TestParticleWorkletsWithDataSetTypes()
     vtkm::Id nSeeds = static_cast<vtkm::Id>(pts.size());
     std::vector<vtkm::Id> stepsTaken = { 10, 20, 600 };
     for (std::size_t i = 0; i < stepsTaken.size(); i++)
-      pts2[i].NumSteps = stepsTaken[i];
+      pts2[i].SetNumberOfSteps(stepsTaken[i]);
 
     for (auto& ds : dataSets)
     {
@@ -644,10 +647,10 @@ void TestParticleStatus()
       pa.Run(rk4, seedsArray, maxSteps);
       auto portal = seedsArray.ReadPortal();
 
-      bool tookStep0 = portal.Get(0).Status.CheckTookAnySteps();
-      bool tookStep1 = portal.Get(1).Status.CheckTookAnySteps();
-      bool isZero0 = portal.Get(0).Status.CheckZeroVelocity();
-      bool isZero1 = portal.Get(1).Status.CheckZeroVelocity();
+      bool tookStep0 = portal.Get(0).GetStatus().CheckTookAnySteps();
+      bool tookStep1 = portal.Get(1).GetStatus().CheckTookAnySteps();
+      bool isZero0 = portal.Get(0).GetStatus().CheckZeroVelocity();
+      bool isZero1 = portal.Get(1).GetStatus().CheckZeroVelocity();
 
       if (vtkm::Magnitude(vec) > 0)
       {
@@ -662,7 +665,8 @@ void TestParticleStatus()
         VTKM_TEST_ASSERT(tookStep1 == false, "Particle took a step when it should not have.");
         VTKM_TEST_ASSERT(isZero0 == true, "Particle in zero velocity when it should not be.");
         VTKM_TEST_ASSERT(isZero1 == false, "Particle in zero velocity when it should not be.");
-        VTKM_TEST_ASSERT(portal.Get(0).NumSteps == 1, "Particle should have taken only 1 step.");
+        VTKM_TEST_ASSERT(portal.Get(0).GetNumberOfSteps() == 1,
+                         "Particle should have taken only 1 step.");
       }
     }
   }
@@ -744,14 +748,15 @@ void TestWorkletsBasic()
         auto portal = res.Particles.ReadPortal();
         for (vtkm::Id i = 0; i < res.Particles.GetNumberOfValues(); i++)
         {
-          VTKM_TEST_ASSERT(portal.Get(i).Pos == endPts[static_cast<std::size_t>(i)],
+          VTKM_TEST_ASSERT(portal.Get(i).GetPosition() == endPts[static_cast<std::size_t>(i)],
                            "Particle advection point is wrong");
-          VTKM_TEST_ASSERT(portal.Get(i).NumSteps == maxSteps,
+          VTKM_TEST_ASSERT(portal.Get(i).GetNumberOfSteps() == maxSteps,
                            "Particle advection NumSteps is wrong");
-          VTKM_TEST_ASSERT(vtkm::Abs(portal.Get(i).Time - endT) < stepSize / 100,
+          VTKM_TEST_ASSERT(vtkm::Abs(portal.Get(i).GetTime() - endT) < stepSize / 100,
                            "Particle advection Time is wrong");
-          VTKM_TEST_ASSERT(portal.Get(i).Status.CheckOk(), "Particle advection Status is wrong");
-          VTKM_TEST_ASSERT(portal.Get(i).Status.CheckTerminate(),
+          VTKM_TEST_ASSERT(portal.Get(i).GetStatus().CheckOk(),
+                           "Particle advection Status is wrong");
+          VTKM_TEST_ASSERT(portal.Get(i).GetStatus().CheckTerminate(),
                            "Particle advection particle did not terminate");
         }
       }
@@ -770,13 +775,14 @@ void TestWorkletsBasic()
         auto parPortal = res.Particles.ReadPortal();
         for (vtkm::Id i = 0; i < res.Particles.GetNumberOfValues(); i++)
         {
-          VTKM_TEST_ASSERT(parPortal.Get(i).Pos == endPts[static_cast<std::size_t>(i)],
+          VTKM_TEST_ASSERT(parPortal.Get(i).GetPosition() == endPts[static_cast<std::size_t>(i)],
                            "Streamline end point is wrong");
-          VTKM_TEST_ASSERT(parPortal.Get(i).NumSteps == maxSteps, "Streamline NumSteps is wrong");
-          VTKM_TEST_ASSERT(vtkm::Abs(parPortal.Get(i).Time - endT) < stepSize / 100,
+          VTKM_TEST_ASSERT(parPortal.Get(i).GetNumberOfSteps() == maxSteps,
+                           "Streamline NumSteps is wrong");
+          VTKM_TEST_ASSERT(vtkm::Abs(parPortal.Get(i).GetTime() - endT) < stepSize / 100,
                            "Streamline Time is wrong");
-          VTKM_TEST_ASSERT(parPortal.Get(i).Status.CheckOk(), "Streamline Status is wrong");
-          VTKM_TEST_ASSERT(parPortal.Get(i).Status.CheckTerminate(),
+          VTKM_TEST_ASSERT(parPortal.Get(i).GetStatus().CheckOk(), "Streamline Status is wrong");
+          VTKM_TEST_ASSERT(parPortal.Get(i).GetStatus().CheckTerminate(),
                            "Streamline particle did not terminate");
         }
 
@@ -815,17 +821,19 @@ void ValidateResult(const ResultType& res,
   auto portal = res.Particles.ReadPortal();
   for (vtkm::Id i = 0; i < 3; i++)
   {
-    vtkm::Vec3f p = portal.Get(i).Pos;
+    vtkm::Vec3f p = portal.Get(i).GetPosition();
     vtkm::Vec3f e = endPts[static_cast<std::size_t>(i)];
 
 
     VTKM_TEST_ASSERT(vtkm::Magnitude(p - e) <= eps, "Particle advection point is wrong");
-    if (portal.Get(i).Status.CheckZeroVelocity())
-      VTKM_TEST_ASSERT(portal.Get(i).NumSteps > 0, "Particle advection NumSteps is wrong");
+    if (portal.Get(i).GetStatus().CheckZeroVelocity())
+      VTKM_TEST_ASSERT(portal.Get(i).GetNumberOfSteps() > 0,
+                       "Particle advection NumSteps is wrong");
     else
-      VTKM_TEST_ASSERT(portal.Get(i).NumSteps == maxSteps, "Particle advection NumSteps is wrong");
-    VTKM_TEST_ASSERT(portal.Get(i).Status.CheckOk(), "Particle advection Status is wrong");
-    VTKM_TEST_ASSERT(portal.Get(i).Status.CheckTerminate(),
+      VTKM_TEST_ASSERT(portal.Get(i).GetNumberOfSteps() == maxSteps,
+                       "Particle advection NumSteps is wrong");
+    VTKM_TEST_ASSERT(portal.Get(i).GetStatus().CheckOk(), "Particle advection Status is wrong");
+    VTKM_TEST_ASSERT(portal.Get(i).GetStatus().CheckTerminate(),
                      "Particle advection particle did not terminate");
   }
 }
diff --git a/vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx b/vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx
index 9cb4ddbe3..ee6bd2778 100644
--- a/vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx
+++ b/vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx
@@ -57,7 +57,7 @@ public:
                             vtkm::Vec3f& pointOut) const
   {
     vtkm::VecVariable<vtkm::Vec3f, 2> values;
-    status = evaluator.Evaluate(pointIn.Pos, 0.5f, values);
+    status = evaluator.Evaluate(pointIn.GetPosition(), 0.5f, values);
     if (values.GetNumberOfComponents() > 0)
       pointOut = values[0];
   }
diff --git a/vtkm/filter/flow/worklet/EulerIntegrator.h b/vtkm/filter/flow/worklet/EulerIntegrator.h
index cc67f20a0..bcd0e74c1 100644
--- a/vtkm/filter/flow/worklet/EulerIntegrator.h
+++ b/vtkm/filter/flow/worklet/EulerIntegrator.h
@@ -38,7 +38,7 @@ public:
                                        vtkm::FloatDefault stepLength,
                                        vtkm::Vec3f& velocity) const
   {
-    auto time = particle.Time;
+    auto time = particle.GetTime();
     auto inpos = particle.GetEvaluationPosition(stepLength);
     vtkm::VecVariable<vtkm::Vec3f, 2> vectors;
     GridEvaluatorStatus evalStatus = this->Evaluator.Evaluate(inpos, time, vectors);
diff --git a/vtkm/filter/flow/worklet/ParticleAdvection.h b/vtkm/filter/flow/worklet/ParticleAdvection.h
index fa28c9ae6..78e3c2040 100644
--- a/vtkm/filter/flow/worklet/ParticleAdvection.h
+++ b/vtkm/filter/flow/worklet/ParticleAdvection.h
@@ -38,11 +38,11 @@ public:
                             const vtkm::Id& step,
                             ParticleType& particle) const
   {
-    particle.Pos = pt;
-    particle.ID = id;
-    particle.Time = time;
-    particle.NumSteps = step;
-    particle.Status.SetOk();
+    particle.SetPosition(pt);
+    particle.SetID(id);
+    particle.SetTime(time);
+    particle.SetNumberOfSteps(step);
+    particle.GetStatus().SetOk();
   }
 };
 
diff --git a/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h b/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
index af3d5a730..1a4e76bb3 100644
--- a/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
+++ b/vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
@@ -48,7 +48,7 @@ public:
                             const vtkm::Id& maxSteps) const
   {
     auto particle = integralCurve.GetParticle(idx);
-    vtkm::FloatDefault time = particle.Time;
+    vtkm::FloatDefault time = particle.GetTime();
     bool tookAnySteps = false;
 
     //the integrator status needs to be more robust:
@@ -143,7 +143,7 @@ public:
   template <typename ParticleType>
   VTKM_EXEC void operator()(const ParticleType& p, vtkm::Id& numSteps) const
   {
-    numSteps = p.NumSteps;
+    numSteps = p.GetNumberOfSteps();
   }
 };
 
@@ -156,13 +156,13 @@ public:
   using ExecutionSignature = void(_1, _2, _3);
 
   // Offset is number of points in streamline.
-  // 1 (inital point) + number of steps taken (p.NumSteps - initalNumSteps)
+  // 1 (inital point) + number of steps taken (p.GetNumberOfSteps() - initalNumSteps)
   template <typename ParticleType>
   VTKM_EXEC void operator()(const ParticleType& p,
                             const vtkm::Id& initialNumSteps,
                             vtkm::Id& diff) const
   {
-    diff = 1 + p.NumSteps - initialNumSteps;
+    diff = 1 + p.GetNumberOfSteps() - initialNumSteps;
   }
 };
 } // namespace detail
diff --git a/vtkm/filter/flow/worklet/Particles.h b/vtkm/filter/flow/worklet/Particles.h
index 68e7ade33..47bff9c0b 100644
--- a/vtkm/filter/flow/worklet/Particles.h
+++ b/vtkm/filter/flow/worklet/Particles.h
@@ -54,9 +54,9 @@ public:
                   const vtkm::Vec3f& pt)
   {
     ParticleType newParticle(particle);
-    newParticle.Pos = pt;
-    newParticle.Time = time;
-    newParticle.NumSteps++;
+    newParticle.SetPosition(pt);
+    newParticle.SetTime(time);
+    newParticle.SetNumberOfSteps(particle.GetNumberOfSteps() + 1);
     this->Particles.Set(idx, newParticle);
   }
 
@@ -67,37 +67,37 @@ public:
   {
     ParticleType p(this->GetParticle(idx));
 
-    if (p.NumSteps == maxSteps)
-      p.Status.SetTerminate();
+    if (p.GetNumberOfSteps() == maxSteps)
+      p.GetStatus().SetTerminate();
 
     if (status.CheckFail())
-      p.Status.SetFail();
+      p.GetStatus().SetFail();
     if (status.CheckSpatialBounds())
-      p.Status.SetSpatialBounds();
+      p.GetStatus().SetSpatialBounds();
     if (status.CheckTemporalBounds())
-      p.Status.SetTemporalBounds();
+      p.GetStatus().SetTemporalBounds();
     if (status.CheckInGhostCell())
-      p.Status.SetInGhostCell();
+      p.GetStatus().SetInGhostCell();
     if (status.CheckZeroVelocity())
     {
-      p.Status.SetZeroVelocity();
-      p.Status.SetTerminate();
+      p.GetStatus().SetZeroVelocity();
+      p.GetStatus().SetTerminate();
     }
 
     this->Particles.Set(idx, p);
   }
 
   VTKM_EXEC
-  bool CanContinue(const vtkm::Id& idx) { return this->GetParticle(idx).Status.CanContinue(); }
+  bool CanContinue(const vtkm::Id& idx) { return this->GetParticle(idx).GetStatus().CanContinue(); }
 
   VTKM_EXEC
   void UpdateTookSteps(const vtkm::Id& idx, bool val)
   {
     ParticleType p(this->GetParticle(idx));
     if (val)
-      p.Status.SetTookAnySteps();
+      p.GetStatus().SetTookAnySteps();
     else
-      p.Status.ClearTookAnySteps();
+      p.GetStatus().ClearTookAnySteps();
     this->Particles.Set(idx, p);
   }
 
@@ -172,7 +172,7 @@ public:
     if (this->StepCount.Get(idx) == 0)
     {
       vtkm::Id loc = idx * Length;
-      this->History.Set(loc, p.Pos);
+      this->History.Set(loc, p.GetPosition());
       this->ValidPoint.Set(loc, 1);
       this->StepCount.Set(idx, 1);
     }
diff --git a/vtkm/filter/flow/worklet/RK4Integrator.h b/vtkm/filter/flow/worklet/RK4Integrator.h
index 7147a8a65..15653301e 100644
--- a/vtkm/filter/flow/worklet/RK4Integrator.h
+++ b/vtkm/filter/flow/worklet/RK4Integrator.h
@@ -38,7 +38,7 @@ public:
                                        vtkm::FloatDefault stepLength,
                                        vtkm::Vec3f& velocity) const
   {
-    auto time = particle.Time;
+    auto time = particle.GetTime();
     auto inpos = particle.GetEvaluationPosition(stepLength);
     vtkm::FloatDefault boundary = this->Evaluator.GetTemporalBoundary(static_cast<vtkm::Id>(1));
     if ((time + stepLength + vtkm::Epsilon<vtkm::FloatDefault>() - boundary) > 0.0)
diff --git a/vtkm/filter/flow/worklet/Stepper.h b/vtkm/filter/flow/worklet/Stepper.h
index b1872b7c6..082953c08 100644
--- a/vtkm/filter/flow/worklet/Stepper.h
+++ b/vtkm/filter/flow/worklet/Stepper.h
@@ -57,11 +57,11 @@ public:
     auto status = this->Integrator.CheckStep(particle, this->DeltaT, velocity);
     if (status.CheckOk())
     {
-      outpos = particle.Pos + this->DeltaT * velocity;
+      outpos = particle.GetPosition() + this->DeltaT * velocity;
       time += this->DeltaT;
     }
     else
-      outpos = particle.Pos;
+      outpos = particle.GetPosition();
 
     return status;
   }
@@ -84,7 +84,7 @@ public:
     vtkm::Vec3f currPos(particle.GetEvaluationPosition(this->DeltaT));
     vtkm::Vec3f currVelocity(0, 0, 0);
     vtkm::VecVariable<vtkm::Vec3f, 2> currValue, tmp;
-    auto evalStatus = this->Evaluator.Evaluate(currPos, particle.Time, currValue);
+    auto evalStatus = this->Evaluator.Evaluate(currPos, particle.GetTime(), currValue);
     if (evalStatus.CheckFail())
       return IntegratorStatus(evalStatus, false);
 
@@ -102,8 +102,8 @@ public:
       if (status.CheckOk()) //Integration step succedded.
       {
         //See if this point is in/out.
-        auto newPos = particle.Pos + currStep * currVelocity;
-        evalStatus = this->Evaluator.Evaluate(newPos, particle.Time + currStep, tmp);
+        auto newPos = particle.GetPosition() + currStep * currVelocity;
+        evalStatus = this->Evaluator.Evaluate(newPos, particle.GetTime() + currStep, tmp);
         if (evalStatus.CheckOk())
         {
           //Point still in. Update currPos and set range to {currStep, stepRange[1]}
@@ -124,7 +124,7 @@ public:
       }
     }
 
-    evalStatus = this->Evaluator.Evaluate(currPos, particle.Time + stepRange[0], currValue);
+    evalStatus = this->Evaluator.Evaluate(currPos, particle.GetTime() + stepRange[0], currValue);
     // The eval at Time + stepRange[0] better be *inside*
     VTKM_ASSERT(evalStatus.CheckOk() && !evalStatus.CheckSpatialBounds());
     if (evalStatus.CheckFail() || evalStatus.CheckSpatialBounds())