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

Merge branch 'particle_status_merge' of gitlab.kitware.com:ayenpure/vtk-m into lcs

Browse Source
This commit is contained in:
Abhishek Yenpure 2019-08-06 11:29:35 -06:00
commit 66f629a571
8 changed files with 164 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vtkm/cont/CellLocatorUniformGrid.cxx
View File

@ -47,7 +47,7 @@ void CellLocatorUniformGrid::Build()
this->RangeTransform[1] = static_cast<vtkm::FloatDefault>(this->CellDims[1]) /
static_cast<vtkm::FloatDefault>(this->Bounds.Y.Length());
}
else if (cellSet.IsSameType(Structured2DType()))
else if (cellSet.IsSameType(Structured3DType()))
{
this->Is3D = true;
this->Bounds = coords.GetBounds();

18
vtkm/worklet/particleadvection/GridEvaluators.h
View File

@ -31,6 +31,12 @@ namespace worklet
{
namespace particleadvection
{
enum class EvaluatorStatus
{
SUCCESS = 0,
OUTSIDE_SPATIAL_BOUNDS,
OUTSIDE_TEMPORAL_BOUNDS
};
template <typename DeviceAdapter, typename FieldArrayType>
class ExecutionGridEvaluator
@ -80,22 +86,22 @@ public:
}
template <typename Point>
VTKM_EXEC ParticleStatus Evaluate(const Point& pos,
vtkm::FloatDefault vtkmNotUsed(time),
Point& out) const
VTKM_EXEC EvaluatorStatus Evaluate(const Point& pos,
vtkm::FloatDefault vtkmNotUsed(time),
Point& out) const
{
return this->Evaluate(pos, out);
}
template <typename Point>
VTKM_EXEC ParticleStatus Evaluate(const Point point, Point& out) const
VTKM_EXEC EvaluatorStatus Evaluate(const Point point, Point& out) const
{
vtkm::Id cellId;
Point parametric;
vtkm::exec::FunctorBase tmp;
Locator->FindCell(point, cellId, parametric, tmp);
if (cellId == -1)
return ParticleStatus::AT_SPATIAL_BOUNDARY;
return EvaluatorStatus::OUTSIDE_SPATIAL_BOUNDS;
vtkm::UInt8 cellShape;
vtkm::IdComponent nVerts;
@ -107,7 +113,7 @@ public:
fieldValues.Append(Field.Get(ptIndices[i]));
out = vtkm::exec::CellInterpolate(fieldValues, parametric, cellShape, tmp);
return ParticleStatus::STATUS_OK;
return EvaluatorStatus::SUCCESS;
}
private:

120
vtkm/worklet/particleadvection/Integrators.h
View File

@ -22,6 +22,7 @@
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/VirtualObjectHandle.h>
#include <vtkm/worklet/particleadvection/GridEvaluators.h>
#include <vtkm/worklet/particleadvection/Particles.h>
namespace vtkm
@ -30,6 +31,13 @@ namespace worklet
{
namespace particleadvection
{
enum class IntegratorStatus
{
SUCCESS = 0,
OUTSIDE_SPATIAL_BOUNDS,
OUTSIDE_TEMPORAL_BOUNDS,
FAIL
};
class Integrator : public vtkm::cont::ExecutionObjectBase
{
@ -59,14 +67,30 @@ public:
public:
VTKM_EXEC
virtual ParticleStatus Step(const vtkm::Vec<ScalarType, 3>& inpos,
ScalarType& time,
vtkm::Vec<ScalarType, 3>& outpos) const = 0;
virtual IntegratorStatus Step(const vtkm::Vec<ScalarType, 3>& inpos,
ScalarType& time,
vtkm::Vec<ScalarType, 3>& outpos) const = 0;
VTKM_EXEC
virtual ParticleStatus SmallStep(vtkm::Vec<ScalarType, 3>& inpos,
ScalarType& time,
vtkm::Vec<ScalarType, 3>& outpos) const = 0;
virtual IntegratorStatus SmallStep(vtkm::Vec<ScalarType, 3>& inpos,
ScalarType& time,
vtkm::Vec<ScalarType, 3>& outpos) const = 0;
VTKM_EXEC
IntegratorStatus ConvertToIntegratorStatus(EvaluatorStatus status) const
{
switch (status)
{
case EvaluatorStatus::SUCCESS:
return IntegratorStatus::SUCCESS;
case EvaluatorStatus::OUTSIDE_SPATIAL_BOUNDS:
return IntegratorStatus::OUTSIDE_SPATIAL_BOUNDS;
case EvaluatorStatus::OUTSIDE_TEMPORAL_BOUNDS:
return IntegratorStatus::OUTSIDE_TEMPORAL_BOUNDS;
default:
return IntegratorStatus::FAIL;
}
}
protected:
ScalarType StepLength = 1.0f;
@ -86,7 +110,8 @@ private:
protected:
ScalarType StepLength;
ScalarType Tolerance = std::numeric_limits<ScalarType>::epsilon() * 100.0;
ScalarType Tolerance =
std::numeric_limits<ScalarType>::epsilon() * static_cast<ScalarType>(100.0f);
VTKM_CONT virtual void PrepareForExecutionImpl(
vtkm::cont::DeviceAdapterId device,
@ -107,40 +132,40 @@ protected:
public:
VTKM_EXEC
ParticleStatus Step(const vtkm::Vec<ScalarType, 3>& inpos,
ScalarType& time,
vtkm::Vec<ScalarType, 3>& outpos) const override
IntegratorStatus Step(const vtkm::Vec<ScalarType, 3>& inpos,
ScalarType& time,
vtkm::Vec<ScalarType, 3>& outpos) const override
{
// If particle is out of either spatial or temporal boundary to begin with,
// then return the corresponding status.
if (!this->Evaluator.IsWithinSpatialBoundary(inpos))
return ParticleStatus::AT_SPATIAL_BOUNDARY;
return IntegratorStatus::OUTSIDE_SPATIAL_BOUNDS;
if (!this->Evaluator.IsWithinTemporalBoundary(time))
return ParticleStatus::AT_TEMPORAL_BOUNDARY;
return IntegratorStatus::OUTSIDE_TEMPORAL_BOUNDS;
vtkm::Vec<ScalarType, 3> velocity;
ParticleStatus status = CheckStep(inpos, this->StepLength, time, velocity);
if (status == ParticleStatus::STATUS_OK)
IntegratorStatus status = CheckStep(inpos, this->StepLength, time, velocity);
if (status == IntegratorStatus::SUCCESS)
{
outpos = inpos + StepLength * velocity;
time += StepLength;
}
else
{
outpos = inpos;
}
return status;
}
VTKM_EXEC
ParticleStatus SmallStep(vtkm::Vec<ScalarType, 3>& inpos,
ScalarType& time,
vtkm::Vec<ScalarType, 3>& outpos) const override
IntegratorStatus SmallStep(vtkm::Vec<ScalarType, 3>& inpos,
ScalarType& time,
vtkm::Vec<ScalarType, 3>& outpos) const override
{
if (!this->Evaluator.IsWithinSpatialBoundary(inpos))
return ParticleStatus::AT_SPATIAL_BOUNDARY;
return IntegratorStatus::OUTSIDE_SPATIAL_BOUNDS;
if (!this->Evaluator.IsWithinTemporalBoundary(time))
return ParticleStatus::AT_TEMPORAL_BOUNDARY;
return IntegratorStatus::OUTSIDE_TEMPORAL_BOUNDS;
ScalarType optimalLength = static_cast<ScalarType>(0);
vtkm::Id iteration = static_cast<vtkm::Id>(1);
vtkm::Id maxIterations = static_cast<vtkm::Id>(1 << 20);
@ -155,8 +180,8 @@ protected:
{
iteration = iteration << 1;
ScalarType length = optimalLength + (this->StepLength / static_cast<ScalarType>(iteration));
ParticleStatus status = this->CheckStep(inpos, length, time, velocity);
if (status == ParticleStatus::STATUS_OK &&
IntegratorStatus status = this->CheckStep(inpos, length, time, velocity);
if (status == IntegratorStatus::SUCCESS &&
this->Evaluator.IsWithinSpatialBoundary(inpos + velocity * length))
{
workpos = inpos + velocity * length;
@ -183,14 +208,14 @@ protected:
outpos = workpos + minLength * velocity;
time = worktime + minLength;
return ParticleStatus::AT_SPATIAL_BOUNDARY;
return IntegratorStatus::OUTSIDE_SPATIAL_BOUNDS;
}
VTKM_EXEC
ParticleStatus CheckStep(const vtkm::Vec<ScalarType, 3>& inpos,
ScalarType stepLength,
ScalarType time,
vtkm::Vec<ScalarType, 3>& velocity) const
IntegratorStatus CheckStep(const vtkm::Vec<ScalarType, 3>& inpos,
ScalarType stepLength,
ScalarType time,
vtkm::Vec<ScalarType, 3>& velocity) const
{
return static_cast<const DerivedType*>(this)->CheckStep(inpos, stepLength, time, velocity);
}
@ -260,10 +285,10 @@ public:
}
VTKM_EXEC
ParticleStatus CheckStep(const vtkm::Vec<ScalarType, 3>& inpos,
ScalarType stepLength,
ScalarType time,
vtkm::Vec<ScalarType, 3>& velocity) const
IntegratorStatus CheckStep(const vtkm::Vec<ScalarType, 3>& inpos,
ScalarType stepLength,
ScalarType time,
vtkm::Vec<ScalarType, 3>& velocity) const
{
ScalarType boundary = this->Evaluator.GetTemporalBoundary(static_cast<vtkm::Id>(1));
if ((time + stepLength + vtkm::Epsilon<ScalarType>() - boundary) > 0.0)
@ -277,22 +302,22 @@ public:
vtkm::TypeTraits<vtkm::Vec<ScalarType, 3>>::ZeroInitialization();
vtkm::Vec<ScalarType, 3> k2 = k1, k3 = k1, k4 = k1;
ParticleStatus status;
EvaluatorStatus status;
status = this->Evaluator.Evaluate(inpos, time, k1);
if (status != ParticleStatus::STATUS_OK)
return status;
if (status != EvaluatorStatus::SUCCESS)
return this->ConvertToIntegratorStatus(status);
status = this->Evaluator.Evaluate(inpos + var1 * k1, var2, k2);
if (status != ParticleStatus::STATUS_OK)
return status;
if (status != EvaluatorStatus::SUCCESS)
return this->ConvertToIntegratorStatus(status);
status = this->Evaluator.Evaluate(inpos + var1 * k2, var2, k3);
if (status != ParticleStatus::STATUS_OK)
return status;
if (status != EvaluatorStatus::SUCCESS)
return this->ConvertToIntegratorStatus(status);
status = this->Evaluator.Evaluate(inpos + stepLength * k3, var3, k4);
if (status != ParticleStatus::STATUS_OK)
return status;
if (status != EvaluatorStatus::SUCCESS)
return this->ConvertToIntegratorStatus(status);
velocity = (k1 + 2 * k2 + 2 * k3 + k4) / 6.0f;
return ParticleStatus::STATUS_OK;
return IntegratorStatus::SUCCESS;
}
};
@ -349,12 +374,13 @@ public:
}
VTKM_EXEC
ParticleStatus CheckStep(const vtkm::Vec<ScalarType, 3>& inpos,
ScalarType vtkmNotUsed(stepLength),
ScalarType time,
vtkm::Vec<ScalarType, 3>& velocity) const
IntegratorStatus CheckStep(const vtkm::Vec<ScalarType, 3>& inpos,
ScalarType vtkmNotUsed(stepLength),
ScalarType time,
vtkm::Vec<ScalarType, 3>& velocity) const
{
return this->Evaluator.Evaluate(inpos, time, velocity);
EvaluatorStatus status = this->Evaluator.Evaluate(inpos, time, velocity);
return this->ConvertToIntegratorStatus(status);
}
};

21
vtkm/worklet/particleadvection/ParticleAdvectionWorklets.h
View File

@ -21,6 +21,7 @@
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/particleadvection/Integrators.h>
#include <vtkm/worklet/particleadvection/Particles.h>
namespace vtkm
@ -45,14 +46,14 @@ public:
vtkm::Vec<ScalarType, 3> inpos = integralCurve.GetPos(idx);
vtkm::Vec<ScalarType, 3> outpos;
ScalarType time = integralCurve.GetTime(idx);
ParticleStatus status;
IntegratorStatus status;
bool tookAnySteps = false;
while (!integralCurve.Done(idx))
{
status = integrator->Step(inpos, time, outpos);
// If the status is OK, we only need to check if the particle
// has completed the maximum steps required.
if (status == ParticleStatus::STATUS_OK)
if (status == IntegratorStatus::SUCCESS)
{
integralCurve.TakeStep(idx, outpos);
// This is to keep track of the particle's time.
@ -66,27 +67,27 @@ public:
// push it a little out of the boundary so that it will start advection in
// another domain, or in another time slice. Taking small steps enables
// reducing the error introduced at spatial or temporal boundaries.
else if (status == ParticleStatus::AT_TEMPORAL_BOUNDARY)
else if (status == IntegratorStatus::OUTSIDE_TEMPORAL_BOUNDS)
{
integralCurve.SetAtTemporalBoundary(idx);
integralCurve.SetExitTemporalBoundary(idx);
break;
}
else if (status == ParticleStatus::AT_SPATIAL_BOUNDARY)
else if (status == IntegratorStatus::OUTSIDE_SPATIAL_BOUNDS)
{
status = integrator->SmallStep(inpos, time, outpos);
integralCurve.TakeStep(idx, outpos);
integralCurve.SetTime(idx, time);
if (status == ParticleStatus::AT_SPATIAL_BOUNDARY)
if (status == IntegratorStatus::OUTSIDE_TEMPORAL_BOUNDS)
{
integralCurve.SetAtSpatialBoundary(idx);
integralCurve.SetExitTemporalBoundary(idx);
break;
}
else if (status == ParticleStatus::AT_TEMPORAL_BOUNDARY)
else if (status == IntegratorStatus::OUTSIDE_SPATIAL_BOUNDS)
{
integralCurve.SetAtTemporalBoundary(idx);
integralCurve.SetExitSpatialBoundary(idx);
break;
}
else if (status == ParticleStatus::STATUS_ERROR)
else if (status == IntegratorStatus::FAIL)
{
integralCurve.SetError(idx);
break;

81
vtkm/worklet/particleadvection/Particles.h
View File

@ -26,16 +26,14 @@ namespace particleadvection
using ScalarType = vtkm::FloatDefault;
enum ParticleStatus
enum class ParticleStatus
{
STATUS_OK = 1,
SUCCESS = 1,
TERMINATED = 1 << 1,
AT_SPATIAL_BOUNDARY = 1 << 2,
AT_TEMPORAL_BOUNDARY = 1 << 3,
EXITED_SPATIAL_BOUNDARY = 1 << 4,
EXITED_TEMPORAL_BOUNDARY = 1 << 5,
STATUS_ERROR = 1 << 6,
TOOK_ANY_STEPS = 1 << 7
EXIT_SPATIAL_BOUNDARY = 1 << 2,
EXIT_TEMPORAL_BOUNDARY = 1 << 3,
FAIL = 1 << 4,
TOOK_ANY_STEPS = 1 << 5
};
template <typename Device>
@ -89,75 +87,62 @@ public:
void SetOK(const vtkm::Id& idx)
{
Clear(idx);
Status.Set(idx, STATUS_OK);
Status.Set(idx, ParticleStatus::SUCCESS);
}
VTKM_EXEC
void SetTerminated(const vtkm::Id& idx)
{
ClearBit(idx, STATUS_OK);
SetBit(idx, TERMINATED);
}
VTKM_EXEC
void SetAtSpatialBoundary(const vtkm::Id& idx)
{
ClearBit(idx, STATUS_OK);
SetBit(idx, AT_SPATIAL_BOUNDARY);
}
VTKM_EXEC
void SetAtTemporalBoundary(const vtkm::Id& idx)
{
ClearBit(idx, STATUS_OK);
SetBit(idx, AT_TEMPORAL_BOUNDARY);
ClearBit(idx, ParticleStatus::SUCCESS);
SetBit(idx, ParticleStatus::TERMINATED);
}
VTKM_EXEC
void SetTookAnySteps(const vtkm::Id& idx, const bool& val)
{
if (val)
SetBit(idx, TOOK_ANY_STEPS);
SetBit(idx, ParticleStatus::TOOK_ANY_STEPS);
else
ClearBit(idx, TOOK_ANY_STEPS);
ClearBit(idx, ParticleStatus::TOOK_ANY_STEPS);
}
VTKM_EXEC
void SetExitedSpatialBoundary(const vtkm::Id& idx)
void SetExitSpatialBoundary(const vtkm::Id& idx)
{
ClearBit(idx, STATUS_OK);
SetBit(idx, EXITED_SPATIAL_BOUNDARY);
ClearBit(idx, ParticleStatus::SUCCESS);
SetBit(idx, ParticleStatus::EXIT_SPATIAL_BOUNDARY);
}
VTKM_EXEC
void SetExitedTemporalBoundary(const vtkm::Id& idx)
void SetExitTemporalBoundary(const vtkm::Id& idx)
{
ClearBit(idx, STATUS_OK);
SetBit(idx, EXITED_TEMPORAL_BOUNDARY);
ClearBit(idx, ParticleStatus::SUCCESS);
SetBit(idx, ParticleStatus::EXIT_TEMPORAL_BOUNDARY);
}
VTKM_EXEC
void SetError(const vtkm::Id& idx)
{
ClearBit(idx, STATUS_OK);
SetBit(idx, STATUS_ERROR);
ClearBit(idx, ParticleStatus::SUCCESS);
SetBit(idx, ParticleStatus::FAIL);
}
/* Check Status */
VTKM_EXEC
bool OK(const vtkm::Id& idx) { return CheckBit(idx, STATUS_OK); }
bool OK(const vtkm::Id& idx) { return CheckBit(idx, ParticleStatus::SUCCESS); }
VTKM_EXEC
bool Terminated(const vtkm::Id& idx) { return CheckBit(idx, TERMINATED); }
bool Terminated(const vtkm::Id& idx) { return CheckBit(idx, ParticleStatus::TERMINATED); }
VTKM_EXEC
bool AtSpatialBoundary(const vtkm::Id& idx) { return CheckBit(idx, AT_SPATIAL_BOUNDARY); }
VTKM_EXEC
bool AtTemporalBoundary(const vtkm::Id& idx) { return CheckBit(idx, AT_TEMPORAL_BOUNDARY); }
VTKM_EXEC
bool ExitedSpatialBoundary(const vtkm::Id& idx) { return CheckBit(idx, EXITED_SPATIAL_BOUNDARY); }
VTKM_EXEC
bool ExitedTemporalBoundary(const vtkm::Id& idx)
bool ExitSpatialBoundary(const vtkm::Id& idx)
{
return CheckBit(idx, EXITED_TEMPORAL_BOUNDARY);
return CheckBit(idx, ParticleStatus::EXIT_SPATIAL_BOUNDARY);
}
VTKM_EXEC
bool Error(const vtkm::Id& idx) { return CheckBit(idx, STATUS_ERROR); }
bool ExitTemporalBoundary(const vtkm::Id& idx)
{
return CheckBit(idx, ParticleStatus::EXIT_TEMPORAL_BOUNDARY);
}
VTKM_EXEC
bool Error(const vtkm::Id& idx) { return CheckBit(idx, ParticleStatus::FAIL); }
VTKM_EXEC
bool Integrateable(const vtkm::Id& idx)
{
return OK(idx) && !(Terminated(idx) || AtSpatialBoundary(idx) || AtTemporalBoundary(idx));
return OK(idx) && !(Terminated(idx) || ExitSpatialBoundary(idx) || ExitTemporalBoundary(idx));
}
VTKM_EXEC
bool Done(const vtkm::Id& idx) { return !Integrateable(idx); }
@ -168,17 +153,17 @@ public:
VTKM_EXEC
void SetBit(const vtkm::Id& idx, const ParticleStatus& b)
{
Status.Set(idx, Status.Get(idx) | b);
Status.Set(idx, Status.Get(idx) | static_cast<vtkm::Id>(b));
}
VTKM_EXEC
void ClearBit(const vtkm::Id& idx, const ParticleStatus& b)
{
Status.Set(idx, Status.Get(idx) & ~b);
Status.Set(idx, Status.Get(idx) & ~static_cast<vtkm::Id>(b));
}
VTKM_EXEC
bool CheckBit(const vtkm::Id& idx, const ParticleStatus& b) const
{
return (Status.Get(idx) & b) != 0;
return (Status.Get(idx) & static_cast<vtkm::Id>(b)) != 0;
}
VTKM_EXEC

12
vtkm/worklet/particleadvection/TemporalGridEvaluators.h
View File

@ -68,23 +68,23 @@ public:
}
template <typename Point>
VTKM_EXEC ParticleStatus Evaluate(const Point& pos, vtkm::FloatDefault time, Point& out) const
VTKM_EXEC EvaluatorStatus Evaluate(const Point& pos, vtkm::FloatDefault time, Point& out) const
{
// Validate time is in bounds for the current two slices.
if (!(time >= TimeOne && time <= TimeTwo))
return ParticleStatus::AT_TEMPORAL_BOUNDARY;
ParticleStatus eval;
return EvaluatorStatus::OUTSIDE_TEMPORAL_BOUNDS;
EvaluatorStatus eval;
Point one, two;
eval = this->EvaluatorOne.Evaluate(pos, one);
if (!eval)
if (eval != EvaluatorStatus::SUCCESS)
return eval;
eval = this->EvaluatorTwo.Evaluate(pos, two);
if (!eval)
if (eval != EvaluatorStatus::SUCCESS)
return eval;
// LERP between the two values of calculated fields to obtain the new value
ScalarType proportion = (time - this->TimeOne) / this->TimeDiff;
out = vtkm::Lerp(one, two, proportion);
return ParticleStatus::STATUS_OK;
return EvaluatorStatus::SUCCESS;
}
private:

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

@ -259,10 +259,10 @@ public:
template <typename EvaluatorType>
VTKM_EXEC void operator()(vtkm::Vec<ScalarType, 3>& pointIn,
const EvaluatorType& evaluator,
bool& validity,
vtkm::worklet::particleadvection::EvaluatorStatus& status,
vtkm::Vec<ScalarType, 3>& pointOut) const
{
validity = evaluator.Evaluate(pointIn, pointOut);
status = evaluator.Evaluate(pointIn, pointOut);
}
};
@ -274,21 +274,22 @@ void ValidateEvaluator(const EvalType& eval,
{
using EvalTester = TestEvaluatorWorklet<ScalarType>;
using EvalTesterDispatcher = vtkm::worklet::DispatcherMapField<EvalTester>;
using Status = vtkm::worklet::particleadvection::EvaluatorStatus;
EvalTester evalTester;
EvalTesterDispatcher evalTesterDispatcher(evalTester);
vtkm::cont::ArrayHandle<vtkm::Vec<ScalarType, 3>> pointsHandle =
vtkm::cont::make_ArrayHandle(pointIns);
vtkm::Id numPoints = pointsHandle.GetNumberOfValues();
vtkm::cont::ArrayHandle<bool> evalStatus;
vtkm::cont::ArrayHandle<Status> evalStatus;
vtkm::cont::ArrayHandle<vtkm::Vec<ScalarType, 3>> evalResults;
evalTesterDispatcher.Invoke(pointsHandle, eval, evalStatus, evalResults);
auto statusPortal = evalStatus.GetPortalConstControl();
auto resultsPortal = evalResults.GetPortalConstControl();
for (vtkm::Id index = 0; index < numPoints; index++)
{
bool status = statusPortal.Get(index);
Status status = statusPortal.Get(index);
vtkm::Vec<ScalarType, 3> result = resultsPortal.Get(index);
VTKM_TEST_ASSERT(status, "Error in evaluator for " + msg);
VTKM_TEST_ASSERT(status == Status::SUCCESS, "Error in evaluator for " + msg);
VTKM_TEST_ASSERT(result == vec, "Error in evaluator result for " + msg);
}
pointsHandle.ReleaseResources();
@ -310,7 +311,7 @@ public:
template <typename IntegratorType>
VTKM_EXEC void operator()(vtkm::Vec<ScalarType, 3>& pointIn,
const IntegratorType* integrator,
vtkm::worklet::particleadvection::ParticleStatus& status,
vtkm::worklet::particleadvection::IntegratorStatus& status,
vtkm::Vec<ScalarType, 3>& pointOut) const
{
ScalarType time = 0;
@ -327,7 +328,7 @@ void ValidateIntegrator(const IntegratorType& integrator,
{
using IntegratorTester = TestIntegratorWorklet<ScalarType>;
using IntegratorTesterDispatcher = vtkm::worklet::DispatcherMapField<IntegratorTester>;
using Status = vtkm::worklet::particleadvection::ParticleStatus;
using Status = vtkm::worklet::particleadvection::IntegratorStatus;
IntegratorTesterDispatcher integratorTesterDispatcher;
vtkm::cont::ArrayHandle<vtkm::Vec<ScalarType, 3>> pointsHandle =
vtkm::cont::make_ArrayHandle(pointIns);
@ -336,15 +337,17 @@ void ValidateIntegrator(const IntegratorType& integrator,
vtkm::cont::ArrayHandle<vtkm::Vec<ScalarType, 3>> stepResults;
integratorTesterDispatcher.Invoke(pointsHandle, integrator, stepStatus, stepResults);
auto statusPortal = stepStatus.GetPortalConstControl();
auto pointsPortal = pointsHandle.GetPortalConstControl();
auto resultsPortal = stepResults.GetPortalConstControl();
for (vtkm::Id index = 0; index < numPoints; index++)
{
Status status = statusPortal.Get(index);
vtkm::Vec<ScalarType, 3> result = resultsPortal.Get(index);
VTKM_TEST_ASSERT(status == Status::STATUS_OK || status == Status::TERMINATED ||
status == Status::AT_SPATIAL_BOUNDARY,
"Error in evaluator for " + msg);
if (status != Status::AT_SPATIAL_BOUNDARY)
VTKM_TEST_ASSERT(status != Status::FAIL, "Error in evaluator for " + msg);
if (status == Status::OUTSIDE_SPATIAL_BOUNDS)
VTKM_TEST_ASSERT(result == pointsPortal.Get(index),
"Error in evaluator result for [OUTSIDE SPATIAL]" + msg);
else
VTKM_TEST_ASSERT(result == expStepResults[(size_t)index],
"Error in evaluator result for " + msg);
}
@ -360,10 +363,11 @@ void ValidateIntegratorForBoundary(const vtkm::Vec<ScalarType, 3>& vector,
const std::vector<vtkm::Vec<ScalarType, 3>>& pointIns,
const std::string& msg)
{
ScalarType tolerance = vtkm::Epsilon<ScalarType>() * 100;
using IntegratorTester = TestIntegratorWorklet<ScalarType>;
using IntegratorTesterDispatcher = vtkm::worklet::DispatcherMapField<IntegratorTester>;
using Status = vtkm::worklet::particleadvection::ParticleStatus;
using Status = vtkm::worklet::particleadvection::IntegratorStatus;
ScalarType tolerance = vtkm::Epsilon<ScalarType>() * 100;
IntegratorTesterDispatcher integratorTesterDispatcher;
vtkm::cont::ArrayHandle<vtkm::Vec<ScalarType, 3>> pointsHandle =
vtkm::cont::make_ArrayHandle(pointIns);
@ -383,7 +387,7 @@ void ValidateIntegratorForBoundary(const vtkm::Vec<ScalarType, 3>& vector,
VTKM_TEST_ASSERT((bounds.Y.Max - result[1]) < tolerance, "Y Tolerance not satisfied.");
if (vector[2] == 1.)
VTKM_TEST_ASSERT((bounds.Z.Max - result[2]) < tolerance, "Z Tolerance not satisfied.");
VTKM_TEST_ASSERT(status == Status::AT_SPATIAL_BOUNDARY, "Error in evaluator for " + msg);
VTKM_TEST_ASSERT(status == Status::OUTSIDE_SPATIAL_BOUNDS, "Error in evaluator for " + msg);
}
pointsHandle.ReleaseResources();
stepStatus.ReleaseResources();
@ -631,10 +635,10 @@ void TestParticleStatus()
auto res = pa.Run(rk4, seedsArray, maxSteps);
auto statusPortal = res.status.GetPortalConstControl();
vtkm::Id tookStep0 =
statusPortal.Get(0) & vtkm::worklet::particleadvection::ParticleStatus::TOOK_ANY_STEPS;
vtkm::Id tookStep1 =
statusPortal.Get(1) & vtkm::worklet::particleadvection::ParticleStatus::TOOK_ANY_STEPS;
vtkm::Id tookStep0 = statusPortal.Get(0) &
static_cast<vtkm::Id>(vtkm::worklet::particleadvection::ParticleStatus::TOOK_ANY_STEPS);
vtkm::Id tookStep1 = statusPortal.Get(1) &
static_cast<vtkm::Id>(vtkm::worklet::particleadvection::ParticleStatus::TOOK_ANY_STEPS);
VTKM_TEST_ASSERT(tookStep0 != 0, "Particle failed to take any steps");
VTKM_TEST_ASSERT(tookStep1 == 0, "Particle took a step when it should not have.");
}

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

@ -53,10 +53,10 @@ public:
template <typename EvaluatorType>
VTKM_EXEC void operator()(vtkm::Vec<ScalarType, 3>& pointIn,
const EvaluatorType& evaluator,
bool& validity,
vtkm::worklet::particleadvection::EvaluatorStatus& status,
vtkm::Vec<ScalarType, 3>& pointOut) const
{
validity = evaluator.Evaluate(pointIn, 0.5f, pointOut);
status = evaluator.Evaluate(pointIn, 0.5f, pointOut);
}
};
@ -68,10 +68,11 @@ void ValidateEvaluator(const EvalType& eval,
{
using EvalTester = TestEvaluatorWorklet<ScalarType>;
using EvalTesterDispatcher = vtkm::worklet::DispatcherMapField<EvalTester>;
using Status = vtkm::worklet::particleadvection::EvaluatorStatus;
EvalTester evalTester;
EvalTesterDispatcher evalTesterDispatcher(evalTester);
vtkm::Id numPoints = pointIns.GetNumberOfValues();
vtkm::cont::ArrayHandle<bool> evalStatus;
vtkm::cont::ArrayHandle<Status> evalStatus;
vtkm::cont::ArrayHandle<vtkm::Vec<ScalarType, 3>> evalResults;
evalTesterDispatcher.Invoke(pointIns, eval, evalStatus, evalResults);
auto statusPortal = evalStatus.GetPortalConstControl();
@ -79,10 +80,10 @@ void ValidateEvaluator(const EvalType& eval,
auto validityPortal = validity.GetPortalConstControl();
for (vtkm::Id index = 0; index < numPoints; index++)
{
bool status = statusPortal.Get(index);
Status status = statusPortal.Get(index);
vtkm::Vec<ScalarType, 3> result = resultsPortal.Get(index);
vtkm::Vec<ScalarType, 3> expected = validityPortal.Get(index);
VTKM_TEST_ASSERT(status, "Error in evaluator for " + msg);
VTKM_TEST_ASSERT(status == Status::SUCCESS, "Error in evaluator for " + msg);
VTKM_TEST_ASSERT(result == expected, "Error in evaluator result for " + msg);
}
evalStatus.ReleaseResources();