Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 10:35:42 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Merge topic 'hide-particle-members'

Browse Source 
99829cf61 Hide Particle class members

Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Abhishek Yenpure <abhi.yenpure@kitware.com>
Merge-request: !2946
This commit is contained in:
Kenneth Moreland 2022-12-13 20:30:33 +00:00 committed by Kitware Robot
commit 1930bea424
20 changed files with 217 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
docs/changelog/hide-particle-members.md Normal file
View File

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

8
examples/particle_advection/ParticleAdvection.cxx
View File

@ -66,10 +66,10 @@ int main(int argc, char** argv)
vtkm::FloatDefault rx = (vtkm::FloatDefault)rand() / (vtkm::FloatDefault)RAND_MAX; vtkm::FloatDefault rx = (vtkm::FloatDefault)rand() / (vtkm::FloatDefault)RAND_MAX;
vtkm::FloatDefault ry = (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; 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.SetPosition({ 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()); 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()); static_cast<vtkm::FloatDefault>(bounds.Z.Min + rz * bounds.Z.Length()) });
p.ID = i; p.SetID(i);
seeds.push_back(p); seeds.push_back(p);
} }
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off); auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off);

4
examples/temporal_advection/TemporalAdvection.cxx
View File

@ -87,8 +87,8 @@ int main(int argc, char** argv)
for (vtkm::Id i = 0; i < numPts; i++) for (vtkm::Id i = 0; i < numPts; i++)
{ {
vtkm::Particle p; vtkm::Particle p;
p.Pos = ptsPortal.Get(i); p.SetPosition(ptsPortal.Get(i));
p.ID = i; p.SetID(i);
seedPortal.Set(i, p); seedPortal.Set(i, p);
} }

97
vtkm/Particle.h
View File

@ -99,7 +99,7 @@ public:
const vtkm::Id& numSteps = 0, const vtkm::Id& numSteps = 0,
const vtkm::ParticleStatus& status = vtkm::ParticleStatus(), const vtkm::ParticleStatus& status = vtkm::ParticleStatus(),
const vtkm::FloatDefault& time = 0) const vtkm::FloatDefault& time = 0)
: Pos(p) : Position(p)
, ID(id) , ID(id)
, NumSteps(numSteps) , NumSteps(numSteps)
, Status(status) , Status(status)
@ -109,7 +109,7 @@ public:
VTKM_EXEC_CONT VTKM_EXEC_CONT
Particle(const vtkm::Particle& p) Particle(const vtkm::Particle& p)
: Pos(p.Pos) : Position(p.Position)
, ID(p.ID) , ID(p.ID)
, NumSteps(p.NumSteps) , NumSteps(p.NumSteps)
, Status(p.Status) , Status(p.Status)
@ -125,6 +125,22 @@ public:
// troublesome with CUDA __host__ __device__ markup. // 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_EXEC_CONT
vtkm::Vec3f Velocity(const vtkm::VecVariable<vtkm::Vec3f, 2>& vectors, vtkm::Vec3f Velocity(const vtkm::VecVariable<vtkm::Vec3f, 2>& vectors,
const vtkm::FloatDefault& vtkmNotUsed(length)) const vtkm::FloatDefault& vtkmNotUsed(length))
@ -139,22 +155,24 @@ public:
vtkm::Vec3f GetEvaluationPosition(const vtkm::FloatDefault& deltaT) const vtkm::Vec3f GetEvaluationPosition(const vtkm::FloatDefault& deltaT) const
{ {
(void)deltaT; // unused for a general particle advection case (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) 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 out << "v(" << p.Time << ") = " << p.Position << ", ID: " << p.ID
<< ", Status: " << p.Status; << ", NumSteps: " << p.NumSteps << ", Status: " << p.Status;
return out; return out;
} }
vtkm::Vec3f Pos; private:
vtkm::Vec3f Position;
vtkm::Id ID = -1; vtkm::Id ID = -1;
vtkm::Id NumSteps = 0; vtkm::Id NumSteps = 0;
vtkm::ParticleStatus Status; vtkm::ParticleStatus Status;
vtkm::FloatDefault Time = 0; vtkm::FloatDefault Time = 0;
public:
static size_t Sizeof() static size_t Sizeof()
{ {
constexpr std::size_t sz = sizeof(vtkm::Vec3f) // Pos constexpr std::size_t sz = sizeof(vtkm::Vec3f) // Pos
@ -183,7 +201,7 @@ public:
const vtkm::Id& numSteps = 0, const vtkm::Id& numSteps = 0,
const vtkm::ParticleStatus& status = vtkm::ParticleStatus(), const vtkm::ParticleStatus& status = vtkm::ParticleStatus(),
const vtkm::FloatDefault& time = 0) const vtkm::FloatDefault& time = 0)
: Pos(position) : Position(position)
, ID(id) , ID(id)
, NumSteps(numSteps) , NumSteps(numSteps)
, Status(status) , 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_EXEC_CONT
vtkm::Float64 Gamma(vtkm::Vec3f momentum, bool reciprocal = false) const vtkm::Float64 Gamma(vtkm::Vec3f momentum, bool reciprocal = false) const
{ {
@ -248,24 +282,23 @@ public:
// Translation is in -ve Z direction, // Translation is in -ve Z direction,
// this needs to be a parameter. // this needs to be a parameter.
auto translation = this->NumSteps * deltaT * SPEED_OF_LIGHT * vtkm::Vec3f{ 0., 0., -1.0 }; 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, inline VTKM_CONT friend std::ostream& operator<<(std::ostream& out,
const vtkm::ChargedParticle& p) const vtkm::ChargedParticle& p)
{ {
out << "v(" << p.Time << ") = " << p.Pos << ", ID: " << p.ID << ", NumSteps: " << p.NumSteps out << "v(" << p.Time << ") = " << p.Position << ", ID: " << p.ID
<< ", Status: " << p.Status; << ", NumSteps: " << p.NumSteps << ", Status: " << p.Status;
return out; return out;
} }
vtkm::Vec3f Pos; private:
vtkm::Vec3f Position;
vtkm::Id ID = -1; vtkm::Id ID = -1;
vtkm::Id NumSteps = 0; vtkm::Id NumSteps = 0;
vtkm::ParticleStatus Status; vtkm::ParticleStatus Status;
vtkm::FloatDefault Time = 0; vtkm::FloatDefault Time = 0;
private:
vtkm::Float64 Mass; vtkm::Float64 Mass;
vtkm::Float64 Charge; vtkm::Float64 Charge;
vtkm::Float64 Weighting; vtkm::Float64 Weighting;
@ -303,20 +336,34 @@ struct Serialization<vtkm::Particle>
public: public:
static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::Particle& p) static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::Particle& p)
{ {
vtkmdiy::save(bb, p.Pos); vtkmdiy::save(bb, p.GetPosition());
vtkmdiy::save(bb, p.ID); vtkmdiy::save(bb, p.GetID());
vtkmdiy::save(bb, p.NumSteps); vtkmdiy::save(bb, p.GetNumberOfSteps());
vtkmdiy::save(bb, p.Status); vtkmdiy::save(bb, p.GetStatus());
vtkmdiy::save(bb, p.Time); vtkmdiy::save(bb, p.GetTime());
} }
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::Particle& p) static VTKM_CONT void load(BinaryBuffer& bb, vtkm::Particle& p)
{ {
vtkmdiy::load(bb, p.Pos); vtkm::Vec3f pos;
vtkmdiy::load(bb, p.ID); vtkmdiy::load(bb, pos);
vtkmdiy::load(bb, p.NumSteps); p.SetPosition(pos);
vtkmdiy::load(bb, p.Status);
vtkmdiy::load(bb, p.Time); 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: public:
static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::ChargedParticle& e) 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.ID);
vtkmdiy::save(bb, e.NumSteps); vtkmdiy::save(bb, e.NumSteps);
vtkmdiy::save(bb, e.Status); vtkmdiy::save(bb, e.Status);
@ -339,7 +386,7 @@ public:
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::ChargedParticle& e) 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.ID);
vtkmdiy::load(bb, e.NumSteps); vtkmdiy::load(bb, e.NumSteps);
vtkmdiy::load(bb, e.Status); vtkmdiy::load(bb, e.Status);

14
vtkm/cont/ParticleArrayCopy.hxx
View File

@ -29,14 +29,14 @@ template <typename ParticleType>
struct ExtractPositionFunctor struct ExtractPositionFunctor
{ {
VTKM_EXEC_CONT 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> template <typename ParticleType>
struct ExtractTerminatedFunctor struct ExtractTerminatedFunctor
{ {
VTKM_EXEC_CONT 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> template <typename ParticleType>
@ -56,11 +56,11 @@ struct CopyParticleAllWorklet : public vtkm::worklet::WorkletMapField
vtkm::ParticleStatus& outStatus, vtkm::ParticleStatus& outStatus,
vtkm::FloatDefault& outTime) const vtkm::FloatDefault& outTime) const
{ {
outPos = inParticle.Pos; outPos = inParticle.GetPosition();
outID = inParticle.ID; outID = inParticle.GetID();
outSteps = inParticle.NumSteps; outSteps = inParticle.GetNumberOfSteps();
outStatus = inParticle.Status; outStatus = inParticle.GetStatus();
outTime = inParticle.Time; outTime = inParticle.GetTime();
} }
}; };

14
vtkm/cont/testing/UnitTestParticleArrayCopy.cxx
View File

@ -45,7 +45,7 @@ void TestParticleArrayCopy()
{ {
auto p = pPortal.Get(j); auto p = pPortal.Get(j);
auto pt = pos.ReadPortal().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 else //Test copy everything
@ -62,11 +62,11 @@ void TestParticleArrayCopy()
{ {
auto p = pPortal.Get(j); auto p = pPortal.Get(j);
auto pt = pos.ReadPortal().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");
VTKM_TEST_ASSERT(p.ID == ids.ReadPortal().Get(j), "IDs do not match"); VTKM_TEST_ASSERT(p.GetID() == 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.GetNumberOfSteps() == 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.GetStatus() == 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.GetTime() == ptime.ReadPortal().Get(j), "Times do not match");
} }
} }
} }
@ -106,7 +106,7 @@ void TestParticleArrayCopy()
{ {
auto p = portal.Get(i); auto p = portal.Get(i);
auto pRes = resPortal.Get(resIdx); 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++; resIdx++;
} }
} }

10
vtkm/filter/flow/Lagrangian.cxx
View File

@ -45,10 +45,10 @@ public:
template <typename ValidityType> template <typename ValidityType>
VTKM_EXEC void operator()(const vtkm::Particle& end_point, ValidityType& res) const 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 (steps > 0 && res == 1)
{ {
if (bounds.Contains(end_point.Pos)) if (bounds.Contains(end_point.GetPosition()))
{ {
res = 1; res = 1;
} }
@ -79,9 +79,9 @@ public:
const vtkm::Particle& start_point, const vtkm::Particle& start_point,
DisplacementType& res) const DisplacementType& res) const
{ {
res[0] = end_point.Pos[0] - start_point.Pos[0]; res[0] = end_point.GetPosition()[0] - start_point.GetPosition()[0];
res[1] = end_point.Pos[1] - start_point.Pos[1]; res[1] = end_point.GetPosition()[1] - start_point.GetPosition()[1];
res[2] = end_point.Pos[2] - start_point.Pos[2]; res[2] = end_point.GetPosition()[2] - start_point.GetPosition()[2];
} }
}; };

6
vtkm/filter/flow/LagrangianStructures.cxx
View File

@ -57,7 +57,7 @@ public:
VTKM_EXEC void operator()(const vtkm::Particle& particle, vtkm::Vec3f& pt) const 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, const vtkm::Vec3f& seed,
vtkm::Particle& particle) const vtkm::Particle& particle) const
{ {
particle.ID = index; particle.SetID(index);
particle.Pos = seed; particle.SetPosition(seed);
} }
}; };

8
vtkm/filter/flow/internal/AdvectAlgorithm.h
View File

@ -75,7 +75,7 @@ public:
for (vtkm::Id i = 0; i < n; i++) for (vtkm::Id i = 0; i < n; i++)
{ {
const ParticleType p = portal.Get(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) if (!ids.empty() && this->BoundsMap.FindRank(ids[0]) == this->Rank)
{ {
@ -155,7 +155,7 @@ public:
auto bit = blockIds.begin(); auto bit = blockIds.begin();
while (pit != particles.end() && bit != blockIds.end()) while (pit != particles.end() && bit != blockIds.end())
{ {
this->ParticleBlockIDsMap[pit->ID] = *bit; this->ParticleBlockIDsMap[pit->GetID()] = *bit;
pit++; pit++;
bit++; bit++;
} }
@ -170,12 +170,12 @@ public:
if (this->Active.empty()) if (this->Active.empty())
return false; return false;
blockId = this->ParticleBlockIDsMap[this->Active.front().ID][0]; blockId = this->ParticleBlockIDsMap[this->Active.front().GetID()][0];
auto it = this->Active.begin(); auto it = this->Active.begin();
while (it != this->Active.end()) while (it != this->Active.end())
{ {
auto p = *it; auto p = *it;
if (blockId == this->ParticleBlockIDsMap[p.ID][0]) if (blockId == this->ParticleBlockIDsMap[p.GetID()][0])
{ {
particles.emplace_back(p); particles.emplace_back(p);
it = this->Active.erase(it); it = this->Active.erase(it);

20
vtkm/filter/flow/internal/DataSetIntegrator.h
View File

@ -161,32 +161,32 @@ VTKM_CONT inline void DataSetIntegrator<Derived>::ClassifyParticles(
{ {
auto p = portal.Get(i); auto p = portal.Get(i);
if (p.Status.CheckTerminate()) if (p.GetStatus().CheckTerminate())
{ {
dsiInfo.TermIdx.emplace_back(i); dsiInfo.TermIdx.emplace_back(i);
dsiInfo.TermID.emplace_back(p.ID); dsiInfo.TermID.emplace_back(p.GetID());
} }
else else
{ {
const auto& it = dsiInfo.ParticleBlockIDsMap.find(p.ID); const auto& it = dsiInfo.ParticleBlockIDsMap.find(p.GetID());
VTKM_ASSERT(it != dsiInfo.ParticleBlockIDsMap.end()); VTKM_ASSERT(it != dsiInfo.ParticleBlockIDsMap.end());
auto currBIDs = it->second; auto currBIDs = it->second;
VTKM_ASSERT(!currBIDs.empty()); VTKM_ASSERT(!currBIDs.empty());
std::vector<vtkm::Id> newIDs; 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()); newIDs.assign(std::next(currBIDs.begin(), 1), currBIDs.end());
else else
newIDs = dsiInfo.BoundsMap.FindBlocks(p.Pos, currBIDs); newIDs = dsiInfo.BoundsMap.FindBlocks(p.GetPosition(), currBIDs);
//reset the particle status. //reset the particle status.
p.Status = vtkm::ParticleStatus(); p.GetStatus() = vtkm::ParticleStatus();
if (newIDs.empty()) //No blocks, we're done. if (newIDs.empty()) //No blocks, we're done.
{ {
p.Status.SetTerminate(); p.GetStatus().SetTerminate();
dsiInfo.TermIdx.emplace_back(i); dsiInfo.TermIdx.emplace_back(i);
dsiInfo.TermID.emplace_back(p.ID); dsiInfo.TermID.emplace_back(p.GetID());
} }
else else
{ {
@ -210,12 +210,12 @@ VTKM_CONT inline void DataSetIntegrator<Derived>::ClassifyParticles(
if (dstRank == this->Rank) if (dstRank == this->Rank)
{ {
dsiInfo.A.emplace_back(p); dsiInfo.A.emplace_back(p);
dsiInfo.IdMapA[p.ID] = newIDs; dsiInfo.IdMapA[p.GetID()] = newIDs;
} }
else else
{ {
dsiInfo.I.emplace_back(p); dsiInfo.I.emplace_back(p);
dsiInfo.IdMapI[p.ID] = newIDs; dsiInfo.IdMapI[p.GetID()] = newIDs;
} }
} }
portal.Set(i, p); portal.Set(i, p);

8
vtkm/filter/flow/internal/ParticleMessenger.h
View File

@ -174,9 +174,9 @@ void ParticleMessenger<ParticleType>::SerialExchange(
{ {
for (auto& p : outData) for (auto& p : outData)
{ {
const auto& bids = outBlockIDsMap.find(p.ID)->second; const auto& bids = outBlockIDsMap.find(p.GetID())->second;
inData.emplace_back(p); 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) 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]); int dstRank = this->BoundsMap.FindRank(bids[0]);
sendData[dstRank].emplace_back(std::make_pair(p, bids)); sendData[dstRank].emplace_back(std::make_pair(p, bids));
} }
@ -227,7 +227,7 @@ void ParticleMessenger<ParticleType>::Exchange(
const auto& p = v.first; const auto& p = v.first;
const auto& bids = v.second; const auto& bids = v.second;
inData.emplace_back(p); inData.emplace_back(p);
inDataBlockIDsMap[p.ID] = bids; inDataBlockIDsMap[p.GetID()] = bids;
} }
for (const auto& m : msgData) for (const auto& m : msgData)

24
vtkm/filter/flow/testing/UnitTestParticleMessengerMPI.cxx
View File

@ -85,13 +85,15 @@ void ValidateReceivedParticles(
const auto& reqP = particles[static_cast<std::size_t>(sendRank)][i]; const auto& reqP = particles[static_cast<std::size_t>(sendRank)][i];
const auto& p = recvP[i].first; const auto& p = recvP[i].first;
VTKM_TEST_ASSERT(p.Pos == reqP.Pos, "Received particle has wrong Position."); VTKM_TEST_ASSERT(p.GetPosition() == reqP.GetPosition(),
VTKM_TEST_ASSERT(p.Time == reqP.Time, "Received particle has wrong Time."); "Received particle has wrong Position.");
VTKM_TEST_ASSERT(p.ID == reqP.ID, "Received particle has wrong ID."); VTKM_TEST_ASSERT(p.GetTime() == reqP.GetTime(), "Received particle has wrong Time.");
VTKM_TEST_ASSERT(p.NumSteps == reqP.NumSteps, "Received particle has wrong NumSteps."); 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 && VTKM_TEST_ASSERT(p.GetPosition() == reqP.GetPosition() && p.GetTime() == reqP.GetTime() &&
p.NumSteps == reqP.NumSteps, p.GetID() == reqP.GetID() && p.GetNumberOfSteps() == reqP.GetNumberOfSteps(),
"Received particle has wrong values."); "Received particle has wrong values.");
const auto& reqBids = particleBlockIds[static_cast<std::size_t>(sendRank)][i]; const auto& reqBids = particleBlockIds[static_cast<std::size_t>(sendRank)][i];
@ -153,12 +155,10 @@ void TestParticleMessenger()
for (int p = 0; p < nP; p++) for (int p = 0; p < nP; p++)
{ {
vtkm::Particle particle; vtkm::Particle particle;
particle.Pos[0] = floatDist(generator); particle.SetPosition({ floatDist(generator), floatDist(generator), floatDist(generator) });
particle.Pos[1] = floatDist(generator); particle.SetTime(floatDist(generator));
particle.Pos[2] = floatDist(generator); particle.SetID(pid++);
particle.Time = floatDist(generator); particle.SetNumberOfSteps(nStepsDist(generator));
particle.ID = pid++;
particle.NumSteps = nStepsDist(generator);
pvec.push_back(particle); pvec.push_back(particle);
std::vector<vtkm::Id> bids(bidDist(generator)); std::vector<vtkm::Id> bids(bidDist(generator));

78
vtkm/filter/flow/testing/UnitTestWorkletParticleAdvection.cxx
View File

@ -147,7 +147,7 @@ public:
vtkm::Vec3f& pointOut) const vtkm::Vec3f& pointOut) const
{ {
vtkm::VecVariable<vtkm::Vec3f, 2> values; 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]; pointOut = values[0];
} }
}; };
@ -228,7 +228,7 @@ void ValidateIntegrator(const IntegratorType& integrator,
vtkm::Vec3f result = resultsPortal.Get(index); vtkm::Vec3f result = resultsPortal.Get(index);
VTKM_TEST_ASSERT(status.CheckOk(), "Error in evaluator for " + msg); VTKM_TEST_ASSERT(status.CheckOk(), "Error in evaluator for " + msg);
if (status.CheckSpatialBounds()) 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); "Error in evaluator result for [OUTSIDE SPATIAL]" + msg);
else else
VTKM_TEST_ASSERT(result == expStepResults[static_cast<size_t>(index)], VTKM_TEST_ASSERT(result == expStepResults[static_cast<size_t>(index)],
@ -322,7 +322,7 @@ void TestEvaluators()
GenerateRandomParticles(pointIns, 38, interiorBounds); GenerateRandomParticles(pointIns, 38, interiorBounds);
for (auto& p : pointIns) for (auto& p : pointIns)
stepResult.push_back(p.Pos + vec * stepSize); stepResult.push_back(p.GetPosition() + vec * stepSize);
vtkm::Range xRange, yRange, zRange; vtkm::Range xRange, yRange, zRange;
@ -414,14 +414,16 @@ void TestGhostCellEvaluators()
for (vtkm::Id i = 0; i < numSeeds; i++) for (vtkm::Id i = 0; i < numSeeds; i++)
{ {
const auto& p = posPortal.Get(i); const auto& p = posPortal.Get(i);
VTKM_TEST_ASSERT(p.Status.CheckSpatialBounds(), "Particle did not leave the dataset."); VTKM_TEST_ASSERT(p.GetStatus().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().CheckInGhostCell(), "Particle did not end up in ghost cell.");
//Particles that start in a ghost cell should take no steps. //Particles that start in a ghost cell should take no steps.
if (p.ID == 0 || p.ID == 1 || p.ID == 2) if (p.GetID() == 0 || p.GetID() == 1 || p.GetID() == 2)
VTKM_TEST_ASSERT(p.NumSteps == 0, "Particle in ghost cell should *not* take any steps"); VTKM_TEST_ASSERT(p.GetNumberOfSteps() == 0,
else if (p.ID == 3) "Particle in ghost cell should *not* take any steps");
VTKM_TEST_ASSERT(p.NumSteps == 21, "Wrong number of steps for particle with ghost cells"); 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(); auto portal = res.Particles.ReadPortal();
for (vtkm::Id i = 0; i < nSeeds; i++) for (vtkm::Id i = 0; i < nSeeds; i++)
{ {
auto stepsTaken = portal.Get(i).NumSteps; auto stepsTaken = portal.Get(i).GetNumberOfSteps();
auto status = portal.Get(i).Status; auto status = portal.Get(i).GetStatus();
VTKM_TEST_ASSERT(stepsTaken <= maxSteps, "Too many steps taken in particle advection"); VTKM_TEST_ASSERT(stepsTaken <= maxSteps, "Too many steps taken in particle advection");
if (stepsTaken == maxSteps) if (stepsTaken == maxSteps)
VTKM_TEST_ASSERT(status.CheckTerminate(), "Particle expected to be terminated"); 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(); auto portal = res.Particles.ReadPortal();
for (vtkm::Id i = 0; i < nSeeds; i++) 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).GetNumberOfSteps() <= maxSteps,
VTKM_TEST_ASSERT(portal.Get(i).Status.CheckOk(), "Bad status in streamline"); "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, VTKM_TEST_ASSERT(res.Particles.GetNumberOfValues() == nSeeds,
"Number of output particles does not match input."); "Number of output particles does not match input.");
@ -556,7 +559,7 @@ void TestParticleWorkletsWithDataSetTypes()
vtkm::Id nSeeds = static_cast<vtkm::Id>(pts.size()); vtkm::Id nSeeds = static_cast<vtkm::Id>(pts.size());
std::vector<vtkm::Id> stepsTaken = { 10, 20, 600 }; std::vector<vtkm::Id> stepsTaken = { 10, 20, 600 };
for (std::size_t i = 0; i < stepsTaken.size(); i++) for (std::size_t i = 0; i < stepsTaken.size(); i++)
pts2[i].NumSteps = stepsTaken[i]; pts2[i].SetNumberOfSteps(stepsTaken[i]);
for (auto& ds : dataSets) for (auto& ds : dataSets)
{ {
@ -644,10 +647,10 @@ void TestParticleStatus()
pa.Run(rk4, seedsArray, maxSteps); pa.Run(rk4, seedsArray, maxSteps);
auto portal = seedsArray.ReadPortal(); auto portal = seedsArray.ReadPortal();
bool tookStep0 = portal.Get(0).Status.CheckTookAnySteps(); bool tookStep0 = portal.Get(0).GetStatus().CheckTookAnySteps();
bool tookStep1 = portal.Get(1).Status.CheckTookAnySteps(); bool tookStep1 = portal.Get(1).GetStatus().CheckTookAnySteps();
bool isZero0 = portal.Get(0).Status.CheckZeroVelocity(); bool isZero0 = portal.Get(0).GetStatus().CheckZeroVelocity();
bool isZero1 = portal.Get(1).Status.CheckZeroVelocity(); bool isZero1 = portal.Get(1).GetStatus().CheckZeroVelocity();
if (vtkm::Magnitude(vec) > 0) 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(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(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(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(); auto portal = res.Particles.ReadPortal();
for (vtkm::Id i = 0; i < res.Particles.GetNumberOfValues(); i++) 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"); "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"); "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"); "Particle advection Time is wrong");
VTKM_TEST_ASSERT(portal.Get(i).Status.CheckOk(), "Particle advection Status is wrong"); VTKM_TEST_ASSERT(portal.Get(i).GetStatus().CheckOk(),
VTKM_TEST_ASSERT(portal.Get(i).Status.CheckTerminate(), "Particle advection Status is wrong");
VTKM_TEST_ASSERT(portal.Get(i).GetStatus().CheckTerminate(),
"Particle advection particle did not terminate"); "Particle advection particle did not terminate");
} }
} }
@ -770,13 +775,14 @@ void TestWorkletsBasic()
auto parPortal = res.Particles.ReadPortal(); auto parPortal = res.Particles.ReadPortal();
for (vtkm::Id i = 0; i < res.Particles.GetNumberOfValues(); i++) 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"); "Streamline end point is wrong");
VTKM_TEST_ASSERT(parPortal.Get(i).NumSteps == maxSteps, "Streamline NumSteps is wrong"); VTKM_TEST_ASSERT(parPortal.Get(i).GetNumberOfSteps() == maxSteps,
VTKM_TEST_ASSERT(vtkm::Abs(parPortal.Get(i).Time - endT) < stepSize / 100, "Streamline NumSteps is wrong");
VTKM_TEST_ASSERT(vtkm::Abs(parPortal.Get(i).GetTime() - endT) < stepSize / 100,
"Streamline Time is wrong"); "Streamline Time is wrong");
VTKM_TEST_ASSERT(parPortal.Get(i).Status.CheckOk(), "Streamline Status is wrong"); VTKM_TEST_ASSERT(parPortal.Get(i).GetStatus().CheckOk(), "Streamline Status is wrong");
VTKM_TEST_ASSERT(parPortal.Get(i).Status.CheckTerminate(), VTKM_TEST_ASSERT(parPortal.Get(i).GetStatus().CheckTerminate(),
"Streamline particle did not terminate"); "Streamline particle did not terminate");
} }
@ -815,17 +821,19 @@ void ValidateResult(const ResultType& res,
auto portal = res.Particles.ReadPortal(); auto portal = res.Particles.ReadPortal();
for (vtkm::Id i = 0; i < 3; i++) 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::Vec3f e = endPts[static_cast<std::size_t>(i)];
VTKM_TEST_ASSERT(vtkm::Magnitude(p - e) <= eps, "Particle advection point is wrong"); VTKM_TEST_ASSERT(vtkm::Magnitude(p - e) <= eps, "Particle advection point is wrong");
if (portal.Get(i).Status.CheckZeroVelocity()) if (portal.Get(i).GetStatus().CheckZeroVelocity())
VTKM_TEST_ASSERT(portal.Get(i).NumSteps > 0, "Particle advection NumSteps is wrong"); VTKM_TEST_ASSERT(portal.Get(i).GetNumberOfSteps() > 0,
"Particle advection NumSteps is wrong");
else else
VTKM_TEST_ASSERT(portal.Get(i).NumSteps == maxSteps, "Particle advection NumSteps is wrong"); VTKM_TEST_ASSERT(portal.Get(i).GetNumberOfSteps() == maxSteps,
VTKM_TEST_ASSERT(portal.Get(i).Status.CheckOk(), "Particle advection Status is wrong"); "Particle advection NumSteps 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"); "Particle advection particle did not terminate");
} }
} }

2
vtkm/filter/flow/testing/UnitTestWorkletTemporalAdvection.cxx
View File

@ -57,7 +57,7 @@ public:
vtkm::Vec3f& pointOut) const vtkm::Vec3f& pointOut) const
{ {
vtkm::VecVariable<vtkm::Vec3f, 2> values; 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) if (values.GetNumberOfComponents() > 0)
pointOut = values[0]; pointOut = values[0];
} }

2
vtkm/filter/flow/worklet/EulerIntegrator.h
View File

@ -38,7 +38,7 @@ public:
vtkm::FloatDefault stepLength, vtkm::FloatDefault stepLength,
vtkm::Vec3f& velocity) const vtkm::Vec3f& velocity) const
{ {
auto time = particle.Time; auto time = particle.GetTime();
auto inpos = particle.GetEvaluationPosition(stepLength); auto inpos = particle.GetEvaluationPosition(stepLength);
vtkm::VecVariable<vtkm::Vec3f, 2> vectors; vtkm::VecVariable<vtkm::Vec3f, 2> vectors;
GridEvaluatorStatus evalStatus = this->Evaluator.Evaluate(inpos, time, vectors); GridEvaluatorStatus evalStatus = this->Evaluator.Evaluate(inpos, time, vectors);

10
vtkm/filter/flow/worklet/ParticleAdvection.h
View File

@ -38,11 +38,11 @@ public:
const vtkm::Id& step, const vtkm::Id& step,
ParticleType& particle) const ParticleType& particle) const
{ {
particle.Pos = pt; particle.SetPosition(pt);
particle.ID = id; particle.SetID(id);
particle.Time = time; particle.SetTime(time);
particle.NumSteps = step; particle.SetNumberOfSteps(step);
particle.Status.SetOk(); particle.GetStatus().SetOk();
} }
}; };

8
vtkm/filter/flow/worklet/ParticleAdvectionWorklets.h
View File

@ -48,7 +48,7 @@ public:
const vtkm::Id& maxSteps) const const vtkm::Id& maxSteps) const
{ {
auto particle = integralCurve.GetParticle(idx); auto particle = integralCurve.GetParticle(idx);
vtkm::FloatDefault time = particle.Time; vtkm::FloatDefault time = particle.GetTime();
bool tookAnySteps = false; bool tookAnySteps = false;
//the integrator status needs to be more robust: //the integrator status needs to be more robust:
@ -143,7 +143,7 @@ public:
template <typename ParticleType> template <typename ParticleType>
VTKM_EXEC void operator()(const ParticleType& p, vtkm::Id& numSteps) const 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); using ExecutionSignature = void(_1, _2, _3);
// Offset is number of points in streamline. // 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> template <typename ParticleType>
VTKM_EXEC void operator()(const ParticleType& p, VTKM_EXEC void operator()(const ParticleType& p,
const vtkm::Id& initialNumSteps, const vtkm::Id& initialNumSteps,
vtkm::Id& diff) const vtkm::Id& diff) const
{ {
diff = 1 + p.NumSteps - initialNumSteps; diff = 1 + p.GetNumberOfSteps() - initialNumSteps;
} }
}; };
} // namespace detail } // namespace detail

30
vtkm/filter/flow/worklet/Particles.h
View File

@ -54,9 +54,9 @@ public:
const vtkm::Vec3f& pt) const vtkm::Vec3f& pt)
{ {
ParticleType newParticle(particle); ParticleType newParticle(particle);
newParticle.Pos = pt; newParticle.SetPosition(pt);
newParticle.Time = time; newParticle.SetTime(time);
newParticle.NumSteps++; newParticle.SetNumberOfSteps(particle.GetNumberOfSteps() + 1);
this->Particles.Set(idx, newParticle); this->Particles.Set(idx, newParticle);
} }
@ -67,37 +67,37 @@ public:
{ {
ParticleType p(this->GetParticle(idx)); ParticleType p(this->GetParticle(idx));
if (p.NumSteps == maxSteps) if (p.GetNumberOfSteps() == maxSteps)
p.Status.SetTerminate(); p.GetStatus().SetTerminate();
if (status.CheckFail()) if (status.CheckFail())
p.Status.SetFail(); p.GetStatus().SetFail();
if (status.CheckSpatialBounds()) if (status.CheckSpatialBounds())
p.Status.SetSpatialBounds(); p.GetStatus().SetSpatialBounds();
if (status.CheckTemporalBounds()) if (status.CheckTemporalBounds())
p.Status.SetTemporalBounds(); p.GetStatus().SetTemporalBounds();
if (status.CheckInGhostCell()) if (status.CheckInGhostCell())
p.Status.SetInGhostCell(); p.GetStatus().SetInGhostCell();
if (status.CheckZeroVelocity()) if (status.CheckZeroVelocity())
{ {
p.Status.SetZeroVelocity(); p.GetStatus().SetZeroVelocity();
p.Status.SetTerminate(); p.GetStatus().SetTerminate();
} }
this->Particles.Set(idx, p); this->Particles.Set(idx, p);
} }
VTKM_EXEC 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 VTKM_EXEC
void UpdateTookSteps(const vtkm::Id& idx, bool val) void UpdateTookSteps(const vtkm::Id& idx, bool val)
{ {
ParticleType p(this->GetParticle(idx)); ParticleType p(this->GetParticle(idx));
if (val) if (val)
p.Status.SetTookAnySteps(); p.GetStatus().SetTookAnySteps();
else else
p.Status.ClearTookAnySteps(); p.GetStatus().ClearTookAnySteps();
this->Particles.Set(idx, p); this->Particles.Set(idx, p);
} }
@ -172,7 +172,7 @@ public:
if (this->StepCount.Get(idx) == 0) if (this->StepCount.Get(idx) == 0)
{ {
vtkm::Id loc = idx * Length; vtkm::Id loc = idx * Length;
this->History.Set(loc, p.Pos); this->History.Set(loc, p.GetPosition());
this->ValidPoint.Set(loc, 1); this->ValidPoint.Set(loc, 1);
this->StepCount.Set(idx, 1); this->StepCount.Set(idx, 1);
} }

2
vtkm/filter/flow/worklet/RK4Integrator.h
View File

@ -38,7 +38,7 @@ public:
vtkm::FloatDefault stepLength, vtkm::FloatDefault stepLength,
vtkm::Vec3f& velocity) const vtkm::Vec3f& velocity) const
{ {
auto time = particle.Time; auto time = particle.GetTime();
auto inpos = particle.GetEvaluationPosition(stepLength); auto inpos = particle.GetEvaluationPosition(stepLength);
vtkm::FloatDefault boundary = this->Evaluator.GetTemporalBoundary(static_cast<vtkm::Id>(1)); vtkm::FloatDefault boundary = this->Evaluator.GetTemporalBoundary(static_cast<vtkm::Id>(1));
if ((time + stepLength + vtkm::Epsilon<vtkm::FloatDefault>() - boundary) > 0.0) if ((time + stepLength + vtkm::Epsilon<vtkm::FloatDefault>() - boundary) > 0.0)

12
vtkm/filter/flow/worklet/Stepper.h
View File

@ -57,11 +57,11 @@ public:
auto status = this->Integrator.CheckStep(particle, this->DeltaT, velocity); auto status = this->Integrator.CheckStep(particle, this->DeltaT, velocity);
if (status.CheckOk()) if (status.CheckOk())
{ {
outpos = particle.Pos + this->DeltaT * velocity; outpos = particle.GetPosition() + this->DeltaT * velocity;
time += this->DeltaT; time += this->DeltaT;
} }
else else
outpos = particle.Pos; outpos = particle.GetPosition();
return status; return status;
} }
@ -84,7 +84,7 @@ public:
vtkm::Vec3f currPos(particle.GetEvaluationPosition(this->DeltaT)); vtkm::Vec3f currPos(particle.GetEvaluationPosition(this->DeltaT));
vtkm::Vec3f currVelocity(0, 0, 0); vtkm::Vec3f currVelocity(0, 0, 0);
vtkm::VecVariable<vtkm::Vec3f, 2> currValue, tmp; 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()) if (evalStatus.CheckFail())
return IntegratorStatus(evalStatus, false); return IntegratorStatus(evalStatus, false);
@ -102,8 +102,8 @@ public:
if (status.CheckOk()) //Integration step succedded. if (status.CheckOk()) //Integration step succedded.
{ {
//See if this point is in/out. //See if this point is in/out.
auto newPos = particle.Pos + currStep * currVelocity; auto newPos = particle.GetPosition() + currStep * currVelocity;
evalStatus = this->Evaluator.Evaluate(newPos, particle.Time + currStep, tmp); evalStatus = this->Evaluator.Evaluate(newPos, particle.GetTime() + currStep, tmp);
if (evalStatus.CheckOk()) if (evalStatus.CheckOk())
{ {
//Point still in. Update currPos and set range to {currStep, stepRange[1]} //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* // The eval at Time + stepRange[0] better be *inside*
VTKM_ASSERT(evalStatus.CheckOk() && !evalStatus.CheckSpatialBounds()); VTKM_ASSERT(evalStatus.CheckOk() && !evalStatus.CheckSpatialBounds());
if (evalStatus.CheckFail() || evalStatus.CheckSpatialBounds()) if (evalStatus.CheckFail() || evalStatus.CheckSpatialBounds())