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

Rename the Particle classes.

Browse Source
This commit is contained in:
Dave Pugmire 2020-08-26 08:59:51 -04:00
parent 83f792b64c
commit 855e973a20
26 changed files with 210 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
vtkm/Particle.h
View File

@ -65,24 +65,24 @@ inline VTKM_CONT std::ostream& operator<<(std::ostream& s, const vtkm::ParticleS
return s; return s;
} }
class Particle class ParticleBase
{ {
public: public:
VTKM_EXEC_CONT VTKM_EXEC_CONT
Particle() {} ParticleBase() {}
VTKM_EXEC_CONT virtual ~Particle() noexcept VTKM_EXEC_CONT virtual ~ParticleBase() noexcept
{ {
// This must not be defaulted, since defaulted virtual destructors are // This must not be defaulted, since defaulted virtual destructors are
// troublesome with CUDA __host__ __device__ markup. // troublesome with CUDA __host__ __device__ markup.
} }
VTKM_EXEC_CONT VTKM_EXEC_CONT
Particle(const vtkm::Vec3f& p, ParticleBase(const vtkm::Vec3f& p,
const vtkm::Id& id, const vtkm::Id& id,
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) : Pos(p)
, ID(id) , ID(id)
, NumSteps(numSteps) , NumSteps(numSteps)
@ -92,7 +92,7 @@ public:
} }
VTKM_EXEC_CONT VTKM_EXEC_CONT
Particle(const vtkm::Particle& p) ParticleBase(const vtkm::ParticleBase& p)
: Pos(p.Pos) : Pos(p.Pos)
, ID(p.ID) , ID(p.ID)
, NumSteps(p.NumSteps) , NumSteps(p.NumSteps)
@ -101,7 +101,7 @@ public:
{ {
} }
vtkm::Particle& operator=(const vtkm::Particle&) = default; vtkm::ParticleBase& operator=(const vtkm::ParticleBase&) = default;
// The basic particle is only meant to be advected in a velocity // The basic particle is only meant to be advected in a velocity
// field. In that case it is safe to assume that the velocity value // field. In that case it is safe to assume that the velocity value
@ -123,13 +123,13 @@ public:
vtkm::FloatDefault Time = 0; vtkm::FloatDefault Time = 0;
}; };
class Massless : public vtkm::Particle class Particle : public vtkm::ParticleBase
{ {
public: public:
VTKM_EXEC_CONT VTKM_EXEC_CONT
Massless() {} Particle() {}
VTKM_EXEC_CONT ~Massless() noexcept override VTKM_EXEC_CONT ~Particle() noexcept override
{ {
// This must not be defaulted, since defaulted virtual destructors are // This must not be defaulted, since defaulted virtual destructors are
// troublesome with CUDA __host__ __device__ markup. // troublesome with CUDA __host__ __device__ markup.
@ -137,21 +137,15 @@ public:
VTKM_EXEC_CONT VTKM_EXEC_CONT
Massless(const vtkm::Vec3f& p, Particle(const vtkm::Vec3f& p,
const vtkm::Id& id, const vtkm::Id& id,
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)
: Particle(p, id, numSteps, status, time) : ParticleBase(p, id, numSteps, status, time)
{ {
} }
/*VTKM_EXEC_CONT
Massless(const vtkm::Massless& p)
: Particle(p)
{
}*/
VTKM_EXEC_CONT VTKM_EXEC_CONT
vtkm::Vec3f Next(const vtkm::VecVariable<vtkm::Vec3f, 2>& vectors, vtkm::Vec3f Next(const vtkm::VecVariable<vtkm::Vec3f, 2>& vectors,
const vtkm::FloatDefault& length) override const vtkm::FloatDefault& length) override
@ -171,7 +165,7 @@ public:
} }
}; };
class Electron : public vtkm::Particle class Electron : public vtkm::ParticleBase
{ {
public: public:
VTKM_EXEC_CONT VTKM_EXEC_CONT
@ -187,7 +181,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)
: Particle(position, id, numSteps, status, time) : ParticleBase(position, id, numSteps, status, time)
, Mass(mass) , Mass(mass)
, Charge(charge) , Charge(charge)
, Weighting(weighting) , Weighting(weighting)
@ -255,6 +249,8 @@ private:
vtkm::Vec3f Momentum; vtkm::Vec3f Momentum;
constexpr static vtkm::FloatDefault SPEED_OF_LIGHT = constexpr static vtkm::FloatDefault SPEED_OF_LIGHT =
static_cast<vtkm::FloatDefault>(2.99792458e8); static_cast<vtkm::FloatDefault>(2.99792458e8);
friend struct mangled_diy_namespace::Serialization<vtkm::Electron>;
}; };
} //namespace vtkm } //namespace vtkm
@ -263,10 +259,10 @@ private:
namespace mangled_diy_namespace namespace mangled_diy_namespace
{ {
template <> template <>
struct Serialization<vtkm::Massless> struct Serialization<vtkm::Particle>
{ {
public: public:
static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::Massless& p) static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::Particle& p)
{ {
vtkmdiy::save(bb, p.Pos); vtkmdiy::save(bb, p.Pos);
vtkmdiy::save(bb, p.ID); vtkmdiy::save(bb, p.ID);
@ -275,7 +271,7 @@ public:
vtkmdiy::save(bb, p.Time); vtkmdiy::save(bb, p.Time);
} }
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::Massless& p) static VTKM_CONT void load(BinaryBuffer& bb, vtkm::Particle& p)
{ {
vtkmdiy::load(bb, p.Pos); vtkmdiy::load(bb, p.Pos);
vtkmdiy::load(bb, p.ID); vtkmdiy::load(bb, p.ID);
@ -284,6 +280,37 @@ public:
vtkmdiy::load(bb, p.Time); vtkmdiy::load(bb, p.Time);
} }
}; };
template <>
struct Serialization<vtkm::Electron>
{
public:
static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::Electron& e)
{
vtkmdiy::save(bb, e.Pos);
vtkmdiy::save(bb, e.ID);
vtkmdiy::save(bb, e.NumSteps);
vtkmdiy::save(bb, e.Status);
vtkmdiy::save(bb, e.Time);
vtkmdiy::save(bb, e.Mass);
vtkmdiy::save(bb, e.Charge);
vtkmdiy::save(bb, e.Weighting);
vtkmdiy::save(bb, e.Momentum);
}
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::Electron& e)
{
vtkmdiy::load(bb, e.Pos);
vtkmdiy::load(bb, e.ID);
vtkmdiy::load(bb, e.NumSteps);
vtkmdiy::load(bb, e.Status);
vtkmdiy::load(bb, e.Time);
vtkmdiy::load(bb, e.Mass);
vtkmdiy::load(bb, e.Charge);
vtkmdiy::load(bb, e.Weighting);
vtkmdiy::load(bb, e.Momentum);
}
};
} }
#endif // vtk_m_Particle_h #endif // vtk_m_Particle_h

17
vtkm/cont/ParticleArrayCopy.hxx
View File

@ -26,18 +26,21 @@ namespace cont
namespace detail namespace detail
{ {
template <typename ParticleType>
struct ExtractPositionFunctor struct ExtractPositionFunctor
{ {
VTKM_EXEC_CONT VTKM_EXEC_CONT
vtkm::Vec3f operator()(const vtkm::Massless& p) const { return p.Pos; } vtkm::Vec3f operator()(const ParticleType& p) const { return p.Pos; }
}; };
template <typename ParticleType>
struct ExtractTerminatedFunctor struct ExtractTerminatedFunctor
{ {
VTKM_EXEC_CONT VTKM_EXEC_CONT
bool operator()(const vtkm::Massless& p) const { return p.Status.CheckTerminate(); } bool operator()(const ParticleType& p) const { return p.Status.CheckTerminate(); }
}; };
template <typename ParticleType>
struct CopyParticleAllWorklet : public vtkm::worklet::WorkletMapField struct CopyParticleAllWorklet : public vtkm::worklet::WorkletMapField
{ {
using ControlSignature = void(FieldIn inParticle, using ControlSignature = void(FieldIn inParticle,
@ -47,7 +50,7 @@ struct CopyParticleAllWorklet : public vtkm::worklet::WorkletMapField
FieldOut outStatus, FieldOut outStatus,
FieldOut outTime); FieldOut outTime);
VTKM_EXEC void operator()(const vtkm::Particle& inParticle, VTKM_EXEC void operator()(const ParticleType& inParticle,
vtkm::Vec3f& outPos, vtkm::Vec3f& outPos,
vtkm::Id& outID, vtkm::Id& outID,
vtkm::Id& outSteps, vtkm::Id& outSteps,
@ -71,11 +74,13 @@ VTKM_ALWAYS_EXPORT inline void ParticleArrayCopy(
vtkm::cont::ArrayHandle<vtkm::Vec3f, vtkm::cont::StorageTagBasic>& outPos, vtkm::cont::ArrayHandle<vtkm::Vec3f, vtkm::cont::StorageTagBasic>& outPos,
bool CopyTerminatedOnly) bool CopyTerminatedOnly)
{ {
auto posTrn = vtkm::cont::make_ArrayHandleTransform(inP, detail::ExtractPositionFunctor()); auto posTrn =
vtkm::cont::make_ArrayHandleTransform(inP, detail::ExtractPositionFunctor<ParticleType>());
if (CopyTerminatedOnly) if (CopyTerminatedOnly)
{ {
auto termTrn = vtkm::cont::make_ArrayHandleTransform(inP, detail::ExtractTerminatedFunctor()); auto termTrn =
vtkm::cont::make_ArrayHandleTransform(inP, detail::ExtractTerminatedFunctor<ParticleType>());
vtkm::cont::Algorithm::CopyIf(posTrn, termTrn, outPos); vtkm::cont::Algorithm::CopyIf(posTrn, termTrn, outPos);
} }
else else
@ -99,7 +104,7 @@ VTKM_ALWAYS_EXPORT inline void ParticleArrayCopy(
vtkm::cont::ArrayHandle<vtkm::FloatDefault, vtkm::cont::StorageTagBasic>& outTime) vtkm::cont::ArrayHandle<vtkm::FloatDefault, vtkm::cont::StorageTagBasic>& outTime)
{ {
vtkm::cont::Invoker invoke; vtkm::cont::Invoker invoke;
detail::CopyParticleAllWorklet worklet; detail::CopyParticleAllWorklet<ParticleType> worklet;
invoke(worklet, inP, outPos, outID, outSteps, outStatus, outTime); invoke(worklet, inP, outPos, outID, outSteps, outStatus, outTime);
} }

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

@ -19,14 +19,14 @@ void TestParticleArrayCopy()
vtkm::FloatDefault x0(-1), x1(1); vtkm::FloatDefault x0(-1), x1(1);
std::uniform_real_distribution<vtkm::FloatDefault> dist(x0, x1); std::uniform_real_distribution<vtkm::FloatDefault> dist(x0, x1);
std::vector<vtkm::Massless> particles; std::vector<vtkm::Particle> particles;
vtkm::Id N = 17; vtkm::Id N = 17;
for (vtkm::Id i = 0; i < N; i++) for (vtkm::Id i = 0; i < N; i++)
{ {
auto x = dist(generator); auto x = dist(generator);
auto y = dist(generator); auto y = dist(generator);
auto z = dist(generator); auto z = dist(generator);
particles.push_back(vtkm::Massless(vtkm::Vec3f(x, y, z), i)); particles.push_back(vtkm::Particle(vtkm::Vec3f(x, y, z), i));
} }
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; i++)
@ -37,7 +37,7 @@ void TestParticleArrayCopy()
if (i == 0) if (i == 0)
{ {
vtkm::cont::ArrayHandle<vtkm::Vec3f> pos; vtkm::cont::ArrayHandle<vtkm::Vec3f> pos;
vtkm::cont::ParticleArrayCopy<vtkm::Massless>(particleAH, pos); vtkm::cont::ParticleArrayCopy<vtkm::Particle>(particleAH, pos);
auto pPortal = particleAH.ReadPortal(); auto pPortal = particleAH.ReadPortal();
for (vtkm::Id j = 0; j < N; j++) for (vtkm::Id j = 0; j < N; j++)
@ -54,7 +54,7 @@ void TestParticleArrayCopy()
vtkm::cont::ArrayHandle<vtkm::ParticleStatus> status; vtkm::cont::ArrayHandle<vtkm::ParticleStatus> status;
vtkm::cont::ArrayHandle<vtkm::FloatDefault> ptime; vtkm::cont::ArrayHandle<vtkm::FloatDefault> ptime;
vtkm::cont::ParticleArrayCopy<vtkm::Massless>(particleAH, pos, ids, steps, status, ptime); vtkm::cont::ParticleArrayCopy<vtkm::Particle>(particleAH, pos, ids, steps, status, ptime);
auto pPortal = particleAH.ReadPortal(); auto pPortal = particleAH.ReadPortal();
for (vtkm::Id j = 0; j < N; j++) for (vtkm::Id j = 0; j < N; j++)

16
vtkm/filter/Lagrangian.hxx
View File

@ -34,8 +34,8 @@
#include <string.h> #include <string.h>
static vtkm::Id cycle = 0; static vtkm::Id cycle = 0;
static vtkm::cont::ArrayHandle<vtkm::Massless> BasisParticles; static vtkm::cont::ArrayHandle<vtkm::Particle> BasisParticles;
static vtkm::cont::ArrayHandle<vtkm::Massless> BasisParticlesOriginal; static vtkm::cont::ArrayHandle<vtkm::Particle> BasisParticlesOriginal;
static vtkm::cont::ArrayHandle<vtkm::Id> BasisParticlesValidity; static vtkm::cont::ArrayHandle<vtkm::Id> BasisParticlesValidity;
namespace namespace
@ -53,7 +53,7 @@ public:
} }
template <typename ValidityType> template <typename ValidityType>
VTKM_EXEC void operator()(const vtkm::Massless& 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.NumSteps;
if (steps > 0 && res == 1) if (steps > 0 && res == 1)
@ -85,8 +85,8 @@ public:
using InputDomain = _1; using InputDomain = _1;
template <typename DisplacementType> template <typename DisplacementType>
VTKM_EXEC void operator()(const vtkm::Massless& end_point, VTKM_EXEC void operator()(const vtkm::Particle& end_point,
const vtkm::Massless& 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.Pos[0] - start_point.Pos[0];
@ -195,7 +195,7 @@ inline void Lagrangian::InitializeSeedPositions(const vtkm::cont::DataSet& input
{ {
vtkm::FloatDefault xi = static_cast<vtkm::FloatDefault>(x * x_spacing); vtkm::FloatDefault xi = static_cast<vtkm::FloatDefault>(x * x_spacing);
portal1.Set(id, portal1.Set(id,
vtkm::Massless(Vec3f(static_cast<vtkm::FloatDefault>(bounds.X.Min) + xi, vtkm::Particle(Vec3f(static_cast<vtkm::FloatDefault>(bounds.X.Min) + xi,
static_cast<vtkm::FloatDefault>(bounds.Y.Min) + yi, static_cast<vtkm::FloatDefault>(bounds.Y.Min) + yi,
static_cast<vtkm::FloatDefault>(bounds.Z.Min) + zi), static_cast<vtkm::FloatDefault>(bounds.Z.Min) + zi),
id)); id));
@ -266,7 +266,7 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
throw vtkm::cont::ErrorFilterExecution( throw vtkm::cont::ErrorFilterExecution(
"Write frequency can not be 0. Use SetWriteFrequency()."); "Write frequency can not be 0. Use SetWriteFrequency().");
} }
vtkm::cont::ArrayHandle<vtkm::Massless> basisParticleArray; vtkm::cont::ArrayHandle<vtkm::Particle> basisParticleArray;
vtkm::cont::ArrayCopy(BasisParticles, basisParticleArray); vtkm::cont::ArrayCopy(BasisParticles, basisParticleArray);
cycle += 1; cycle += 1;
@ -280,7 +280,7 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>; using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>; using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
vtkm::worklet::ParticleAdvection particleadvection; vtkm::worklet::ParticleAdvection particleadvection;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> res; vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
FieldType velocities(field); FieldType velocities(field);
GridEvalType gridEval(coords, cells, velocities); GridEvalType gridEval(coords, cells, velocities);

8
vtkm/filter/LagrangianStructures.hxx
View File

@ -36,7 +36,7 @@ public:
using ExecutionSignature = void(_1, _2); using ExecutionSignature = void(_1, _2);
using InputDomain = _1; using InputDomain = _1;
VTKM_EXEC void operator()(const vtkm::Massless& particle, vtkm::Vec3f& pt) const VTKM_EXEC void operator()(const vtkm::Particle& particle, vtkm::Vec3f& pt) const
{ {
pt = particle.Pos; pt = particle.Pos;
} }
@ -51,7 +51,7 @@ public:
VTKM_EXEC void operator()(const vtkm::Id index, VTKM_EXEC void operator()(const vtkm::Id index,
const vtkm::Vec3f& seed, const vtkm::Vec3f& seed,
vtkm::Massless& particle) const vtkm::Particle& particle) const
{ {
particle.ID = index; particle.ID = index;
particle.Pos = seed; particle.Pos = seed;
@ -140,8 +140,8 @@ inline VTKM_CONT vtkm::cont::DataSet LagrangianStructures::DoExecute(
GridEvaluator evaluator(input.GetCoordinateSystem(), input.GetCellSet(), velocities); GridEvaluator evaluator(input.GetCoordinateSystem(), input.GetCellSet(), velocities);
Integrator integrator(evaluator, stepSize); Integrator integrator(evaluator, stepSize);
vtkm::worklet::ParticleAdvection particles; vtkm::worklet::ParticleAdvection particles;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> advectionResult; vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> advectionResult;
vtkm::cont::ArrayHandle<vtkm::Massless> advectionPoints; vtkm::cont::ArrayHandle<vtkm::Particle> advectionPoints;
invoke(detail::MakeParticles{}, lcsInputPoints, advectionPoints); invoke(detail::MakeParticles{}, lcsInputPoints, advectionPoints);
advectionResult = particles.Run(integrator, advectionPoints, numberOfSteps); advectionResult = particles.Run(integrator, advectionPoints, numberOfSteps);
invoke(detail::ExtractParticlePosition{}, advectionResult.Particles, lcsOutputPoints); invoke(detail::ExtractParticlePosition{}, advectionResult.Particles, lcsOutputPoints);

4
vtkm/filter/ParticleAdvection.h
View File

@ -38,7 +38,7 @@ public:
void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; } void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; }
VTKM_CONT VTKM_CONT
void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds); void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds);
template <typename DerivedPolicy> template <typename DerivedPolicy>
vtkm::cont::PartitionedDataSet PrepareForExecution( vtkm::cont::PartitionedDataSet PrepareForExecution(
@ -53,7 +53,7 @@ public:
private: private:
vtkm::Id NumberOfSteps; vtkm::Id NumberOfSteps;
vtkm::FloatDefault StepSize; vtkm::FloatDefault StepSize;
vtkm::cont::ArrayHandle<vtkm::Massless> Seeds; vtkm::cont::ArrayHandle<vtkm::Particle> Seeds;
vtkm::worklet::ParticleAdvection Worklet; vtkm::worklet::ParticleAdvection Worklet;
}; };
} }

2
vtkm/filter/ParticleAdvection.hxx
View File

@ -34,7 +34,7 @@ inline VTKM_CONT ParticleAdvection::ParticleAdvection()
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
inline VTKM_CONT void ParticleAdvection::SetSeeds(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds) inline VTKM_CONT void ParticleAdvection::SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds)
{ {
this->Seeds = seeds; this->Seeds = seeds;
} }

4
vtkm/filter/Pathline.h
View File

@ -47,7 +47,7 @@ public:
void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; } void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; }
VTKM_CONT VTKM_CONT
void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds); void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds);
template <typename T, typename StorageType, typename DerivedPolicy> template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute( VTKM_CONT vtkm::cont::DataSet DoExecute(
@ -68,7 +68,7 @@ private:
vtkm::FloatDefault NextTime; vtkm::FloatDefault NextTime;
vtkm::cont::DataSet NextDataSet; vtkm::cont::DataSet NextDataSet;
vtkm::Id NumberOfSteps; vtkm::Id NumberOfSteps;
vtkm::cont::ArrayHandle<vtkm::Massless> Seeds; vtkm::cont::ArrayHandle<vtkm::Particle> Seeds;
}; };
} }
} // namespace vtkm::filter } // namespace vtkm::filter

6
vtkm/filter/Pathline.hxx
View File

@ -34,7 +34,7 @@ inline VTKM_CONT Pathline::Pathline()
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
inline VTKM_CONT void Pathline::SetSeeds(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds) inline VTKM_CONT void Pathline::SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds)
{ {
this->Seeds = seeds; this->Seeds = seeds;
} }
@ -80,9 +80,9 @@ inline VTKM_CONT vtkm::cont::DataSet Pathline::DoExecute(
RK4Type rk4(eval, this->StepSize); RK4Type rk4(eval, this->StepSize);
vtkm::worklet::Streamline streamline; vtkm::worklet::Streamline streamline;
vtkm::worklet::StreamlineResult<vtkm::Massless> res; vtkm::worklet::StreamlineResult<vtkm::Particle> res;
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray; vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
vtkm::cont::ArrayCopy(this->Seeds, seedArray); vtkm::cont::ArrayCopy(this->Seeds, seedArray);
res = Worklet.Run(rk4, seedArray, this->NumberOfSteps); res = Worklet.Run(rk4, seedArray, this->NumberOfSteps);

4
vtkm/filter/StreamSurface.h
View File

@ -40,7 +40,7 @@ public:
void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; } void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; }
VTKM_CONT VTKM_CONT
void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds) { this->Seeds = seeds; } void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds) { this->Seeds = seeds; }
template <typename T, typename StorageType, typename DerivedPolicy> template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute( VTKM_CONT vtkm::cont::DataSet DoExecute(
@ -56,7 +56,7 @@ public:
private: private:
vtkm::Id NumberOfSteps; vtkm::Id NumberOfSteps;
vtkm::cont::ArrayHandle<vtkm::Massless> Seeds; vtkm::cont::ArrayHandle<vtkm::Particle> Seeds;
vtkm::FloatDefault StepSize; vtkm::FloatDefault StepSize;
vtkm::worklet::StreamSurface Worklet; vtkm::worklet::StreamSurface Worklet;
}; };

2
vtkm/filter/StreamSurface.hxx
View File

@ -65,7 +65,7 @@ inline VTKM_CONT vtkm::cont::DataSet StreamSurface::DoExecute(
vtkm::worklet::Streamline streamline; vtkm::worklet::Streamline streamline;
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray; vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
vtkm::cont::ArrayCopy(this->Seeds, seedArray); vtkm::cont::ArrayCopy(this->Seeds, seedArray);
auto res = streamline.Run(rk4, seedArray, this->NumberOfSteps); auto res = streamline.Run(rk4, seedArray, this->NumberOfSteps);

4
vtkm/filter/Streamline.h
View File

@ -37,7 +37,7 @@ public:
void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; } void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; }
VTKM_CONT VTKM_CONT
void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds); void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds);
template <typename DerivedPolicy> template <typename DerivedPolicy>
vtkm::cont::PartitionedDataSet PrepareForExecution( vtkm::cont::PartitionedDataSet PrepareForExecution(
@ -52,7 +52,7 @@ public:
private: private:
vtkm::Id NumberOfSteps; vtkm::Id NumberOfSteps;
vtkm::FloatDefault StepSize; vtkm::FloatDefault StepSize;
vtkm::cont::ArrayHandle<vtkm::Massless> Seeds; vtkm::cont::ArrayHandle<vtkm::Particle> Seeds;
vtkm::worklet::Streamline Worklet; vtkm::worklet::Streamline Worklet;
}; };
} }

2
vtkm/filter/Streamline.hxx
View File

@ -34,7 +34,7 @@ inline VTKM_CONT Streamline::Streamline()
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
inline VTKM_CONT void Streamline::SetSeeds(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds) inline VTKM_CONT void Streamline::SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds)
{ {
this->Seeds = seeds; this->Seeds = seeds;
} }

12
vtkm/filter/particleadvection/DataSetIntegrator.h
View File

@ -55,7 +55,7 @@ public:
vtkm::Id GetID() const { return this->ID; } vtkm::Id GetID() const { return this->ID; }
template <typename ResultType> template <typename ResultType>
void Advect(std::vector<vtkm::Massless>& v, void Advect(std::vector<vtkm::Particle>& v,
vtkm::FloatDefault stepSize, vtkm::FloatDefault stepSize,
vtkm::Id maxSteps, vtkm::Id maxSteps,
ResultType& result) const ResultType& result) const
@ -67,7 +67,7 @@ public:
private: private:
template <typename ResultType> template <typename ResultType>
inline void DoAdvect(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds, inline void DoAdvect(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
const RK4Type& rk4, const RK4Type& rk4,
vtkm::Id maxSteps, vtkm::Id maxSteps,
ResultType& result) const; ResultType& result) const;
@ -81,10 +81,10 @@ private:
// Specialization for ParticleAdvection worklet // Specialization for ParticleAdvection worklet
template <> template <>
inline void DataSetIntegrator::DoAdvect( inline void DataSetIntegrator::DoAdvect(
vtkm::cont::ArrayHandle<vtkm::Massless>& seeds, vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
const RK4Type& rk4, const RK4Type& rk4,
vtkm::Id maxSteps, vtkm::Id maxSteps,
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless>& result) const vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>& result) const
{ {
vtkm::worklet::ParticleAdvection Worklet; vtkm::worklet::ParticleAdvection Worklet;
result = Worklet.Run(rk4, seeds, maxSteps); result = Worklet.Run(rk4, seeds, maxSteps);
@ -94,10 +94,10 @@ inline void DataSetIntegrator::DoAdvect(
// Specialization for Streamline worklet // Specialization for Streamline worklet
template <> template <>
inline void DataSetIntegrator::DoAdvect( inline void DataSetIntegrator::DoAdvect(
vtkm::cont::ArrayHandle<vtkm::Massless>& seeds, vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
const RK4Type& rk4, const RK4Type& rk4,
vtkm::Id maxSteps, vtkm::Id maxSteps,
vtkm::worklet::StreamlineResult<vtkm::Massless>& result) const vtkm::worklet::StreamlineResult<vtkm::Particle>& result) const
{ {
vtkm::worklet::Streamline Worklet; vtkm::worklet::Streamline Worklet;
result = Worklet.Run(rk4, seeds, maxSteps); result = Worklet.Run(rk4, seeds, maxSteps);

38
vtkm/filter/particleadvection/ParticleAdvector.h
View File

@ -54,12 +54,12 @@ public:
void SetStepSize(vtkm::FloatDefault stepSize) { this->StepSize = stepSize; } void SetStepSize(vtkm::FloatDefault stepSize) { this->StepSize = stepSize; }
void SetNumberOfSteps(vtkm::Id numSteps) { this->NumberOfSteps = numSteps; } void SetNumberOfSteps(vtkm::Id numSteps) { this->NumberOfSteps = numSteps; }
virtual void SetSeeds(const vtkm::cont::ArrayHandle<vtkm::Massless>& seeds) = 0; virtual void SetSeeds(const vtkm::cont::ArrayHandle<vtkm::Particle>& seeds) = 0;
virtual void Go() = 0; virtual void Go() = 0;
virtual vtkm::cont::PartitionedDataSet GetOutput() = 0; virtual vtkm::cont::PartitionedDataSet GetOutput() = 0;
protected: protected:
virtual bool GetActiveParticles(std::vector<vtkm::Massless>& particles) = 0; virtual bool GetActiveParticles(std::vector<vtkm::Particle>& particles) = 0;
inline vtkm::Id ComputeTotalNumParticles(vtkm::Id numLocal) const; inline vtkm::Id ComputeTotalNumParticles(vtkm::Id numLocal) const;
@ -68,9 +68,9 @@ protected:
inline void UpdateResult(const ResultType& res, inline void UpdateResult(const ResultType& res,
vtkm::Id blockId, vtkm::Id blockId,
std::vector<vtkm::Massless>& I, std::vector<vtkm::Particle>& I,
std::vector<vtkm::Massless>& T, std::vector<vtkm::Particle>& T,
std::vector<vtkm::Massless>& A); std::vector<vtkm::Particle>& A);
std::vector<DataSetIntegratorType> Blocks; std::vector<DataSetIntegratorType> Blocks;
vtkm::filter::particleadvection::BoundsMap BoundsMap; vtkm::filter::particleadvection::BoundsMap BoundsMap;
@ -99,7 +99,7 @@ public:
{ {
} }
void SetSeeds(const vtkm::cont::ArrayHandle<vtkm::Massless>& seeds) override void SetSeeds(const vtkm::cont::ArrayHandle<vtkm::Particle>& seeds) override
{ {
this->ParticleBlockIDsMap.clear(); this->ParticleBlockIDsMap.clear();
@ -107,7 +107,7 @@ public:
auto portal = seeds.ReadPortal(); auto portal = seeds.ReadPortal();
for (vtkm::Id i = 0; i < n; i++) for (vtkm::Id i = 0; i < n; i++)
{ {
vtkm::Massless p = portal.Get(i); vtkm::Particle p = portal.Get(i);
std::vector<vtkm::Id> blockIDs = this->BoundsMap.FindBlocks(p.Pos); std::vector<vtkm::Id> blockIDs = this->BoundsMap.FindBlocks(p.Pos);
if (!blockIDs.empty() && this->BoundsMap.FindRank(blockIDs[0]) == this->Rank) if (!blockIDs.empty() && this->BoundsMap.FindRank(blockIDs[0]) == this->Rank)
{ {
@ -128,7 +128,7 @@ public:
vtkm::Id N = 0; vtkm::Id N = 0;
while (N < totalNumSeeds) while (N < totalNumSeeds)
{ {
std::vector<vtkm::Massless> v, I, T, A; std::vector<vtkm::Particle> v, I, T, A;
vtkm::Id blockId = -1; vtkm::Id blockId = -1;
if (GetActiveParticles(v)) if (GetActiveParticles(v))
@ -144,7 +144,7 @@ public:
this->Active.insert(this->Active.end(), A.begin(), A.end()); this->Active.insert(this->Active.end(), A.begin(), A.end());
} }
std::vector<vtkm::Massless> incoming; std::vector<vtkm::Particle> incoming;
std::map<vtkm::Id, std::vector<vtkm::Id>> incomingBlockIDsMap; std::map<vtkm::Id, std::vector<vtkm::Id>> incomingBlockIDsMap;
vtkm::Id myTerm = static_cast<vtkm::Id>(T.size()); vtkm::Id myTerm = static_cast<vtkm::Id>(T.size());
vtkm::Id numTermMessages = 0; vtkm::Id numTermMessages = 0;
@ -171,7 +171,7 @@ public:
} }
protected: protected:
bool GetActiveParticles(std::vector<vtkm::Massless>& particles) override bool GetActiveParticles(std::vector<vtkm::Particle>& particles) override
{ {
particles.clear(); particles.clear();
if (this->Active.empty()) if (this->Active.empty())
@ -195,21 +195,21 @@ protected:
} }
protected: protected:
std::vector<vtkm::Massless> Active; std::vector<vtkm::Particle> Active;
std::vector<vtkm::Massless> Inactive; std::vector<vtkm::Particle> Inactive;
std::map<vtkm::Id, std::vector<vtkm::Massless>> Terminated; std::map<vtkm::Id, std::vector<vtkm::Particle>> Terminated;
}; };
class VTKM_ALWAYS_EXPORT ParticleAdvectionAlgorithm class VTKM_ALWAYS_EXPORT ParticleAdvectionAlgorithm
: public PABaseAlgorithm<vtkm::worklet::ParticleAdvectionResult<vtkm::Massless>> : public PABaseAlgorithm<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>>
{ {
using DataSetIntegratorType = vtkm::filter::particleadvection::DataSetIntegrator; using DataSetIntegratorType = vtkm::filter::particleadvection::DataSetIntegrator;
public: public:
ParticleAdvectionAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm, ParticleAdvectionAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
const std::vector<DataSetIntegratorType>& blocks) const std::vector<DataSetIntegratorType>& blocks)
: PABaseAlgorithm<vtkm::worklet::ParticleAdvectionResult<vtkm::Massless>>(bm, blocks) : PABaseAlgorithm<vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>>(bm, blocks)
{ {
} }
@ -251,14 +251,14 @@ protected:
class VTKM_ALWAYS_EXPORT StreamlineAlgorithm class VTKM_ALWAYS_EXPORT StreamlineAlgorithm
: public PABaseAlgorithm<vtkm::worklet::StreamlineResult<vtkm::Massless>> : public PABaseAlgorithm<vtkm::worklet::StreamlineResult<vtkm::Particle>>
{ {
using DataSetIntegratorType = vtkm::filter::particleadvection::DataSetIntegrator; using DataSetIntegratorType = vtkm::filter::particleadvection::DataSetIntegrator;
public: public:
StreamlineAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm, StreamlineAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
const std::vector<DataSetIntegratorType>& blocks) const std::vector<DataSetIntegratorType>& blocks)
: PABaseAlgorithm<vtkm::worklet::StreamlineResult<vtkm::Massless>>(bm, blocks) : PABaseAlgorithm<vtkm::worklet::StreamlineResult<vtkm::Particle>>(bm, blocks)
{ {
} }
@ -350,13 +350,13 @@ public:
} }
protected: protected:
virtual void StoreResult(const vtkm::worklet::StreamlineResult<vtkm::Massless>& res, virtual void StoreResult(const vtkm::worklet::StreamlineResult<vtkm::Particle>& res,
vtkm::Id blockId) override vtkm::Id blockId) override
{ {
this->Results[blockId].push_back(res); this->Results[blockId].push_back(res);
} }
std::map<vtkm::Id, std::vector<vtkm::worklet::StreamlineResult<vtkm::Massless>>> Results; std::map<vtkm::Id, std::vector<vtkm::worklet::StreamlineResult<vtkm::Particle>>> Results;
}; };
} }
} }

8
vtkm/filter/particleadvection/ParticleAdvector.hxx
View File

@ -42,16 +42,16 @@ ParticleAdvectorBase<ResultType>::GetDataSet(vtkm::Id id) const
template <typename ResultType> template <typename ResultType>
inline void ParticleAdvectorBase<ResultType>::UpdateResult(const ResultType& res, inline void ParticleAdvectorBase<ResultType>::UpdateResult(const ResultType& res,
vtkm::Id blockId, vtkm::Id blockId,
std::vector<vtkm::Massless>& I, std::vector<vtkm::Particle>& I,
std::vector<vtkm::Massless>& T, std::vector<vtkm::Particle>& T,
std::vector<vtkm::Massless>& A) std::vector<vtkm::Particle>& A)
{ {
vtkm::Id n = res.Particles.GetNumberOfValues(); vtkm::Id n = res.Particles.GetNumberOfValues();
auto portal = res.Particles.ReadPortal(); auto portal = res.Particles.ReadPortal();
for (vtkm::Id i = 0; i < n; i++) for (vtkm::Id i = 0; i < n; i++)
{ {
vtkm::Massless p = portal.Get(i); vtkm::Particle p = portal.Get(i);
if (p.Status.CheckTerminate()) if (p.Status.CheckTerminate())
{ {

12
vtkm/filter/particleadvection/ParticleMessenger.cxx
View File

@ -54,10 +54,10 @@ std::size_t ParticleMessenger::CalcParticleBufferSize(std::size_t nParticles, st
return return
// rank // rank
sizeof(int) sizeof(int)
//std::vector<vtkm::Massless> p; //std::vector<vtkm::Particle> p;
//p.size() //p.size()
+ sizeof(std::size_t) + sizeof(std::size_t)
//nParticles of vtkm::Massless //nParticles of vtkm::Particle
+ nParticles * pSize + nParticles * pSize
// std::vector<vtkm::Id> blockIDs for each particle. // std::vector<vtkm::Id> blockIDs for each particle.
// blockIDs.size() for each particle // blockIDs.size() for each particle
@ -68,10 +68,10 @@ std::size_t ParticleMessenger::CalcParticleBufferSize(std::size_t nParticles, st
VTKM_CONT VTKM_CONT
void ParticleMessenger::SerialExchange( void ParticleMessenger::SerialExchange(
const std::vector<vtkm::Massless>& outData, const std::vector<vtkm::Particle>& outData,
const std::map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap, const std::map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
vtkm::Id vtkmNotUsed(numLocalTerm), vtkm::Id vtkmNotUsed(numLocalTerm),
std::vector<vtkm::Massless>& inData, std::vector<vtkm::Particle>& inData,
std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap) const std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap) const
{ {
for (auto& p : outData) for (auto& p : outData)
@ -83,10 +83,10 @@ void ParticleMessenger::SerialExchange(
} }
VTKM_CONT VTKM_CONT
void ParticleMessenger::Exchange(const std::vector<vtkm::Massless>& outData, void ParticleMessenger::Exchange(const std::vector<vtkm::Particle>& outData,
const std::map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap, const std::map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
vtkm::Id numLocalTerm, vtkm::Id numLocalTerm,
std::vector<vtkm::Massless>& inData, std::vector<vtkm::Particle>& inData,
std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap, std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
vtkm::Id& numTerminateMessages) vtkm::Id& numTerminateMessages)
{ {

10
vtkm/filter/particleadvection/ParticleMessenger.h
View File

@ -36,7 +36,7 @@ class VTKM_FILTER_EXTRA_EXPORT ParticleMessenger : public vtkm::filter::particle
using MsgCommType = std::pair<int, std::vector<int>>; using MsgCommType = std::pair<int, std::vector<int>>;
//particle + blockIDs. //particle + blockIDs.
using ParticleCommType = std::pair<vtkm::Massless, std::vector<vtkm::Id>>; using ParticleCommType = std::pair<vtkm::Particle, std::vector<vtkm::Id>>;
//sendRank, vector of ParticleCommType. //sendRank, vector of ParticleCommType.
using ParticleRecvCommType = std::pair<int, std::vector<ParticleCommType>>; using ParticleRecvCommType = std::pair<int, std::vector<ParticleCommType>>;
@ -49,10 +49,10 @@ public:
int numBlockIds = 2); int numBlockIds = 2);
VTKM_CONT ~ParticleMessenger() {} VTKM_CONT ~ParticleMessenger() {}
VTKM_CONT void Exchange(const std::vector<vtkm::Massless>& outData, VTKM_CONT void Exchange(const std::vector<vtkm::Particle>& outData,
const std::map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap, const std::map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
vtkm::Id numLocalTerm, vtkm::Id numLocalTerm,
std::vector<vtkm::Massless>& inData, std::vector<vtkm::Particle>& inData,
std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap, std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
vtkm::Id& numTerminateMessages); vtkm::Id& numTerminateMessages);
@ -96,10 +96,10 @@ protected:
#endif #endif
VTKM_CONT void SerialExchange(const std::vector<vtkm::Massless>& outData, VTKM_CONT void SerialExchange(const std::vector<vtkm::Particle>& outData,
const std::map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap, const std::map<vtkm::Id, std::vector<vtkm::Id>>& outBlockIDsMap,
vtkm::Id numLocalTerm, vtkm::Id numLocalTerm,
std::vector<vtkm::Massless>& inData, std::vector<vtkm::Particle>& inData,
std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap) const; std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap) const;
static std::size_t CalcParticleBufferSize(std::size_t nParticles, std::size_t numBlockIds = 2); static std::size_t CalcParticleBufferSize(std::size_t nParticles, std::size_t numBlockIds = 2);

24
vtkm/filter/testing/UnitTestParticleAdvectionFilter.cxx
View File

@ -40,11 +40,11 @@ void TestBasic()
const vtkm::Id3 dims(5, 5, 5); const vtkm::Id3 dims(5, 5, 5);
const vtkm::Vec3f origin(0, 0, 0), spacing(1, 1, 1), vecX(1, 0, 0); const vtkm::Vec3f origin(0, 0, 0), spacing(1, 1, 1), vecX(1, 0, 0);
vtkm::cont::DataSet ds = CreateDataSet(dims, origin, spacing, vecX); vtkm::cont::DataSet ds = CreateDataSet(dims, origin, spacing, vecX);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray = vtkm::cont::ArrayHandle<vtkm::Particle> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0), vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1), vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2), vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2),
vtkm::Massless(vtkm::Vec3f(.2f, 3.2f, .2f), 3) }); vtkm::Particle(vtkm::Vec3f(.2f, 3.2f, .2f), 3) });
vtkm::filter::ParticleAdvection particleAdvection; vtkm::filter::ParticleAdvection particleAdvection;
@ -79,11 +79,11 @@ void TestPartitionedDataSet()
pds.AppendPartition(CreateDataSet(dims, o2, spacing, vecX)); pds.AppendPartition(CreateDataSet(dims, o2, spacing, vecX));
pds.AppendPartition(CreateDataSet(dims, o3, spacing, vecX)); pds.AppendPartition(CreateDataSet(dims, o3, spacing, vecX));
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray; vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0), seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1), vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(4.2f, 1.0f, .2f), 2), vtkm::Particle(vtkm::Vec3f(4.2f, 1.0f, .2f), 2),
vtkm::Massless(vtkm::Vec3f(8.2f, 1.0f, .2f), 3) }); vtkm::Particle(vtkm::Vec3f(8.2f, 1.0f, .2f), 3) });
vtkm::Id numSeeds = seedArray.GetNumberOfValues(); vtkm::Id numSeeds = seedArray.GetNumberOfValues();
@ -145,9 +145,9 @@ void TestFile(const std::string& fname,
} }
vtkm::Id numPoints = static_cast<vtkm::Id>(pts.size()); vtkm::Id numPoints = static_cast<vtkm::Id>(pts.size());
std::vector<vtkm::Massless> seeds; std::vector<vtkm::Particle> seeds;
for (vtkm::Id i = 0; i < numPoints; i++) for (vtkm::Id i = 0; i < numPoints; i++)
seeds.push_back(vtkm::Massless(pts[static_cast<std::size_t>(i)], i)); seeds.push_back(vtkm::Particle(pts[static_cast<std::size_t>(i)], i));
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::On); auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::On);
vtkm::filter::ParticleAdvection particleAdvection; vtkm::filter::ParticleAdvection particleAdvection;

6
vtkm/filter/testing/UnitTestParticleAdvectionFilterMPI.cxx
View File

@ -53,9 +53,9 @@ void TestPartitionedDataSet(int nPerRank)
pds.AppendPartition(CreateDataSet(dims, origin, spacing, vecX)); pds.AppendPartition(CreateDataSet(dims, origin, spacing, vecX));
} }
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray; vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0), seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1) }); vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1) });
vtkm::Id numSeeds = seedArray.GetNumberOfValues(); vtkm::Id numSeeds = seedArray.GetNumberOfValues();

18
vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx
View File

@ -18,9 +18,9 @@
namespace namespace
{ {
using PCommType = std::pair<vtkm::Massless, std::vector<vtkm::Id>>; using PCommType = std::pair<vtkm::Particle, std::vector<vtkm::Id>>;
using MCommType = std::pair<int, std::vector<int>>; using MCommType = std::pair<int, std::vector<int>>;
using PCommType = std::pair<vtkm::Massless, std::vector<vtkm::Id>>; using PCommType = std::pair<vtkm::Particle, std::vector<vtkm::Id>>;
using PRecvCommType = std::pair<int, std::vector<PCommType>>; using PRecvCommType = std::pair<int, std::vector<PCommType>>;
class TestMessenger : public vtkm::filter::particleadvection::ParticleMessenger class TestMessenger : public vtkm::filter::particleadvection::ParticleMessenger
@ -46,7 +46,7 @@ public:
} }
void SendP(int dst, void SendP(int dst,
const std::vector<vtkm::Massless>& p, const std::vector<vtkm::Particle>& p,
const std::vector<std::vector<vtkm::Id>>& bids) const std::vector<std::vector<vtkm::Id>>& bids)
{ {
std::vector<PCommType> data; std::vector<PCommType> data;
@ -71,7 +71,7 @@ public:
void ValidateReceivedParticles( void ValidateReceivedParticles(
int sendRank, int sendRank,
const std::vector<PCommType>& recvP, const std::vector<PCommType>& recvP,
const std::vector<std::vector<vtkm::Massless>>& particles, const std::vector<std::vector<vtkm::Particle>>& particles,
const std::vector<std::vector<std::vector<vtkm::Id>>>& particleBlockIds) const std::vector<std::vector<std::vector<vtkm::Id>>>& particleBlockIds)
{ {
//Make sure the right number of particles were received from sender. //Make sure the right number of particles were received from sender.
@ -128,7 +128,7 @@ void TestParticleMessenger()
TestMessenger messenger(comm, boundsMap, maxMsgSz / 2, maxNumParticles / 2, maxNumBlockIds / 2); TestMessenger messenger(comm, boundsMap, maxMsgSz / 2, maxNumParticles / 2, maxNumBlockIds / 2);
//create some data. //create some data.
std::vector<std::vector<vtkm::Massless>> particles(comm.size()); std::vector<std::vector<vtkm::Particle>> particles(comm.size());
std::vector<std::vector<std::vector<vtkm::Id>>> particleBlockIds(comm.size()); std::vector<std::vector<std::vector<vtkm::Id>>> particleBlockIds(comm.size());
std::vector<std::vector<int>> messages(comm.size()); std::vector<std::vector<int>> messages(comm.size());
@ -148,11 +148,11 @@ void TestParticleMessenger()
for (std::size_t r = 0; r < numRanks; r++) for (std::size_t r = 0; r < numRanks; r++)
{ {
int nP = nPDist(generator); int nP = nPDist(generator);
std::vector<vtkm::Massless> pvec; std::vector<vtkm::Particle> pvec;
std::vector<std::vector<vtkm::Id>> blockIds; std::vector<std::vector<vtkm::Id>> blockIds;
for (int p = 0; p < nP; p++) for (int p = 0; p < nP; p++)
{ {
vtkm::Massless particle; vtkm::Particle particle;
particle.Pos[0] = floatDist(generator); particle.Pos[0] = floatDist(generator);
particle.Pos[1] = floatDist(generator); particle.Pos[1] = floatDist(generator);
particle.Pos[2] = floatDist(generator); particle.Pos[2] = floatDist(generator);
@ -190,7 +190,7 @@ void TestParticleMessenger()
int dst = rankDist(generator); int dst = rankDist(generator);
if (dst != comm.rank()) if (dst != comm.rank())
{ {
std::vector<vtkm::Massless> sendP = particles[rank]; std::vector<vtkm::Particle> sendP = particles[rank];
std::vector<std::vector<vtkm::Id>> sendIds = particleBlockIds[rank]; std::vector<std::vector<vtkm::Id>> sendIds = particleBlockIds[rank];
messenger.SendP(dst, sendP, sendIds); messenger.SendP(dst, sendP, sendIds);
} }
@ -271,7 +271,7 @@ void TestBufferSizes()
std::vector<PCommType> particleData; std::vector<PCommType> particleData;
for (int i = 0; i < numP; i++) for (int i = 0; i < numP; i++)
{ {
vtkm::Massless p; vtkm::Particle p;
std::vector<vtkm::Id> bids(nBids, 0); std::vector<vtkm::Id> bids(nBids, 0);
particleData.push_back(std::make_pair(p, bids)); particleData.push_back(std::make_pair(p, bids));
} }

10
vtkm/filter/testing/UnitTestStreamSurfaceFilter.cxx
View File

@ -38,11 +38,11 @@ void TestStreamSurface()
const vtkm::Vec3f vecX(1, 0, 0); const vtkm::Vec3f vecX(1, 0, 0);
vtkm::cont::DataSet ds = CreateDataSet(dims, vecX); vtkm::cont::DataSet ds = CreateDataSet(dims, vecX);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray = vtkm::cont::ArrayHandle<vtkm::Particle> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.1f, 1.0f, .2f), 0), vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.1f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.1f, 2.0f, .1f), 1), vtkm::Particle(vtkm::Vec3f(.1f, 2.0f, .1f), 1),
vtkm::Massless(vtkm::Vec3f(.1f, 3.0f, .3f), 2), vtkm::Particle(vtkm::Vec3f(.1f, 3.0f, .3f), 2),
vtkm::Massless(vtkm::Vec3f(.1f, 3.5f, .2f), 3) }); vtkm::Particle(vtkm::Vec3f(.1f, 3.5f, .2f), 3) });
vtkm::filter::StreamSurface streamSrf; vtkm::filter::StreamSurface streamSrf;

20
vtkm/filter/testing/UnitTestStreamlineFilter.cxx
View File

@ -38,10 +38,10 @@ void TestStreamline()
const vtkm::Vec3f vecX(1, 0, 0); const vtkm::Vec3f vecX(1, 0, 0);
vtkm::cont::DataSet ds = CreateDataSet(dims, vecX); vtkm::cont::DataSet ds = CreateDataSet(dims, vecX);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray = vtkm::cont::ArrayHandle<vtkm::Particle> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0), vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1), vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2) }); vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
vtkm::filter::Streamline streamline; vtkm::filter::Streamline streamline;
@ -72,10 +72,10 @@ void TestPathline()
vtkm::cont::DataSet ds1 = CreateDataSet(dims, vecX); vtkm::cont::DataSet ds1 = CreateDataSet(dims, vecX);
vtkm::cont::DataSet ds2 = CreateDataSet(dims, vecY); vtkm::cont::DataSet ds2 = CreateDataSet(dims, vecY);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray = vtkm::cont::ArrayHandle<vtkm::Particle> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0), vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1), vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2) }); vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
vtkm::filter::Pathline pathline; vtkm::filter::Pathline pathline;
@ -120,9 +120,9 @@ void TestStreamlineFile(const std::string& fname,
} }
vtkm::Id numPoints = static_cast<vtkm::Id>(pts.size()); vtkm::Id numPoints = static_cast<vtkm::Id>(pts.size());
std::vector<vtkm::Massless> seeds; std::vector<vtkm::Particle> seeds;
for (vtkm::Id i = 0; i < numPoints; i++) for (vtkm::Id i = 0; i < numPoints; i++)
seeds.push_back(vtkm::Massless(pts[static_cast<std::size_t>(i)], i)); seeds.push_back(vtkm::Particle(pts[static_cast<std::size_t>(i)], i));
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off); auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off);
vtkm::filter::Streamline streamline; vtkm::filter::Streamline streamline;

6
vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx
View File

@ -54,9 +54,9 @@ void TestPartitionedDataSet(vtkm::Id nPerRank)
XPartitionRanges.push_back(vtkm::Range(x, x + 4)); XPartitionRanges.push_back(vtkm::Range(x, x + 4));
} }
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray; vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0), seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1) }); vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1) });
vtkm::Id numSeeds = seedArray.GetNumberOfValues(); vtkm::Id numSeeds = seedArray.GetNumberOfValues();
vtkm::filter::Streamline streamline; vtkm::filter::Streamline streamline;

58
vtkm/worklet/testing/UnitTestParticleAdvection.cxx
View File

@ -96,7 +96,7 @@ vtkm::FloatDefault vecData[125 * 3] = {
}; };
} }
void GenerateRandomParticles(std::vector<vtkm::Massless>& points, void GenerateRandomParticles(std::vector<vtkm::Particle>& points,
const std::size_t N, const std::size_t N,
const vtkm::Bounds& bounds, const vtkm::Bounds& bounds,
const std::size_t seed = 314) const std::size_t seed = 314)
@ -117,7 +117,7 @@ void GenerateRandomParticles(std::vector<vtkm::Massless>& points,
p[0] = static_cast<vtkm::FloatDefault>(bounds.X.Min + rx * bounds.X.Length()); p[0] = static_cast<vtkm::FloatDefault>(bounds.X.Min + rx * bounds.X.Length());
p[1] = static_cast<vtkm::FloatDefault>(bounds.Y.Min + ry * bounds.Y.Length()); p[1] = static_cast<vtkm::FloatDefault>(bounds.Y.Min + ry * bounds.Y.Length());
p[2] = static_cast<vtkm::FloatDefault>(bounds.Z.Min + rz * bounds.Z.Length()); p[2] = static_cast<vtkm::FloatDefault>(bounds.Z.Min + rz * bounds.Z.Length());
points.push_back(vtkm::Massless(p, static_cast<vtkm::Id>(i))); points.push_back(vtkm::Particle(p, static_cast<vtkm::Id>(i)));
} }
} }
@ -295,7 +295,7 @@ public:
using ExecutionSignature = void(_1, _2, _3, _4); using ExecutionSignature = void(_1, _2, _3, _4);
template <typename EvaluatorType> template <typename EvaluatorType>
VTKM_EXEC void operator()(vtkm::Massless& pointIn, VTKM_EXEC void operator()(vtkm::Particle& pointIn,
const EvaluatorType& evaluator, const EvaluatorType& evaluator,
vtkm::worklet::particleadvection::GridEvaluatorStatus& status, vtkm::worklet::particleadvection::GridEvaluatorStatus& status,
vtkm::Vec3f& pointOut) const vtkm::Vec3f& pointOut) const
@ -308,7 +308,7 @@ public:
template <typename EvalType> template <typename EvalType>
void ValidateEvaluator(const EvalType& eval, void ValidateEvaluator(const EvalType& eval,
const std::vector<vtkm::Massless>& pointIns, const std::vector<vtkm::Particle>& pointIns,
const vtkm::Vec3f& vec, const vtkm::Vec3f& vec,
const std::string& msg) const std::string& msg)
{ {
@ -317,7 +317,7 @@ void ValidateEvaluator(const EvalType& eval,
using Status = vtkm::worklet::particleadvection::GridEvaluatorStatus; using Status = vtkm::worklet::particleadvection::GridEvaluatorStatus;
EvalTester evalTester; EvalTester evalTester;
EvalTesterDispatcher evalTesterDispatcher(evalTester); EvalTesterDispatcher evalTesterDispatcher(evalTester);
vtkm::cont::ArrayHandle<vtkm::Massless> pointsHandle = vtkm::cont::ArrayHandle<vtkm::Particle> pointsHandle =
vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off); vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off);
vtkm::Id numPoints = pointsHandle.GetNumberOfValues(); vtkm::Id numPoints = pointsHandle.GetNumberOfValues();
vtkm::cont::ArrayHandle<Status> evalStatus; vtkm::cont::ArrayHandle<Status> evalStatus;
@ -345,7 +345,7 @@ public:
using ExecutionSignature = void(_1, _2, _3, _4); using ExecutionSignature = void(_1, _2, _3, _4);
template <typename IntegratorType> template <typename IntegratorType>
VTKM_EXEC void operator()(vtkm::Massless& pointIn, VTKM_EXEC void operator()(vtkm::Particle& pointIn,
const IntegratorType* integrator, const IntegratorType* integrator,
vtkm::worklet::particleadvection::IntegratorStatus& status, vtkm::worklet::particleadvection::IntegratorStatus& status,
vtkm::Vec3f& pointOut) const vtkm::Vec3f& pointOut) const
@ -360,7 +360,7 @@ public:
template <typename IntegratorType> template <typename IntegratorType>
void ValidateIntegrator(const IntegratorType& integrator, void ValidateIntegrator(const IntegratorType& integrator,
const std::vector<vtkm::Massless>& pointIns, const std::vector<vtkm::Particle>& pointIns,
const std::vector<vtkm::Vec3f>& expStepResults, const std::vector<vtkm::Vec3f>& expStepResults,
const std::string& msg) const std::string& msg)
{ {
@ -393,7 +393,7 @@ void ValidateIntegrator(const IntegratorType& integrator,
template <typename IntegratorType> template <typename IntegratorType>
void ValidateIntegratorForBoundary(const vtkm::Bounds& bounds, void ValidateIntegratorForBoundary(const vtkm::Bounds& bounds,
const IntegratorType& integrator, const IntegratorType& integrator,
const std::vector<vtkm::Massless>& pointIns, const std::vector<vtkm::Particle>& pointIns,
const std::string& msg) const std::string& msg)
{ {
using IntegratorTester = TestIntegratorWorklet; using IntegratorTester = TestIntegratorWorklet;
@ -462,7 +462,7 @@ void TestEvaluators()
//vtkm::FloatDefault stepSize = 0.01f; //vtkm::FloatDefault stepSize = 0.01f;
vtkm::FloatDefault stepSize = 0.1f; vtkm::FloatDefault stepSize = 0.1f;
std::vector<vtkm::Massless> pointIns; std::vector<vtkm::Particle> pointIns;
std::vector<vtkm::Vec3f> stepResult; std::vector<vtkm::Vec3f> stepResult;
//Generate points 2 steps inside the bounding box. //Generate points 2 steps inside the bounding box.
@ -499,7 +499,7 @@ void TestEvaluators()
// of the velocity field // of the velocity field
// All velocities are in the +ve direction. // All velocities are in the +ve direction.
std::vector<vtkm::Massless> boundaryPoints; std::vector<vtkm::Particle> boundaryPoints;
GenerateRandomParticles(boundaryPoints, 10, forBoundary, 919); GenerateRandomParticles(boundaryPoints, 10, forBoundary, 919);
for (auto& ds : dataSets) for (auto& ds : dataSets)
@ -517,7 +517,7 @@ void TestEvaluators()
} }
void ValidateParticleAdvectionResult( void ValidateParticleAdvectionResult(
const vtkm::worklet::ParticleAdvectionResult<vtkm::Massless>& res, const vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>& res,
vtkm::Id nSeeds, vtkm::Id nSeeds,
vtkm::Id maxSteps) vtkm::Id maxSteps)
{ {
@ -537,7 +537,7 @@ void ValidateParticleAdvectionResult(
} }
} }
void ValidateStreamlineResult(const vtkm::worklet::StreamlineResult<vtkm::Massless>& res, void ValidateStreamlineResult(const vtkm::worklet::StreamlineResult<vtkm::Particle>& res,
vtkm::Id nSeeds, vtkm::Id nSeeds,
vtkm::Id maxSteps) vtkm::Id maxSteps)
{ {
@ -577,11 +577,11 @@ void TestIntegrators()
GridEvalType eval(dataset.GetCoordinateSystem(), dataset.GetCellSet(), velocities); GridEvalType eval(dataset.GetCoordinateSystem(), dataset.GetCellSet(), velocities);
//Generate three random points. //Generate three random points.
std::vector<vtkm::Massless> points; std::vector<vtkm::Particle> points;
GenerateRandomParticles(points, 3, bounds); GenerateRandomParticles(points, 3, bounds);
vtkm::worklet::ParticleAdvection pa; vtkm::worklet::ParticleAdvection pa;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> res; vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
{ {
auto seeds = vtkm::cont::make_ArrayHandle(points, vtkm::CopyFlag::On); auto seeds = vtkm::cont::make_ArrayHandle(points, vtkm::CopyFlag::On);
using IntegratorType = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>; using IntegratorType = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
@ -640,9 +640,9 @@ void TestParticleWorkletsWithDataSetTypes()
dataSets.push_back(CreateWeirdnessFromStructuredDataSet(dataSets[0], DataSetOption::EXPLICIT)); dataSets.push_back(CreateWeirdnessFromStructuredDataSet(dataSets[0], DataSetOption::EXPLICIT));
//Generate three random points. //Generate three random points.
std::vector<vtkm::Massless> pts; std::vector<vtkm::Particle> pts;
GenerateRandomParticles(pts, 3, bound, 111); GenerateRandomParticles(pts, 3, bound, 111);
std::vector<vtkm::Massless> pts2 = pts; std::vector<vtkm::Particle> pts2 = pts;
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 };
@ -662,7 +662,7 @@ void TestParticleWorkletsWithDataSetTypes()
if (i < 2) if (i < 2)
{ {
vtkm::worklet::ParticleAdvection pa; vtkm::worklet::ParticleAdvection pa;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> res; vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
if (i == 0) if (i == 0)
{ {
auto seeds = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On); auto seeds = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On);
@ -678,7 +678,7 @@ void TestParticleWorkletsWithDataSetTypes()
else else
{ {
vtkm::worklet::Streamline s; vtkm::worklet::Streamline s;
vtkm::worklet::StreamlineResult<vtkm::Massless> res; vtkm::worklet::StreamlineResult<vtkm::Particle> res;
if (i == 2) if (i == 2)
{ {
auto seeds = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On); auto seeds = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On);
@ -723,9 +723,9 @@ void TestParticleStatus()
RK4Type rk4(eval, stepSize); RK4Type rk4(eval, stepSize);
vtkm::worklet::ParticleAdvection pa; vtkm::worklet::ParticleAdvection pa;
std::vector<vtkm::Massless> pts; std::vector<vtkm::Particle> pts;
pts.push_back(vtkm::Massless(vtkm::Vec3f(.5, .5, .5), 0)); pts.push_back(vtkm::Particle(vtkm::Vec3f(.5, .5, .5), 0));
pts.push_back(vtkm::Massless(vtkm::Vec3f(-1, -1, -1), 1)); pts.push_back(vtkm::Particle(vtkm::Vec3f(-1, -1, -1), 1));
auto seedsArray = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On); auto seedsArray = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On);
pa.Run(rk4, seedsArray, maxSteps); pa.Run(rk4, seedsArray, maxSteps);
auto portal = seedsArray.ReadPortal(); auto portal = seedsArray.ReadPortal();
@ -768,7 +768,7 @@ void TestWorkletsBasic()
for (auto w : workletTypes) for (auto w : workletTypes)
{ {
std::vector<vtkm::Massless> particles; std::vector<vtkm::Particle> particles;
std::vector<vtkm::Vec3f> pts, samplePts, endPts; std::vector<vtkm::Vec3f> pts, samplePts, endPts;
vtkm::FloatDefault X = static_cast<vtkm::FloatDefault>(.1); vtkm::FloatDefault X = static_cast<vtkm::FloatDefault>(.1);
vtkm::FloatDefault Y = static_cast<vtkm::FloatDefault>(.1); vtkm::FloatDefault Y = static_cast<vtkm::FloatDefault>(.1);
@ -784,7 +784,7 @@ void TestWorkletsBasic()
for (std::size_t i = 0; i < pts.size(); i++, id++) for (std::size_t i = 0; i < pts.size(); i++, id++)
{ {
vtkm::Vec3f p = pts[i]; vtkm::Vec3f p = pts[i];
particles.push_back(vtkm::Massless(p, id)); particles.push_back(vtkm::Particle(p, id));
samplePts.push_back(p); samplePts.push_back(p);
for (vtkm::Id j = 0; j < maxSteps; j++) for (vtkm::Id j = 0; j < maxSteps; j++)
{ {
@ -799,7 +799,7 @@ void TestWorkletsBasic()
if (w == "particleAdvection") if (w == "particleAdvection")
{ {
vtkm::worklet::ParticleAdvection pa; vtkm::worklet::ParticleAdvection pa;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> res; vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
res = pa.Run(rk4, seedsArray, maxSteps); res = pa.Run(rk4, seedsArray, maxSteps);
@ -823,7 +823,7 @@ void TestWorkletsBasic()
else if (w == "streamline") else if (w == "streamline")
{ {
vtkm::worklet::Streamline s; vtkm::worklet::Streamline s;
vtkm::worklet::StreamlineResult<vtkm::Massless> res; vtkm::worklet::StreamlineResult<vtkm::Particle> res;
res = s.Run(rk4, seedsArray, maxSteps); res = s.Run(rk4, seedsArray, maxSteps);
@ -940,15 +940,15 @@ void TestParticleAdvectionFile(const std::string& fname,
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; i++)
{ {
std::vector<vtkm::Massless> seeds; std::vector<vtkm::Particle> seeds;
for (size_t j = 0; j < pts.size(); j++) for (size_t j = 0; j < pts.size(); j++)
seeds.push_back(vtkm::Massless(pts[j], static_cast<vtkm::Id>(j))); seeds.push_back(vtkm::Particle(pts[j], static_cast<vtkm::Id>(j)));
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off); auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off);
if (i == 0) if (i == 0)
{ {
vtkm::worklet::ParticleAdvection pa; vtkm::worklet::ParticleAdvection pa;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> res; vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
res = pa.Run(rk4, seedArray, maxSteps); res = pa.Run(rk4, seedArray, maxSteps);
ValidateResult(res, maxSteps, endPts); ValidateResult(res, maxSteps, endPts);
@ -956,7 +956,7 @@ void TestParticleAdvectionFile(const std::string& fname,
else if (i == 1) else if (i == 1)
{ {
vtkm::worklet::Streamline s; vtkm::worklet::Streamline s;
vtkm::worklet::StreamlineResult<vtkm::Massless> res; vtkm::worklet::StreamlineResult<vtkm::Particle> res;
res = s.Run(rk4, seedArray, maxSteps); res = s.Run(rk4, seedArray, maxSteps);
ValidateResult(res, maxSteps, endPts); ValidateResult(res, maxSteps, endPts);

10
vtkm/worklet/testing/UnitTestTemporalAdvection.cxx
View File

@ -50,7 +50,7 @@ public:
using ExecutionSignature = void(_1, _2, _3, _4); using ExecutionSignature = void(_1, _2, _3, _4);
template <typename EvaluatorType> template <typename EvaluatorType>
VTKM_EXEC void operator()(vtkm::Massless& pointIn, VTKM_EXEC void operator()(vtkm::Particle& pointIn,
const EvaluatorType& evaluator, const EvaluatorType& evaluator,
vtkm::worklet::particleadvection::GridEvaluatorStatus& status, vtkm::worklet::particleadvection::GridEvaluatorStatus& status,
vtkm::Vec3f& pointOut) const vtkm::Vec3f& pointOut) const
@ -64,7 +64,7 @@ public:
template <typename EvalType> template <typename EvalType>
void ValidateEvaluator(const EvalType& eval, void ValidateEvaluator(const EvalType& eval,
const vtkm::cont::ArrayHandle<vtkm::Massless>& pointIns, const vtkm::cont::ArrayHandle<vtkm::Particle>& pointIns,
const vtkm::cont::ArrayHandle<vtkm::Vec3f>& validity, const vtkm::cont::ArrayHandle<vtkm::Vec3f>& validity,
const std::string& msg) const std::string& msg)
{ {
@ -119,13 +119,13 @@ vtkm::Vec3f RandomPt(const vtkm::Bounds& bounds)
void GeneratePoints(const vtkm::Id numOfEntries, void GeneratePoints(const vtkm::Id numOfEntries,
const vtkm::Bounds& bounds, const vtkm::Bounds& bounds,
vtkm::cont::ArrayHandle<vtkm::Massless>& pointIns) vtkm::cont::ArrayHandle<vtkm::Particle>& pointIns)
{ {
pointIns.Allocate(numOfEntries); pointIns.Allocate(numOfEntries);
auto writePortal = pointIns.WritePortal(); auto writePortal = pointIns.WritePortal();
for (vtkm::Id index = 0; index < numOfEntries; index++) for (vtkm::Id index = 0; index < numOfEntries; index++)
{ {
vtkm::Massless particle(RandomPt(bounds), index); vtkm::Particle particle(RandomPt(bounds), index);
writePortal.Set(index, particle); writePortal.Set(index, particle);
} }
} }
@ -174,7 +174,7 @@ void TestTemporalEvaluators()
// Test data : populate with meaningful values // Test data : populate with meaningful values
vtkm::Id numValues = 10; vtkm::Id numValues = 10;
vtkm::cont::ArrayHandle<vtkm::Massless> pointIns; vtkm::cont::ArrayHandle<vtkm::Particle> pointIns;
vtkm::cont::ArrayHandle<vtkm::Vec3f> validity; vtkm::cont::ArrayHandle<vtkm::Vec3f> validity;
GeneratePoints(numValues, bounds, pointIns); GeneratePoints(numValues, bounds, pointIns);
GenerateValidity(numValues, validity, X, Z); GenerateValidity(numValues, validity, X, Z);