Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-07-06 07:17:25 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Hide Particle class members

Browse Source 
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.
This commit is contained in:
Kenneth Moreland 2022-12-13 13:10:13 -05:00
parent 63c5bf9116
commit 99829cf617
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 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);

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++)
{
vtkm::Particle p;
p.Pos = ptsPortal.Get(i);
p.ID = i;
p.SetPosition(ptsPortal.Get(i));
p.SetID(i);
seedPortal.Set(i, p);
}

97
vtkm/Particle.h
View File

@ -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);

14
vtkm/cont/ParticleArrayCopy.hxx
View File

@ -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();
}
};

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

@ -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++;
}
}

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

@ -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];
}
};

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
{
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);
}
};

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

@ -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);

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);
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);

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

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

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& 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));

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

@ -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");
}
}

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

@ -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];
}

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

@ -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);

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

@ -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();
}
};

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

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

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

@ -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);
}

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

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

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

@ -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())