Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +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;
}
class Particle
class ParticleBase
{
public:
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
// troublesome with CUDA __host__ __device__ markup.
}
VTKM_EXEC_CONT
Particle(const vtkm::Vec3f& p,
const vtkm::Id& id,
const vtkm::Id& numSteps = 0,
const vtkm::ParticleStatus& status = vtkm::ParticleStatus(),
const vtkm::FloatDefault& time = 0)
ParticleBase(const vtkm::Vec3f& p,
const vtkm::Id& id,
const vtkm::Id& numSteps = 0,
const vtkm::ParticleStatus& status = vtkm::ParticleStatus(),
const vtkm::FloatDefault& time = 0)
: Pos(p)
, ID(id)
, NumSteps(numSteps)
@ -92,7 +92,7 @@ public:
}
VTKM_EXEC_CONT
Particle(const vtkm::Particle& p)
ParticleBase(const vtkm::ParticleBase& p)
: Pos(p.Pos)
, ID(p.ID)
, 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
// field. In that case it is safe to assume that the velocity value
@ -123,13 +123,13 @@ public:
vtkm::FloatDefault Time = 0;
};
class Massless : public vtkm::Particle
class Particle : public vtkm::ParticleBase
{
public:
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
// troublesome with CUDA __host__ __device__ markup.
@ -137,21 +137,15 @@ public:
VTKM_EXEC_CONT
Massless(const vtkm::Vec3f& p,
Particle(const vtkm::Vec3f& p,
const vtkm::Id& id,
const vtkm::Id& numSteps = 0,
const vtkm::ParticleStatus& status = vtkm::ParticleStatus(),
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::Vec3f Next(const vtkm::VecVariable<vtkm::Vec3f, 2>& vectors,
const vtkm::FloatDefault& length) override
@ -171,7 +165,7 @@ public:
}
};
class Electron : public vtkm::Particle
class Electron : public vtkm::ParticleBase
{
public:
VTKM_EXEC_CONT
@ -187,7 +181,7 @@ public:
const vtkm::Id& numSteps = 0,
const vtkm::ParticleStatus& status = vtkm::ParticleStatus(),
const vtkm::FloatDefault& time = 0)
: Particle(position, id, numSteps, status, time)
: ParticleBase(position, id, numSteps, status, time)
, Mass(mass)
, Charge(charge)
, Weighting(weighting)
@ -255,6 +249,8 @@ private:
vtkm::Vec3f Momentum;
constexpr static vtkm::FloatDefault SPEED_OF_LIGHT =
static_cast<vtkm::FloatDefault>(2.99792458e8);
friend struct mangled_diy_namespace::Serialization<vtkm::Electron>;
};
} //namespace vtkm
@ -263,10 +259,10 @@ private:
namespace mangled_diy_namespace
{
template <>
struct Serialization<vtkm::Massless>
struct Serialization<vtkm::Particle>
{
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.ID);
@ -275,7 +271,7 @@ public:
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.ID);
@ -284,6 +280,37 @@ public:
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

17
vtkm/cont/ParticleArrayCopy.hxx
View File

@ -26,18 +26,21 @@ namespace cont
namespace detail
{
template <typename ParticleType>
struct ExtractPositionFunctor
{
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
{
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
{
using ControlSignature = void(FieldIn inParticle,
@ -47,7 +50,7 @@ struct CopyParticleAllWorklet : public vtkm::worklet::WorkletMapField
FieldOut outStatus,
FieldOut outTime);
VTKM_EXEC void operator()(const vtkm::Particle& inParticle,
VTKM_EXEC void operator()(const ParticleType& inParticle,
vtkm::Vec3f& outPos,
vtkm::Id& outID,
vtkm::Id& outSteps,
@ -71,11 +74,13 @@ VTKM_ALWAYS_EXPORT inline void ParticleArrayCopy(
vtkm::cont::ArrayHandle<vtkm::Vec3f, vtkm::cont::StorageTagBasic>& outPos,
bool CopyTerminatedOnly)
{
auto posTrn = vtkm::cont::make_ArrayHandleTransform(inP, detail::ExtractPositionFunctor());
auto posTrn =
vtkm::cont::make_ArrayHandleTransform(inP, detail::ExtractPositionFunctor<ParticleType>());
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);
}
else
@ -99,7 +104,7 @@ VTKM_ALWAYS_EXPORT inline void ParticleArrayCopy(
vtkm::cont::ArrayHandle<vtkm::FloatDefault, vtkm::cont::StorageTagBasic>& outTime)
{
vtkm::cont::Invoker invoke;
detail::CopyParticleAllWorklet worklet;
detail::CopyParticleAllWorklet<ParticleType> worklet;
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);
std::uniform_real_distribution<vtkm::FloatDefault> dist(x0, x1);
std::vector<vtkm::Massless> particles;
std::vector<vtkm::Particle> particles;
vtkm::Id N = 17;
for (vtkm::Id i = 0; i < N; i++)
{
auto x = dist(generator);
auto y = 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++)
@ -37,7 +37,7 @@ void TestParticleArrayCopy()
if (i == 0)
{
vtkm::cont::ArrayHandle<vtkm::Vec3f> pos;
vtkm::cont::ParticleArrayCopy<vtkm::Massless>(particleAH, pos);
vtkm::cont::ParticleArrayCopy<vtkm::Particle>(particleAH, pos);
auto pPortal = particleAH.ReadPortal();
for (vtkm::Id j = 0; j < N; j++)
@ -54,7 +54,7 @@ void TestParticleArrayCopy()
vtkm::cont::ArrayHandle<vtkm::ParticleStatus> status;
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();
for (vtkm::Id j = 0; j < N; j++)

16
vtkm/filter/Lagrangian.hxx
View File

@ -34,8 +34,8 @@
#include <string.h>
static vtkm::Id cycle = 0;
static vtkm::cont::ArrayHandle<vtkm::Massless> BasisParticles;
static vtkm::cont::ArrayHandle<vtkm::Massless> BasisParticlesOriginal;
static vtkm::cont::ArrayHandle<vtkm::Particle> BasisParticles;
static vtkm::cont::ArrayHandle<vtkm::Particle> BasisParticlesOriginal;
static vtkm::cont::ArrayHandle<vtkm::Id> BasisParticlesValidity;
namespace
@ -53,7 +53,7 @@ public:
}
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;
if (steps > 0 && res == 1)
@ -85,8 +85,8 @@ public:
using InputDomain = _1;
template <typename DisplacementType>
VTKM_EXEC void operator()(const vtkm::Massless& end_point,
const vtkm::Massless& start_point,
VTKM_EXEC void operator()(const vtkm::Particle& end_point,
const vtkm::Particle& start_point,
DisplacementType& res) const
{
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);
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.Z.Min) + zi),
id));
@ -266,7 +266,7 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
throw vtkm::cont::ErrorFilterExecution(
"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);
cycle += 1;
@ -280,7 +280,7 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
using GridEvalType = vtkm::worklet::particleadvection::GridEvaluator<FieldType>;
using RK4Type = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
vtkm::worklet::ParticleAdvection particleadvection;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> res;
vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
FieldType velocities(field);
GridEvalType gridEval(coords, cells, velocities);

8
vtkm/filter/LagrangianStructures.hxx
View File

@ -36,7 +36,7 @@ public:
using ExecutionSignature = void(_1, _2);
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;
}
@ -51,7 +51,7 @@ public:
VTKM_EXEC void operator()(const vtkm::Id index,
const vtkm::Vec3f& seed,
vtkm::Massless& particle) const
vtkm::Particle& particle) const
{
particle.ID = index;
particle.Pos = seed;
@ -140,8 +140,8 @@ inline VTKM_CONT vtkm::cont::DataSet LagrangianStructures::DoExecute(
GridEvaluator evaluator(input.GetCoordinateSystem(), input.GetCellSet(), velocities);
Integrator integrator(evaluator, stepSize);
vtkm::worklet::ParticleAdvection particles;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> advectionResult;
vtkm::cont::ArrayHandle<vtkm::Massless> advectionPoints;
vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> advectionResult;
vtkm::cont::ArrayHandle<vtkm::Particle> advectionPoints;
invoke(detail::MakeParticles{}, lcsInputPoints, advectionPoints);
advectionResult = particles.Run(integrator, advectionPoints, numberOfSteps);
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; }
VTKM_CONT
void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds);
void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds);
template <typename DerivedPolicy>
vtkm::cont::PartitionedDataSet PrepareForExecution(
@ -53,7 +53,7 @@ public:
private:
vtkm::Id NumberOfSteps;
vtkm::FloatDefault StepSize;
vtkm::cont::ArrayHandle<vtkm::Massless> Seeds;
vtkm::cont::ArrayHandle<vtkm::Particle> Seeds;
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;
}

4
vtkm/filter/Pathline.h
View File

@ -47,7 +47,7 @@ public:
void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; }
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>
VTKM_CONT vtkm::cont::DataSet DoExecute(
@ -68,7 +68,7 @@ private:
vtkm::FloatDefault NextTime;
vtkm::cont::DataSet NextDataSet;
vtkm::Id NumberOfSteps;
vtkm::cont::ArrayHandle<vtkm::Massless> Seeds;
vtkm::cont::ArrayHandle<vtkm::Particle> Seeds;
};
}
} // 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;
}
@ -80,9 +80,9 @@ inline VTKM_CONT vtkm::cont::DataSet Pathline::DoExecute(
RK4Type rk4(eval, this->StepSize);
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);
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; }
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>
VTKM_CONT vtkm::cont::DataSet DoExecute(
@ -56,7 +56,7 @@ public:
private:
vtkm::Id NumberOfSteps;
vtkm::cont::ArrayHandle<vtkm::Massless> Seeds;
vtkm::cont::ArrayHandle<vtkm::Particle> Seeds;
vtkm::FloatDefault StepSize;
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::cont::ArrayHandle<vtkm::Massless> seedArray;
vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
vtkm::cont::ArrayCopy(this->Seeds, seedArray);
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; }
VTKM_CONT
void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds);
void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds);
template <typename DerivedPolicy>
vtkm::cont::PartitionedDataSet PrepareForExecution(
@ -52,7 +52,7 @@ public:
private:
vtkm::Id NumberOfSteps;
vtkm::FloatDefault StepSize;
vtkm::cont::ArrayHandle<vtkm::Massless> Seeds;
vtkm::cont::ArrayHandle<vtkm::Particle> Seeds;
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;
}

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

@ -55,7 +55,7 @@ public:
vtkm::Id GetID() const { return this->ID; }
template <typename ResultType>
void Advect(std::vector<vtkm::Massless>& v,
void Advect(std::vector<vtkm::Particle>& v,
vtkm::FloatDefault stepSize,
vtkm::Id maxSteps,
ResultType& result) const
@ -67,7 +67,7 @@ public:
private:
template <typename ResultType>
inline void DoAdvect(vtkm::cont::ArrayHandle<vtkm::Massless>& seeds,
inline void DoAdvect(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
const RK4Type& rk4,
vtkm::Id maxSteps,
ResultType& result) const;
@ -81,10 +81,10 @@ private:
// Specialization for ParticleAdvection worklet
template <>
inline void DataSetIntegrator::DoAdvect(
vtkm::cont::ArrayHandle<vtkm::Massless>& seeds,
vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
const RK4Type& rk4,
vtkm::Id maxSteps,
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless>& result) const
vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>& result) const
{
vtkm::worklet::ParticleAdvection Worklet;
result = Worklet.Run(rk4, seeds, maxSteps);
@ -94,10 +94,10 @@ inline void DataSetIntegrator::DoAdvect(
// Specialization for Streamline worklet
template <>
inline void DataSetIntegrator::DoAdvect(
vtkm::cont::ArrayHandle<vtkm::Massless>& seeds,
vtkm::cont::ArrayHandle<vtkm::Particle>& seeds,
const RK4Type& rk4,
vtkm::Id maxSteps,
vtkm::worklet::StreamlineResult<vtkm::Massless>& result) const
vtkm::worklet::StreamlineResult<vtkm::Particle>& result) const
{
vtkm::worklet::Streamline Worklet;
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 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 vtkm::cont::PartitionedDataSet GetOutput() = 0;
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;
@ -68,9 +68,9 @@ protected:
inline void UpdateResult(const ResultType& res,
vtkm::Id blockId,
std::vector<vtkm::Massless>& I,
std::vector<vtkm::Massless>& T,
std::vector<vtkm::Massless>& A);
std::vector<vtkm::Particle>& I,
std::vector<vtkm::Particle>& T,
std::vector<vtkm::Particle>& A);
std::vector<DataSetIntegratorType> Blocks;
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();
@ -107,7 +107,7 @@ public:
auto portal = seeds.ReadPortal();
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);
if (!blockIDs.empty() && this->BoundsMap.FindRank(blockIDs[0]) == this->Rank)
{
@ -128,7 +128,7 @@ public:
vtkm::Id N = 0;
while (N < totalNumSeeds)
{
std::vector<vtkm::Massless> v, I, T, A;
std::vector<vtkm::Particle> v, I, T, A;
vtkm::Id blockId = -1;
if (GetActiveParticles(v))
@ -144,7 +144,7 @@ public:
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;
vtkm::Id myTerm = static_cast<vtkm::Id>(T.size());
vtkm::Id numTermMessages = 0;
@ -171,7 +171,7 @@ public:
}
protected:
bool GetActiveParticles(std::vector<vtkm::Massless>& particles) override
bool GetActiveParticles(std::vector<vtkm::Particle>& particles) override
{
particles.clear();
if (this->Active.empty())
@ -195,21 +195,21 @@ protected:
}
protected:
std::vector<vtkm::Massless> Active;
std::vector<vtkm::Massless> Inactive;
std::map<vtkm::Id, std::vector<vtkm::Massless>> Terminated;
std::vector<vtkm::Particle> Active;
std::vector<vtkm::Particle> Inactive;
std::map<vtkm::Id, std::vector<vtkm::Particle>> Terminated;
};
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;
public:
ParticleAdvectionAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
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
: public PABaseAlgorithm<vtkm::worklet::StreamlineResult<vtkm::Massless>>
: public PABaseAlgorithm<vtkm::worklet::StreamlineResult<vtkm::Particle>>
{
using DataSetIntegratorType = vtkm::filter::particleadvection::DataSetIntegrator;
public:
StreamlineAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm,
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:
virtual void StoreResult(const vtkm::worklet::StreamlineResult<vtkm::Massless>& res,
virtual void StoreResult(const vtkm::worklet::StreamlineResult<vtkm::Particle>& res,
vtkm::Id blockId) override
{
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>
inline void ParticleAdvectorBase<ResultType>::UpdateResult(const ResultType& res,
vtkm::Id blockId,
std::vector<vtkm::Massless>& I,
std::vector<vtkm::Massless>& T,
std::vector<vtkm::Massless>& A)
std::vector<vtkm::Particle>& I,
std::vector<vtkm::Particle>& T,
std::vector<vtkm::Particle>& A)
{
vtkm::Id n = res.Particles.GetNumberOfValues();
auto portal = res.Particles.ReadPortal();
for (vtkm::Id i = 0; i < n; i++)
{
vtkm::Massless p = portal.Get(i);
vtkm::Particle p = portal.Get(i);
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
// rank
sizeof(int)
//std::vector<vtkm::Massless> p;
//std::vector<vtkm::Particle> p;
//p.size()
+ sizeof(std::size_t)
//nParticles of vtkm::Massless
//nParticles of vtkm::Particle
+ nParticles * pSize
// std::vector<vtkm::Id> blockIDs for each particle.
// blockIDs.size() for each particle
@ -68,10 +68,10 @@ std::size_t ParticleMessenger::CalcParticleBufferSize(std::size_t nParticles, st
VTKM_CONT
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,
vtkm::Id vtkmNotUsed(numLocalTerm),
std::vector<vtkm::Massless>& inData,
std::vector<vtkm::Particle>& inData,
std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap) const
{
for (auto& p : outData)
@ -83,10 +83,10 @@ void ParticleMessenger::SerialExchange(
}
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,
vtkm::Id numLocalTerm,
std::vector<vtkm::Massless>& inData,
std::vector<vtkm::Particle>& inData,
std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
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>>;
//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.
using ParticleRecvCommType = std::pair<int, std::vector<ParticleCommType>>;
@ -49,10 +49,10 @@ public:
int numBlockIds = 2);
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,
vtkm::Id numLocalTerm,
std::vector<vtkm::Massless>& inData,
std::vector<vtkm::Particle>& inData,
std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap,
vtkm::Id& numTerminateMessages);
@ -96,10 +96,10 @@ protected:
#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,
vtkm::Id numLocalTerm,
std::vector<vtkm::Massless>& inData,
std::vector<vtkm::Particle>& inData,
std::map<vtkm::Id, std::vector<vtkm::Id>>& inDataBlockIDsMap) const;
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::Vec3f origin(0, 0, 0), spacing(1, 1, 1), vecX(1, 0, 0);
vtkm::cont::DataSet ds = CreateDataSet(dims, origin, spacing, vecX);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2),
vtkm::Massless(vtkm::Vec3f(.2f, 3.2f, .2f), 3) });
vtkm::cont::ArrayHandle<vtkm::Particle> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2),
vtkm::Particle(vtkm::Vec3f(.2f, 3.2f, .2f), 3) });
vtkm::filter::ParticleAdvection particleAdvection;
@ -79,11 +79,11 @@ void TestPartitionedDataSet()
pds.AppendPartition(CreateDataSet(dims, o2, spacing, vecX));
pds.AppendPartition(CreateDataSet(dims, o3, spacing, vecX));
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(4.2f, 1.0f, .2f), 2),
vtkm::Massless(vtkm::Vec3f(8.2f, 1.0f, .2f), 3) });
vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Particle(vtkm::Vec3f(4.2f, 1.0f, .2f), 2),
vtkm::Particle(vtkm::Vec3f(8.2f, 1.0f, .2f), 3) });
vtkm::Id numSeeds = seedArray.GetNumberOfValues();
@ -145,9 +145,9 @@ void TestFile(const std::string& fname,
}
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++)
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);
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));
}
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1) });
vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1) });
vtkm::Id numSeeds = seedArray.GetNumberOfValues();

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

@ -18,9 +18,9 @@
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 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>>;
class TestMessenger : public vtkm::filter::particleadvection::ParticleMessenger
@ -46,7 +46,7 @@ public:
}
void SendP(int dst,
const std::vector<vtkm::Massless>& p,
const std::vector<vtkm::Particle>& p,
const std::vector<std::vector<vtkm::Id>>& bids)
{
std::vector<PCommType> data;
@ -71,7 +71,7 @@ public:
void ValidateReceivedParticles(
int sendRank,
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)
{
//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);
//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<int>> messages(comm.size());
@ -148,11 +148,11 @@ void TestParticleMessenger()
for (std::size_t r = 0; r < numRanks; r++)
{
int nP = nPDist(generator);
std::vector<vtkm::Massless> pvec;
std::vector<vtkm::Particle> pvec;
std::vector<std::vector<vtkm::Id>> blockIds;
for (int p = 0; p < nP; p++)
{
vtkm::Massless particle;
vtkm::Particle particle;
particle.Pos[0] = floatDist(generator);
particle.Pos[1] = floatDist(generator);
particle.Pos[2] = floatDist(generator);
@ -190,7 +190,7 @@ void TestParticleMessenger()
int dst = rankDist(generator);
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];
messenger.SendP(dst, sendP, sendIds);
}
@ -271,7 +271,7 @@ void TestBufferSizes()
std::vector<PCommType> particleData;
for (int i = 0; i < numP; i++)
{
vtkm::Massless p;
vtkm::Particle p;
std::vector<vtkm::Id> bids(nBids, 0);
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);
vtkm::cont::DataSet ds = CreateDataSet(dims, vecX);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.1f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.1f, 2.0f, .1f), 1),
vtkm::Massless(vtkm::Vec3f(.1f, 3.0f, .3f), 2),
vtkm::Massless(vtkm::Vec3f(.1f, 3.5f, .2f), 3) });
vtkm::cont::ArrayHandle<vtkm::Particle> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.1f, 1.0f, .2f), 0),
vtkm::Particle(vtkm::Vec3f(.1f, 2.0f, .1f), 1),
vtkm::Particle(vtkm::Vec3f(.1f, 3.0f, .3f), 2),
vtkm::Particle(vtkm::Vec3f(.1f, 3.5f, .2f), 3) });
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);
vtkm::cont::DataSet ds = CreateDataSet(dims, vecX);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
vtkm::cont::ArrayHandle<vtkm::Particle> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
vtkm::filter::Streamline streamline;
@ -72,10 +72,10 @@ void TestPathline()
vtkm::cont::DataSet ds1 = CreateDataSet(dims, vecX);
vtkm::cont::DataSet ds2 = CreateDataSet(dims, vecY);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
vtkm::cont::ArrayHandle<vtkm::Particle> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Particle(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
vtkm::filter::Pathline pathline;
@ -120,9 +120,9 @@ void TestStreamlineFile(const std::string& fname,
}
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++)
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);
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));
}
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1) });
vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1) });
vtkm::Id numSeeds = seedArray.GetNumberOfValues();
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 vtkm::Bounds& bounds,
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[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());
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);
template <typename EvaluatorType>
VTKM_EXEC void operator()(vtkm::Massless& pointIn,
VTKM_EXEC void operator()(vtkm::Particle& pointIn,
const EvaluatorType& evaluator,
vtkm::worklet::particleadvection::GridEvaluatorStatus& status,
vtkm::Vec3f& pointOut) const
@ -308,7 +308,7 @@ public:
template <typename EvalType>
void ValidateEvaluator(const EvalType& eval,
const std::vector<vtkm::Massless>& pointIns,
const std::vector<vtkm::Particle>& pointIns,
const vtkm::Vec3f& vec,
const std::string& msg)
{
@ -317,7 +317,7 @@ void ValidateEvaluator(const EvalType& eval,
using Status = vtkm::worklet::particleadvection::GridEvaluatorStatus;
EvalTester 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::Id numPoints = pointsHandle.GetNumberOfValues();
vtkm::cont::ArrayHandle<Status> evalStatus;
@ -345,7 +345,7 @@ public:
using ExecutionSignature = void(_1, _2, _3, _4);
template <typename IntegratorType>
VTKM_EXEC void operator()(vtkm::Massless& pointIn,
VTKM_EXEC void operator()(vtkm::Particle& pointIn,
const IntegratorType* integrator,
vtkm::worklet::particleadvection::IntegratorStatus& status,
vtkm::Vec3f& pointOut) const
@ -360,7 +360,7 @@ public:
template <typename IntegratorType>
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::string& msg)
{
@ -393,7 +393,7 @@ void ValidateIntegrator(const IntegratorType& integrator,
template <typename IntegratorType>
void ValidateIntegratorForBoundary(const vtkm::Bounds& bounds,
const IntegratorType& integrator,
const std::vector<vtkm::Massless>& pointIns,
const std::vector<vtkm::Particle>& pointIns,
const std::string& msg)
{
using IntegratorTester = TestIntegratorWorklet;
@ -462,7 +462,7 @@ void TestEvaluators()
//vtkm::FloatDefault stepSize = 0.01f;
vtkm::FloatDefault stepSize = 0.1f;
std::vector<vtkm::Massless> pointIns;
std::vector<vtkm::Particle> pointIns;
std::vector<vtkm::Vec3f> stepResult;
//Generate points 2 steps inside the bounding box.
@ -499,7 +499,7 @@ void TestEvaluators()
// of the velocity field
// All velocities are in the +ve direction.
std::vector<vtkm::Massless> boundaryPoints;
std::vector<vtkm::Particle> boundaryPoints;
GenerateRandomParticles(boundaryPoints, 10, forBoundary, 919);
for (auto& ds : dataSets)
@ -517,7 +517,7 @@ void TestEvaluators()
}
void ValidateParticleAdvectionResult(
const vtkm::worklet::ParticleAdvectionResult<vtkm::Massless>& res,
const vtkm::worklet::ParticleAdvectionResult<vtkm::Particle>& res,
vtkm::Id nSeeds,
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 maxSteps)
{
@ -577,11 +577,11 @@ void TestIntegrators()
GridEvalType eval(dataset.GetCoordinateSystem(), dataset.GetCellSet(), velocities);
//Generate three random points.
std::vector<vtkm::Massless> points;
std::vector<vtkm::Particle> points;
GenerateRandomParticles(points, 3, bounds);
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);
using IntegratorType = vtkm::worklet::particleadvection::RK4Integrator<GridEvalType>;
@ -640,9 +640,9 @@ void TestParticleWorkletsWithDataSetTypes()
dataSets.push_back(CreateWeirdnessFromStructuredDataSet(dataSets[0], DataSetOption::EXPLICIT));
//Generate three random points.
std::vector<vtkm::Massless> pts;
std::vector<vtkm::Particle> pts;
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());
std::vector<vtkm::Id> stepsTaken = { 10, 20, 600 };
@ -662,7 +662,7 @@ void TestParticleWorkletsWithDataSetTypes()
if (i < 2)
{
vtkm::worklet::ParticleAdvection pa;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> res;
vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
if (i == 0)
{
auto seeds = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On);
@ -678,7 +678,7 @@ void TestParticleWorkletsWithDataSetTypes()
else
{
vtkm::worklet::Streamline s;
vtkm::worklet::StreamlineResult<vtkm::Massless> res;
vtkm::worklet::StreamlineResult<vtkm::Particle> res;
if (i == 2)
{
auto seeds = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On);
@ -723,9 +723,9 @@ void TestParticleStatus()
RK4Type rk4(eval, stepSize);
vtkm::worklet::ParticleAdvection pa;
std::vector<vtkm::Massless> pts;
pts.push_back(vtkm::Massless(vtkm::Vec3f(.5, .5, .5), 0));
pts.push_back(vtkm::Massless(vtkm::Vec3f(-1, -1, -1), 1));
std::vector<vtkm::Particle> pts;
pts.push_back(vtkm::Particle(vtkm::Vec3f(.5, .5, .5), 0));
pts.push_back(vtkm::Particle(vtkm::Vec3f(-1, -1, -1), 1));
auto seedsArray = vtkm::cont::make_ArrayHandle(pts, vtkm::CopyFlag::On);
pa.Run(rk4, seedsArray, maxSteps);
auto portal = seedsArray.ReadPortal();
@ -768,7 +768,7 @@ void TestWorkletsBasic()
for (auto w : workletTypes)
{
std::vector<vtkm::Massless> particles;
std::vector<vtkm::Particle> particles;
std::vector<vtkm::Vec3f> pts, samplePts, endPts;
vtkm::FloatDefault X = 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++)
{
vtkm::Vec3f p = pts[i];
particles.push_back(vtkm::Massless(p, id));
particles.push_back(vtkm::Particle(p, id));
samplePts.push_back(p);
for (vtkm::Id j = 0; j < maxSteps; j++)
{
@ -799,7 +799,7 @@ void TestWorkletsBasic()
if (w == "particleAdvection")
{
vtkm::worklet::ParticleAdvection pa;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> res;
vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
res = pa.Run(rk4, seedsArray, maxSteps);
@ -823,7 +823,7 @@ void TestWorkletsBasic()
else if (w == "streamline")
{
vtkm::worklet::Streamline s;
vtkm::worklet::StreamlineResult<vtkm::Massless> res;
vtkm::worklet::StreamlineResult<vtkm::Particle> res;
res = s.Run(rk4, seedsArray, maxSteps);
@ -940,15 +940,15 @@ void TestParticleAdvectionFile(const std::string& fname,
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++)
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);
if (i == 0)
{
vtkm::worklet::ParticleAdvection pa;
vtkm::worklet::ParticleAdvectionResult<vtkm::Massless> res;
vtkm::worklet::ParticleAdvectionResult<vtkm::Particle> res;
res = pa.Run(rk4, seedArray, maxSteps);
ValidateResult(res, maxSteps, endPts);
@ -956,7 +956,7 @@ void TestParticleAdvectionFile(const std::string& fname,
else if (i == 1)
{
vtkm::worklet::Streamline s;
vtkm::worklet::StreamlineResult<vtkm::Massless> res;
vtkm::worklet::StreamlineResult<vtkm::Particle> res;
res = s.Run(rk4, seedArray, maxSteps);
ValidateResult(res, maxSteps, endPts);

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

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