From 855e973a2062f75d7f764e654ad54a97412d331f Mon Sep 17 00:00:00 2001 From: Dave Pugmire Date: Wed, 26 Aug 2020 08:59:51 -0400 Subject: [PATCH] Rename the Particle classes. --- vtkm/Particle.h | 79 +++++++++++++------ vtkm/cont/ParticleArrayCopy.hxx | 17 ++-- .../testing/UnitTestParticleArrayCopy.cxx | 8 +- vtkm/filter/Lagrangian.hxx | 16 ++-- vtkm/filter/LagrangianStructures.hxx | 8 +- vtkm/filter/ParticleAdvection.h | 4 +- vtkm/filter/ParticleAdvection.hxx | 2 +- vtkm/filter/Pathline.h | 4 +- vtkm/filter/Pathline.hxx | 6 +- vtkm/filter/StreamSurface.h | 4 +- vtkm/filter/StreamSurface.hxx | 2 +- vtkm/filter/Streamline.h | 4 +- vtkm/filter/Streamline.hxx | 2 +- .../particleadvection/DataSetIntegrator.h | 12 +-- .../particleadvection/ParticleAdvector.h | 38 ++++----- .../particleadvection/ParticleAdvector.hxx | 8 +- .../particleadvection/ParticleMessenger.cxx | 12 +-- .../particleadvection/ParticleMessenger.h | 10 +-- .../UnitTestParticleAdvectionFilter.cxx | 24 +++--- .../UnitTestParticleAdvectionFilterMPI.cxx | 6 +- .../testing/UnitTestParticleMessengerMPI.cxx | 18 ++--- .../testing/UnitTestStreamSurfaceFilter.cxx | 10 +-- .../testing/UnitTestStreamlineFilter.cxx | 20 ++--- .../testing/UnitTestStreamlineFilterMPI.cxx | 6 +- .../testing/UnitTestParticleAdvection.cxx | 58 +++++++------- .../testing/UnitTestTemporalAdvection.cxx | 10 +-- 26 files changed, 210 insertions(+), 178 deletions(-) diff --git a/vtkm/Particle.h b/vtkm/Particle.h index 6930e85ed..5107c79a9 100644 --- a/vtkm/Particle.h +++ b/vtkm/Particle.h @@ -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& 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(2.99792458e8); + + friend struct mangled_diy_namespace::Serialization; }; } //namespace vtkm @@ -263,10 +259,10 @@ private: namespace mangled_diy_namespace { template <> -struct Serialization +struct Serialization { 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 +{ +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 diff --git a/vtkm/cont/ParticleArrayCopy.hxx b/vtkm/cont/ParticleArrayCopy.hxx index ee6734a39..59ccd15d8 100644 --- a/vtkm/cont/ParticleArrayCopy.hxx +++ b/vtkm/cont/ParticleArrayCopy.hxx @@ -26,18 +26,21 @@ namespace cont namespace detail { +template 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 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 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& outPos, bool CopyTerminatedOnly) { - auto posTrn = vtkm::cont::make_ArrayHandleTransform(inP, detail::ExtractPositionFunctor()); + auto posTrn = + vtkm::cont::make_ArrayHandleTransform(inP, detail::ExtractPositionFunctor()); if (CopyTerminatedOnly) { - auto termTrn = vtkm::cont::make_ArrayHandleTransform(inP, detail::ExtractTerminatedFunctor()); + auto termTrn = + vtkm::cont::make_ArrayHandleTransform(inP, detail::ExtractTerminatedFunctor()); vtkm::cont::Algorithm::CopyIf(posTrn, termTrn, outPos); } else @@ -99,7 +104,7 @@ VTKM_ALWAYS_EXPORT inline void ParticleArrayCopy( vtkm::cont::ArrayHandle& outTime) { vtkm::cont::Invoker invoke; - detail::CopyParticleAllWorklet worklet; + detail::CopyParticleAllWorklet worklet; invoke(worklet, inP, outPos, outID, outSteps, outStatus, outTime); } diff --git a/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx b/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx index 90859e50a..14200cf14 100644 --- a/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx +++ b/vtkm/cont/testing/UnitTestParticleArrayCopy.cxx @@ -19,14 +19,14 @@ void TestParticleArrayCopy() vtkm::FloatDefault x0(-1), x1(1); std::uniform_real_distribution dist(x0, x1); - std::vector particles; + std::vector 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 pos; - vtkm::cont::ParticleArrayCopy(particleAH, pos); + vtkm::cont::ParticleArrayCopy(particleAH, pos); auto pPortal = particleAH.ReadPortal(); for (vtkm::Id j = 0; j < N; j++) @@ -54,7 +54,7 @@ void TestParticleArrayCopy() vtkm::cont::ArrayHandle status; vtkm::cont::ArrayHandle ptime; - vtkm::cont::ParticleArrayCopy(particleAH, pos, ids, steps, status, ptime); + vtkm::cont::ParticleArrayCopy(particleAH, pos, ids, steps, status, ptime); auto pPortal = particleAH.ReadPortal(); for (vtkm::Id j = 0; j < N; j++) diff --git a/vtkm/filter/Lagrangian.hxx b/vtkm/filter/Lagrangian.hxx index 2f2d66dd7..8d464a84a 100644 --- a/vtkm/filter/Lagrangian.hxx +++ b/vtkm/filter/Lagrangian.hxx @@ -34,8 +34,8 @@ #include static vtkm::Id cycle = 0; -static vtkm::cont::ArrayHandle BasisParticles; -static vtkm::cont::ArrayHandle BasisParticlesOriginal; +static vtkm::cont::ArrayHandle BasisParticles; +static vtkm::cont::ArrayHandle BasisParticlesOriginal; static vtkm::cont::ArrayHandle BasisParticlesValidity; namespace @@ -53,7 +53,7 @@ public: } template - 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 - 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(x * x_spacing); portal1.Set(id, - vtkm::Massless(Vec3f(static_cast(bounds.X.Min) + xi, + vtkm::Particle(Vec3f(static_cast(bounds.X.Min) + xi, static_cast(bounds.Y.Min) + yi, static_cast(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 basisParticleArray; + vtkm::cont::ArrayHandle 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; using RK4Type = vtkm::worklet::particleadvection::RK4Integrator; vtkm::worklet::ParticleAdvection particleadvection; - vtkm::worklet::ParticleAdvectionResult res; + vtkm::worklet::ParticleAdvectionResult res; FieldType velocities(field); GridEvalType gridEval(coords, cells, velocities); diff --git a/vtkm/filter/LagrangianStructures.hxx b/vtkm/filter/LagrangianStructures.hxx index 6519e84e9..80b234552 100644 --- a/vtkm/filter/LagrangianStructures.hxx +++ b/vtkm/filter/LagrangianStructures.hxx @@ -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 advectionResult; - vtkm::cont::ArrayHandle advectionPoints; + vtkm::worklet::ParticleAdvectionResult advectionResult; + vtkm::cont::ArrayHandle advectionPoints; invoke(detail::MakeParticles{}, lcsInputPoints, advectionPoints); advectionResult = particles.Run(integrator, advectionPoints, numberOfSteps); invoke(detail::ExtractParticlePosition{}, advectionResult.Particles, lcsOutputPoints); diff --git a/vtkm/filter/ParticleAdvection.h b/vtkm/filter/ParticleAdvection.h index e6ac5a277..d1a2da271 100644 --- a/vtkm/filter/ParticleAdvection.h +++ b/vtkm/filter/ParticleAdvection.h @@ -38,7 +38,7 @@ public: void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; } VTKM_CONT - void SetSeeds(vtkm::cont::ArrayHandle& seeds); + void SetSeeds(vtkm::cont::ArrayHandle& seeds); template vtkm::cont::PartitionedDataSet PrepareForExecution( @@ -53,7 +53,7 @@ public: private: vtkm::Id NumberOfSteps; vtkm::FloatDefault StepSize; - vtkm::cont::ArrayHandle Seeds; + vtkm::cont::ArrayHandle Seeds; vtkm::worklet::ParticleAdvection Worklet; }; } diff --git a/vtkm/filter/ParticleAdvection.hxx b/vtkm/filter/ParticleAdvection.hxx index 56902ba4f..7f429f9ee 100644 --- a/vtkm/filter/ParticleAdvection.hxx +++ b/vtkm/filter/ParticleAdvection.hxx @@ -34,7 +34,7 @@ inline VTKM_CONT ParticleAdvection::ParticleAdvection() } //----------------------------------------------------------------------------- -inline VTKM_CONT void ParticleAdvection::SetSeeds(vtkm::cont::ArrayHandle& seeds) +inline VTKM_CONT void ParticleAdvection::SetSeeds(vtkm::cont::ArrayHandle& seeds) { this->Seeds = seeds; } diff --git a/vtkm/filter/Pathline.h b/vtkm/filter/Pathline.h index 11bb4276d..d8448db44 100644 --- a/vtkm/filter/Pathline.h +++ b/vtkm/filter/Pathline.h @@ -47,7 +47,7 @@ public: void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; } VTKM_CONT - void SetSeeds(vtkm::cont::ArrayHandle& seeds); + void SetSeeds(vtkm::cont::ArrayHandle& seeds); template VTKM_CONT vtkm::cont::DataSet DoExecute( @@ -68,7 +68,7 @@ private: vtkm::FloatDefault NextTime; vtkm::cont::DataSet NextDataSet; vtkm::Id NumberOfSteps; - vtkm::cont::ArrayHandle Seeds; + vtkm::cont::ArrayHandle Seeds; }; } } // namespace vtkm::filter diff --git a/vtkm/filter/Pathline.hxx b/vtkm/filter/Pathline.hxx index f8a5c63c4..25169ee14 100644 --- a/vtkm/filter/Pathline.hxx +++ b/vtkm/filter/Pathline.hxx @@ -34,7 +34,7 @@ inline VTKM_CONT Pathline::Pathline() } //----------------------------------------------------------------------------- -inline VTKM_CONT void Pathline::SetSeeds(vtkm::cont::ArrayHandle& seeds) +inline VTKM_CONT void Pathline::SetSeeds(vtkm::cont::ArrayHandle& 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 res; + vtkm::worklet::StreamlineResult res; - vtkm::cont::ArrayHandle seedArray; + vtkm::cont::ArrayHandle seedArray; vtkm::cont::ArrayCopy(this->Seeds, seedArray); res = Worklet.Run(rk4, seedArray, this->NumberOfSteps); diff --git a/vtkm/filter/StreamSurface.h b/vtkm/filter/StreamSurface.h index 2a0babac1..3c9b8ccf0 100644 --- a/vtkm/filter/StreamSurface.h +++ b/vtkm/filter/StreamSurface.h @@ -40,7 +40,7 @@ public: void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; } VTKM_CONT - void SetSeeds(vtkm::cont::ArrayHandle& seeds) { this->Seeds = seeds; } + void SetSeeds(vtkm::cont::ArrayHandle& seeds) { this->Seeds = seeds; } template VTKM_CONT vtkm::cont::DataSet DoExecute( @@ -56,7 +56,7 @@ public: private: vtkm::Id NumberOfSteps; - vtkm::cont::ArrayHandle Seeds; + vtkm::cont::ArrayHandle Seeds; vtkm::FloatDefault StepSize; vtkm::worklet::StreamSurface Worklet; }; diff --git a/vtkm/filter/StreamSurface.hxx b/vtkm/filter/StreamSurface.hxx index 6bf98467e..75f4e8ac4 100644 --- a/vtkm/filter/StreamSurface.hxx +++ b/vtkm/filter/StreamSurface.hxx @@ -65,7 +65,7 @@ inline VTKM_CONT vtkm::cont::DataSet StreamSurface::DoExecute( vtkm::worklet::Streamline streamline; - vtkm::cont::ArrayHandle seedArray; + vtkm::cont::ArrayHandle seedArray; vtkm::cont::ArrayCopy(this->Seeds, seedArray); auto res = streamline.Run(rk4, seedArray, this->NumberOfSteps); diff --git a/vtkm/filter/Streamline.h b/vtkm/filter/Streamline.h index e788c06bb..08ec80520 100644 --- a/vtkm/filter/Streamline.h +++ b/vtkm/filter/Streamline.h @@ -37,7 +37,7 @@ public: void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; } VTKM_CONT - void SetSeeds(vtkm::cont::ArrayHandle& seeds); + void SetSeeds(vtkm::cont::ArrayHandle& seeds); template vtkm::cont::PartitionedDataSet PrepareForExecution( @@ -52,7 +52,7 @@ public: private: vtkm::Id NumberOfSteps; vtkm::FloatDefault StepSize; - vtkm::cont::ArrayHandle Seeds; + vtkm::cont::ArrayHandle Seeds; vtkm::worklet::Streamline Worklet; }; } diff --git a/vtkm/filter/Streamline.hxx b/vtkm/filter/Streamline.hxx index 9eb57eb82..03f37ef3a 100644 --- a/vtkm/filter/Streamline.hxx +++ b/vtkm/filter/Streamline.hxx @@ -34,7 +34,7 @@ inline VTKM_CONT Streamline::Streamline() } //----------------------------------------------------------------------------- -inline VTKM_CONT void Streamline::SetSeeds(vtkm::cont::ArrayHandle& seeds) +inline VTKM_CONT void Streamline::SetSeeds(vtkm::cont::ArrayHandle& seeds) { this->Seeds = seeds; } diff --git a/vtkm/filter/particleadvection/DataSetIntegrator.h b/vtkm/filter/particleadvection/DataSetIntegrator.h index 80b3f4aca..d92ca82ce 100644 --- a/vtkm/filter/particleadvection/DataSetIntegrator.h +++ b/vtkm/filter/particleadvection/DataSetIntegrator.h @@ -55,7 +55,7 @@ public: vtkm::Id GetID() const { return this->ID; } template - void Advect(std::vector& v, + void Advect(std::vector& v, vtkm::FloatDefault stepSize, vtkm::Id maxSteps, ResultType& result) const @@ -67,7 +67,7 @@ public: private: template - inline void DoAdvect(vtkm::cont::ArrayHandle& seeds, + inline void DoAdvect(vtkm::cont::ArrayHandle& 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& seeds, + vtkm::cont::ArrayHandle& seeds, const RK4Type& rk4, vtkm::Id maxSteps, - vtkm::worklet::ParticleAdvectionResult& result) const + vtkm::worklet::ParticleAdvectionResult& 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& seeds, + vtkm::cont::ArrayHandle& seeds, const RK4Type& rk4, vtkm::Id maxSteps, - vtkm::worklet::StreamlineResult& result) const + vtkm::worklet::StreamlineResult& result) const { vtkm::worklet::Streamline Worklet; result = Worklet.Run(rk4, seeds, maxSteps); diff --git a/vtkm/filter/particleadvection/ParticleAdvector.h b/vtkm/filter/particleadvection/ParticleAdvector.h index a240cd9e9..bc10a413e 100644 --- a/vtkm/filter/particleadvection/ParticleAdvector.h +++ b/vtkm/filter/particleadvection/ParticleAdvector.h @@ -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& seeds) = 0; + virtual void SetSeeds(const vtkm::cont::ArrayHandle& seeds) = 0; virtual void Go() = 0; virtual vtkm::cont::PartitionedDataSet GetOutput() = 0; protected: - virtual bool GetActiveParticles(std::vector& particles) = 0; + virtual bool GetActiveParticles(std::vector& 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& I, - std::vector& T, - std::vector& A); + std::vector& I, + std::vector& T, + std::vector& A); std::vector Blocks; vtkm::filter::particleadvection::BoundsMap BoundsMap; @@ -99,7 +99,7 @@ public: { } - void SetSeeds(const vtkm::cont::ArrayHandle& seeds) override + void SetSeeds(const vtkm::cont::ArrayHandle& 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 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 v, I, T, A; + std::vector 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 incoming; + std::vector incoming; std::map> incomingBlockIDsMap; vtkm::Id myTerm = static_cast(T.size()); vtkm::Id numTermMessages = 0; @@ -171,7 +171,7 @@ public: } protected: - bool GetActiveParticles(std::vector& particles) override + bool GetActiveParticles(std::vector& particles) override { particles.clear(); if (this->Active.empty()) @@ -195,21 +195,21 @@ protected: } protected: - std::vector Active; - std::vector Inactive; - std::map> Terminated; + std::vector Active; + std::vector Inactive; + std::map> Terminated; }; class VTKM_ALWAYS_EXPORT ParticleAdvectionAlgorithm - : public PABaseAlgorithm> + : public PABaseAlgorithm> { using DataSetIntegratorType = vtkm::filter::particleadvection::DataSetIntegrator; public: ParticleAdvectionAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm, const std::vector& blocks) - : PABaseAlgorithm>(bm, blocks) + : PABaseAlgorithm>(bm, blocks) { } @@ -251,14 +251,14 @@ protected: class VTKM_ALWAYS_EXPORT StreamlineAlgorithm - : public PABaseAlgorithm> + : public PABaseAlgorithm> { using DataSetIntegratorType = vtkm::filter::particleadvection::DataSetIntegrator; public: StreamlineAlgorithm(const vtkm::filter::particleadvection::BoundsMap& bm, const std::vector& blocks) - : PABaseAlgorithm>(bm, blocks) + : PABaseAlgorithm>(bm, blocks) { } @@ -350,13 +350,13 @@ public: } protected: - virtual void StoreResult(const vtkm::worklet::StreamlineResult& res, + virtual void StoreResult(const vtkm::worklet::StreamlineResult& res, vtkm::Id blockId) override { this->Results[blockId].push_back(res); } - std::map>> Results; + std::map>> Results; }; } } diff --git a/vtkm/filter/particleadvection/ParticleAdvector.hxx b/vtkm/filter/particleadvection/ParticleAdvector.hxx index 863dda3b1..9e5b828ec 100644 --- a/vtkm/filter/particleadvection/ParticleAdvector.hxx +++ b/vtkm/filter/particleadvection/ParticleAdvector.hxx @@ -42,16 +42,16 @@ ParticleAdvectorBase::GetDataSet(vtkm::Id id) const template inline void ParticleAdvectorBase::UpdateResult(const ResultType& res, vtkm::Id blockId, - std::vector& I, - std::vector& T, - std::vector& A) + std::vector& I, + std::vector& T, + std::vector& 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()) { diff --git a/vtkm/filter/particleadvection/ParticleMessenger.cxx b/vtkm/filter/particleadvection/ParticleMessenger.cxx index 13586b7e0..ddb477b05 100644 --- a/vtkm/filter/particleadvection/ParticleMessenger.cxx +++ b/vtkm/filter/particleadvection/ParticleMessenger.cxx @@ -54,10 +54,10 @@ std::size_t ParticleMessenger::CalcParticleBufferSize(std::size_t nParticles, st return // rank sizeof(int) - //std::vector p; + //std::vector p; //p.size() + sizeof(std::size_t) - //nParticles of vtkm::Massless + //nParticles of vtkm::Particle + nParticles * pSize // std::vector 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& outData, + const std::vector& outData, const std::map>& outBlockIDsMap, vtkm::Id vtkmNotUsed(numLocalTerm), - std::vector& inData, + std::vector& inData, std::map>& inDataBlockIDsMap) const { for (auto& p : outData) @@ -83,10 +83,10 @@ void ParticleMessenger::SerialExchange( } VTKM_CONT -void ParticleMessenger::Exchange(const std::vector& outData, +void ParticleMessenger::Exchange(const std::vector& outData, const std::map>& outBlockIDsMap, vtkm::Id numLocalTerm, - std::vector& inData, + std::vector& inData, std::map>& inDataBlockIDsMap, vtkm::Id& numTerminateMessages) { diff --git a/vtkm/filter/particleadvection/ParticleMessenger.h b/vtkm/filter/particleadvection/ParticleMessenger.h index bd524e9e2..19d2c91ef 100644 --- a/vtkm/filter/particleadvection/ParticleMessenger.h +++ b/vtkm/filter/particleadvection/ParticleMessenger.h @@ -36,7 +36,7 @@ class VTKM_FILTER_EXTRA_EXPORT ParticleMessenger : public vtkm::filter::particle using MsgCommType = std::pair>; //particle + blockIDs. - using ParticleCommType = std::pair>; + using ParticleCommType = std::pair>; //sendRank, vector of ParticleCommType. using ParticleRecvCommType = std::pair>; @@ -49,10 +49,10 @@ public: int numBlockIds = 2); VTKM_CONT ~ParticleMessenger() {} - VTKM_CONT void Exchange(const std::vector& outData, + VTKM_CONT void Exchange(const std::vector& outData, const std::map>& outBlockIDsMap, vtkm::Id numLocalTerm, - std::vector& inData, + std::vector& inData, std::map>& inDataBlockIDsMap, vtkm::Id& numTerminateMessages); @@ -96,10 +96,10 @@ protected: #endif - VTKM_CONT void SerialExchange(const std::vector& outData, + VTKM_CONT void SerialExchange(const std::vector& outData, const std::map>& outBlockIDsMap, vtkm::Id numLocalTerm, - std::vector& inData, + std::vector& inData, std::map>& inDataBlockIDsMap) const; static std::size_t CalcParticleBufferSize(std::size_t nParticles, std::size_t numBlockIds = 2); diff --git a/vtkm/filter/testing/UnitTestParticleAdvectionFilter.cxx b/vtkm/filter/testing/UnitTestParticleAdvectionFilter.cxx index cd20819c9..94068b15d 100644 --- a/vtkm/filter/testing/UnitTestParticleAdvectionFilter.cxx +++ b/vtkm/filter/testing/UnitTestParticleAdvectionFilter.cxx @@ -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 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 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 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 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(pts.size()); - std::vector seeds; + std::vector seeds; for (vtkm::Id i = 0; i < numPoints; i++) - seeds.push_back(vtkm::Massless(pts[static_cast(i)], i)); + seeds.push_back(vtkm::Particle(pts[static_cast(i)], i)); auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::On); vtkm::filter::ParticleAdvection particleAdvection; diff --git a/vtkm/filter/testing/UnitTestParticleAdvectionFilterMPI.cxx b/vtkm/filter/testing/UnitTestParticleAdvectionFilterMPI.cxx index 133713727..924744563 100644 --- a/vtkm/filter/testing/UnitTestParticleAdvectionFilterMPI.cxx +++ b/vtkm/filter/testing/UnitTestParticleAdvectionFilterMPI.cxx @@ -53,9 +53,9 @@ void TestPartitionedDataSet(int nPerRank) pds.AppendPartition(CreateDataSet(dims, origin, spacing, vecX)); } - vtkm::cont::ArrayHandle 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 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(); diff --git a/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx b/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx index f1ba0398a..dca664c08 100644 --- a/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx +++ b/vtkm/filter/testing/UnitTestParticleMessengerMPI.cxx @@ -18,9 +18,9 @@ namespace { -using PCommType = std::pair>; +using PCommType = std::pair>; using MCommType = std::pair>; -using PCommType = std::pair>; +using PCommType = std::pair>; using PRecvCommType = std::pair>; class TestMessenger : public vtkm::filter::particleadvection::ParticleMessenger @@ -46,7 +46,7 @@ public: } void SendP(int dst, - const std::vector& p, + const std::vector& p, const std::vector>& bids) { std::vector data; @@ -71,7 +71,7 @@ public: void ValidateReceivedParticles( int sendRank, const std::vector& recvP, - const std::vector>& particles, + const std::vector>& particles, const std::vector>>& 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> particles(comm.size()); + std::vector> particles(comm.size()); std::vector>> particleBlockIds(comm.size()); std::vector> messages(comm.size()); @@ -148,11 +148,11 @@ void TestParticleMessenger() for (std::size_t r = 0; r < numRanks; r++) { int nP = nPDist(generator); - std::vector pvec; + std::vector pvec; std::vector> 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 sendP = particles[rank]; + std::vector sendP = particles[rank]; std::vector> sendIds = particleBlockIds[rank]; messenger.SendP(dst, sendP, sendIds); } @@ -271,7 +271,7 @@ void TestBufferSizes() std::vector particleData; for (int i = 0; i < numP; i++) { - vtkm::Massless p; + vtkm::Particle p; std::vector bids(nBids, 0); particleData.push_back(std::make_pair(p, bids)); } diff --git a/vtkm/filter/testing/UnitTestStreamSurfaceFilter.cxx b/vtkm/filter/testing/UnitTestStreamSurfaceFilter.cxx index 7ddb68840..eee61fe6e 100644 --- a/vtkm/filter/testing/UnitTestStreamSurfaceFilter.cxx +++ b/vtkm/filter/testing/UnitTestStreamSurfaceFilter.cxx @@ -38,11 +38,11 @@ void TestStreamSurface() const vtkm::Vec3f vecX(1, 0, 0); vtkm::cont::DataSet ds = CreateDataSet(dims, vecX); - vtkm::cont::ArrayHandle 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 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; diff --git a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx index 68043f36d..94c68d01a 100644 --- a/vtkm/filter/testing/UnitTestStreamlineFilter.cxx +++ b/vtkm/filter/testing/UnitTestStreamlineFilter.cxx @@ -38,10 +38,10 @@ void TestStreamline() const vtkm::Vec3f vecX(1, 0, 0); vtkm::cont::DataSet ds = CreateDataSet(dims, vecX); - vtkm::cont::ArrayHandle 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 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 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 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(pts.size()); - std::vector seeds; + std::vector seeds; for (vtkm::Id i = 0; i < numPoints; i++) - seeds.push_back(vtkm::Massless(pts[static_cast(i)], i)); + seeds.push_back(vtkm::Particle(pts[static_cast(i)], i)); auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off); vtkm::filter::Streamline streamline; diff --git a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx index bc0a5cdd1..7255f4295 100644 --- a/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx +++ b/vtkm/filter/testing/UnitTestStreamlineFilterMPI.cxx @@ -54,9 +54,9 @@ void TestPartitionedDataSet(vtkm::Id nPerRank) XPartitionRanges.push_back(vtkm::Range(x, x + 4)); } - vtkm::cont::ArrayHandle 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 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; diff --git a/vtkm/worklet/testing/UnitTestParticleAdvection.cxx b/vtkm/worklet/testing/UnitTestParticleAdvection.cxx index 7112adf77..938b7d0b4 100644 --- a/vtkm/worklet/testing/UnitTestParticleAdvection.cxx +++ b/vtkm/worklet/testing/UnitTestParticleAdvection.cxx @@ -96,7 +96,7 @@ vtkm::FloatDefault vecData[125 * 3] = { }; } -void GenerateRandomParticles(std::vector& points, +void GenerateRandomParticles(std::vector& points, const std::size_t N, const vtkm::Bounds& bounds, const std::size_t seed = 314) @@ -117,7 +117,7 @@ void GenerateRandomParticles(std::vector& points, p[0] = static_cast(bounds.X.Min + rx * bounds.X.Length()); p[1] = static_cast(bounds.Y.Min + ry * bounds.Y.Length()); p[2] = static_cast(bounds.Z.Min + rz * bounds.Z.Length()); - points.push_back(vtkm::Massless(p, static_cast(i))); + points.push_back(vtkm::Particle(p, static_cast(i))); } } @@ -295,7 +295,7 @@ public: using ExecutionSignature = void(_1, _2, _3, _4); template - 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 void ValidateEvaluator(const EvalType& eval, - const std::vector& pointIns, + const std::vector& 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 pointsHandle = + vtkm::cont::ArrayHandle pointsHandle = vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off); vtkm::Id numPoints = pointsHandle.GetNumberOfValues(); vtkm::cont::ArrayHandle evalStatus; @@ -345,7 +345,7 @@ public: using ExecutionSignature = void(_1, _2, _3, _4); template - 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 void ValidateIntegrator(const IntegratorType& integrator, - const std::vector& pointIns, + const std::vector& pointIns, const std::vector& expStepResults, const std::string& msg) { @@ -393,7 +393,7 @@ void ValidateIntegrator(const IntegratorType& integrator, template void ValidateIntegratorForBoundary(const vtkm::Bounds& bounds, const IntegratorType& integrator, - const std::vector& pointIns, + const std::vector& 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 pointIns; + std::vector pointIns; std::vector 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 boundaryPoints; + std::vector boundaryPoints; GenerateRandomParticles(boundaryPoints, 10, forBoundary, 919); for (auto& ds : dataSets) @@ -517,7 +517,7 @@ void TestEvaluators() } void ValidateParticleAdvectionResult( - const vtkm::worklet::ParticleAdvectionResult& res, + const vtkm::worklet::ParticleAdvectionResult& res, vtkm::Id nSeeds, vtkm::Id maxSteps) { @@ -537,7 +537,7 @@ void ValidateParticleAdvectionResult( } } -void ValidateStreamlineResult(const vtkm::worklet::StreamlineResult& res, +void ValidateStreamlineResult(const vtkm::worklet::StreamlineResult& 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 points; + std::vector points; GenerateRandomParticles(points, 3, bounds); vtkm::worklet::ParticleAdvection pa; - vtkm::worklet::ParticleAdvectionResult res; + vtkm::worklet::ParticleAdvectionResult res; { auto seeds = vtkm::cont::make_ArrayHandle(points, vtkm::CopyFlag::On); using IntegratorType = vtkm::worklet::particleadvection::RK4Integrator; @@ -640,9 +640,9 @@ void TestParticleWorkletsWithDataSetTypes() dataSets.push_back(CreateWeirdnessFromStructuredDataSet(dataSets[0], DataSetOption::EXPLICIT)); //Generate three random points. - std::vector pts; + std::vector pts; GenerateRandomParticles(pts, 3, bound, 111); - std::vector pts2 = pts; + std::vector pts2 = pts; vtkm::Id nSeeds = static_cast(pts.size()); std::vector stepsTaken = { 10, 20, 600 }; @@ -662,7 +662,7 @@ void TestParticleWorkletsWithDataSetTypes() if (i < 2) { vtkm::worklet::ParticleAdvection pa; - vtkm::worklet::ParticleAdvectionResult res; + vtkm::worklet::ParticleAdvectionResult 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 res; + vtkm::worklet::StreamlineResult 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 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 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 particles; + std::vector particles; std::vector pts, samplePts, endPts; vtkm::FloatDefault X = static_cast(.1); vtkm::FloatDefault Y = static_cast(.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 res; + vtkm::worklet::ParticleAdvectionResult res; res = pa.Run(rk4, seedsArray, maxSteps); @@ -823,7 +823,7 @@ void TestWorkletsBasic() else if (w == "streamline") { vtkm::worklet::Streamline s; - vtkm::worklet::StreamlineResult res; + vtkm::worklet::StreamlineResult 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 seeds; + std::vector seeds; for (size_t j = 0; j < pts.size(); j++) - seeds.push_back(vtkm::Massless(pts[j], static_cast(j))); + seeds.push_back(vtkm::Particle(pts[j], static_cast(j))); auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off); if (i == 0) { vtkm::worklet::ParticleAdvection pa; - vtkm::worklet::ParticleAdvectionResult res; + vtkm::worklet::ParticleAdvectionResult 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 res; + vtkm::worklet::StreamlineResult res; res = s.Run(rk4, seedArray, maxSteps); ValidateResult(res, maxSteps, endPts); diff --git a/vtkm/worklet/testing/UnitTestTemporalAdvection.cxx b/vtkm/worklet/testing/UnitTestTemporalAdvection.cxx index 84b1fbebf..33d8c10e5 100644 --- a/vtkm/worklet/testing/UnitTestTemporalAdvection.cxx +++ b/vtkm/worklet/testing/UnitTestTemporalAdvection.cxx @@ -50,7 +50,7 @@ public: using ExecutionSignature = void(_1, _2, _3, _4); template - 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 void ValidateEvaluator(const EvalType& eval, - const vtkm::cont::ArrayHandle& pointIns, + const vtkm::cont::ArrayHandle& pointIns, const vtkm::cont::ArrayHandle& 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& pointIns) + vtkm::cont::ArrayHandle& 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 pointIns; + vtkm::cont::ArrayHandle pointIns; vtkm::cont::ArrayHandle validity; GeneratePoints(numValues, bounds, pointIns); GenerateValidity(numValues, validity, X, Z);