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

Remove TryExecute from filters

Browse Source 
Now that the dispatcher does its own TryExecute, filters do not need to
do that. This change requires all worklets called by filters to be able
to execute without knowing the device a priori.
This commit is contained in:
Kenneth Moreland 2018-08-30 08:53:18 -07:00
parent 03e2e721ec
commit bddad9b386
200 changed files with 2517 additions and 3225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
benchmarking/BenchmarkDeviceAdapter.cxx
View File

@ -698,7 +698,7 @@ private:
template <typename Value>
struct BenchStableSortIndices
{
using SSI = vtkm::worklet::StableSortIndices<DeviceAdapterTag>;
using SSI = vtkm::worklet::StableSortIndices;
using ValueArrayHandle = vtkm::cont::ArrayHandle<Value, StorageTag>;
ValueArrayHandle ValueHandle;
@ -743,7 +743,7 @@ private:
template <typename Value>
struct BenchStableSortIndicesUnique
{
using SSI = vtkm::worklet::StableSortIndices<DeviceAdapterTag>;
using SSI = vtkm::worklet::StableSortIndices;
using IndexArrayHandle = typename SSI::IndexArrayType;
using ValueArrayHandle = vtkm::cont::ArrayHandle<Value, StorageTag>;
@ -915,6 +915,7 @@ public:
static VTKM_CONT int Run()
{
std::cout << DIVIDER << "\nRunning DeviceAdapter benchmarks\n";
vtkm::cont::GetGlobalRuntimeDeviceTracker().ForceDevice(DeviceAdapterTag());
// Run fixed bytes / size tests:
for (int sizeType = 0; sizeType < 2; ++sizeType)

21
examples/clipping/Clipping.cxx
View File

@ -19,7 +19,6 @@
//============================================================================
#include <vtkm/cont/ArrayHandleCast.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/io/reader/VTKDataSetReader.h>
#include <vtkm/io/writer/VTKDataSetWriter.h>
@ -37,7 +36,6 @@ using FloatVec3 = vtkm::Vec<vtkm::Float32, 3>;
namespace
{
template <typename DeviceTag>
struct FieldMapper
{
vtkm::cont::DynamicArrayHandle& Output;
@ -58,11 +56,11 @@ struct FieldMapper
{
if (this->IsCellField)
{
this->Output = this->Worklet.ProcessCellField(input, DeviceTag());
this->Output = this->Worklet.ProcessCellField(input);
}
else
{
this->Output = this->Worklet.ProcessPointField(input, DeviceTag());
this->Output = this->Worklet.ProcessPointField(input);
}
}
};
@ -79,10 +77,6 @@ int main(int argc, char* argv[])
return 1;
}
using DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG;
std::cout << "Device Adapter Name: " << vtkm::cont::DeviceAdapterTraits<DeviceAdapter>::GetName()
<< std::endl;
vtkm::io::reader::VTKDataSetReader reader(argv[1]);
vtkm::cont::DataSet input = reader.ReadDataSet();
@ -91,15 +85,14 @@ int main(int argc, char* argv[])
vtkm::Float32 clipValue = std::stof(argv[argc - 2]);
vtkm::worklet::Clip clip;
vtkm::cont::Timer<DeviceAdapter> total;
vtkm::cont::Timer<DeviceAdapter> timer;
vtkm::cont::Timer<> total;
vtkm::cont::Timer<> timer;
bool invertClip = false;
vtkm::cont::CellSetExplicit<> outputCellSet =
clip.Run(input.GetCellSet(0),
scalarField.GetData().ResetTypeList(vtkm::TypeListTagScalarAll()),
clipValue,
invertClip,
DeviceAdapter());
invertClip);
vtkm::Float64 clipTime = timer.GetElapsedTime();
vtkm::cont::DataSet output;
@ -108,7 +101,7 @@ int main(int argc, char* argv[])
auto inCoords = input.GetCoordinateSystem(0).GetData();
timer.Reset();
auto outCoords = clip.ProcessCellField(inCoords, DeviceAdapter());
auto outCoords = clip.ProcessCellField(inCoords);
vtkm::Float64 processCoordinatesTime = timer.GetElapsedTime();
output.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", outCoords));
@ -132,7 +125,7 @@ int main(int argc, char* argv[])
}
vtkm::cont::DynamicArrayHandle outField;
FieldMapper<DeviceAdapter> fieldMapper(outField, clip, isCellField);
FieldMapper fieldMapper(outField, clip, isCellField);
inField.GetData().CastAndCall(fieldMapper);
output.AddField(vtkm::cont::Field(inField.GetName(), inField.GetAssociation(), outField));
}

47
examples/contour_tree_augmented/ContourTreeApp.cxx
View File

@ -62,10 +62,6 @@
#define DEBUG_TIMING
#ifndef VTKM_DEVICE_ADAPTER
#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_SERIAL
#endif
#ifdef ENABLE_SET_NUM_THREADS
#include "tbb/task_scheduler_init.h"
#endif
@ -149,12 +145,8 @@ private:
// Compute and render an isosurface for a uniform grid example
int main(int argc, char* argv[])
{
typedef VTKM_DEFAULT_DEVICE_ADAPTER_TAG DeviceAdapter;
auto tracker = vtkm::cont::GetGlobalRuntimeDeviceTracker();
tracker.ForceDevice(DeviceAdapter());
vtkm::cont::Timer<DeviceAdapter> totalTime;
// TODO: Change timing to use logging in vtkm/cont/Logging.h
vtkm::cont::Timer<> totalTime;
vtkm::Float64 prevTime = 0;
vtkm::Float64 currTime = 0;
std::cout << "ContourTreePPP2Mesh <options> <fileName>" << std::endl;
@ -337,20 +329,20 @@ int main(int argc, char* argv[])
////////////////////////////////////////////
if (computeBranchDecomposition)
{
vtkm::cont::Timer<DeviceAdapter> branchDecompTimer;
// TODO: Change timing to use logging in vtkm/cont/Logging.h
vtkm::cont::Timer<> branchDecompTimer;
// compute the volume for each hyperarc and superarc
cppp2_ns::IdArrayType superarcIntrinsicWeight;
cppp2_ns::IdArrayType superarcDependentWeight;
cppp2_ns::IdArrayType supernodeTransferWeight;
cppp2_ns::IdArrayType hyperarcDependentWeight;
cppp2_ns::ProcessContourTree::ComputeVolumeWeights<DeviceAdapter>(
filter.GetContourTree(),
filter.GetNumIterations(),
superarcIntrinsicWeight, // (output)
superarcDependentWeight, // (output)
supernodeTransferWeight, // (output)
hyperarcDependentWeight); // (output)
cppp2_ns::ProcessContourTree::ComputeVolumeWeights(filter.GetContourTree(),
filter.GetNumIterations(),
superarcIntrinsicWeight, // (output)
superarcDependentWeight, // (output)
supernodeTransferWeight, // (output)
hyperarcDependentWeight); // (output)
std::cout << std::setw(42) << std::left << "Compute Volume Weights"
<< ": " << branchDecompTimer.GetElapsedTime() << " seconds" << std::endl;
branchDecompTimer.Reset();
@ -362,15 +354,14 @@ int main(int argc, char* argv[])
cppp2_ns::IdArrayType branchSaddle;
cppp2_ns::IdArrayType branchParent;
cppp2_ns::ProcessContourTree::ComputeVolumeBranchDecomposition<DeviceAdapter>(
filter.GetContourTree(),
superarcDependentWeight,
superarcIntrinsicWeight,
whichBranch, // (output)
branchMinimum, // (output)
branchMaximum, // (output)
branchSaddle, // (output)
branchParent); // (output)
cppp2_ns::ProcessContourTree::ComputeVolumeBranchDecomposition(filter.GetContourTree(),
superarcDependentWeight,
superarcIntrinsicWeight,
whichBranch, // (output)
branchMinimum, // (output)
branchMaximum, // (output)
branchSaddle, // (output)
branchParent); // (output)
std::cout << std::setw(42) << std::left << "Compute Volume Branch Decomposition"
<< ": " << branchDecompTimer.GetElapsedTime() << " seconds" << std::endl;
}
@ -388,7 +379,7 @@ int main(int argc, char* argv[])
std::cout << "Contour Tree" << std::endl;
std::cout << "============" << std::endl;
cppp2_ns::EdgePairArray saddlePeak;
cppp2_ns::ProcessContourTree::CollectSortedSuperarcs<DeviceAdapter>(
cppp2_ns::ProcessContourTree::CollectSortedSuperarcs(
filter.GetContourTree(), filter.GetSortOrder(), saddlePeak);
cppp2_ns::printEdgePairArray(saddlePeak);
}

21
examples/game_of_life/GameOfLife.cxx
View File

@ -122,23 +122,12 @@ struct UpdateLifeState : public vtkm::worklet::WorkletPointNeighborhood3x3x3
class GameOfLife : public vtkm::filter::FilterDataSet<GameOfLife>
{
bool PrintedDeviceMsg = false;
public:
template <typename Policy, typename Device>
template <typename Policy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<Policy> policy,
Device)
vtkm::filter::PolicyBase<Policy> policy)
{
if (!this->PrintedDeviceMsg)
{
using DeviceAdapterTraits = vtkm::cont::DeviceAdapterTraits<Device>;
std::cout << "Running GameOfLife filter on device adapter: " << DeviceAdapterTraits::GetName()
<< std::endl;
this->PrintedDeviceMsg = true;
}
using DispatcherType = vtkm::worklet::DispatcherPointNeighborhood<UpdateLifeState>;
@ -154,7 +143,6 @@ public:
//Update the game state
DispatcherType dispatcher;
dispatcher.SetDevice(Device());
dispatcher.Invoke(vtkm::filter::ApplyPolicy(cells, policy), prevstate, state, colors);
//save the results
@ -171,12 +159,11 @@ public:
return output;
}
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<T, StorageType>&,
const vtkm::filter::FieldMetadata&,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
DeviceAdapter)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
return false;
}

2
examples/multi_backend/MultiDeviceGradient.h
View File

@ -28,7 +28,7 @@
#include <thread>
using RuntimeTaskQueue = TaskQueue<std::function<void(const vtkm::cont::RuntimeDeviceTracker&)>>;
using RuntimeTaskQueue = TaskQueue<std::function<void()>>;
/// \brief Construct a MultiDeviceGradient for a given multiblock dataset
///

31
examples/multi_backend/MultiDeviceGradient.hxx
View File

@ -45,10 +45,10 @@ void process_block_tbb(RuntimeTaskQueue& queue)
{
//Step 1. Set the device adapter to this thread to TBB.
//This makes sure that any vtkm::filters used by our
//task operate only on TBB
//task operate only on TBB. The "global" thread tracker
//is actually thread-local, so we can use that.
//
vtkm::cont::RuntimeDeviceTracker tracker;
tracker.ForceDevice(vtkm::cont::DeviceAdapterTagTBB{});
vtkm::cont::GetGlobalRuntimeDeviceTracker().ForceDevice(vtkm::cont::DeviceAdapterTagTBB{});
while (queue.hasTasks())
{
@ -60,7 +60,7 @@ void process_block_tbb(RuntimeTaskQueue& queue)
//when the queue is empty and we are shutting down
if (task != nullptr)
{
task(tracker);
task();
}
//Step 4. Notify the queue that we finished processing this task
@ -73,13 +73,10 @@ void process_block_cuda(RuntimeTaskQueue& queue, int gpuId)
{
//Step 1. Set the device adapter to this thread to cuda.
//This makes sure that any vtkm::filters used by our
//task operate only on cuda
//task operate only on cuda. The "global" thread tracker
//is actually thread-local, so we can use that.
//
vtkm::cont::RuntimeDeviceTracker tracker;
#if defined(VTKM_ENABLE_CUDA)
auto error = cudaSetDevice(gpuId);
tracker.ForceDevice(vtkm::cont::DeviceAdapterTagCuda{});
#endif
vtkm::cont::GetGlobalRuntimeDeviceTracker().ForceDevice(vtkm::cont::DeviceAdapterTagCuda{});
(void)gpuId;
while (queue.hasTasks())
@ -87,12 +84,12 @@ void process_block_cuda(RuntimeTaskQueue& queue, int gpuId)
//Step 2. Get the task to run on cuda
auto task = queue.pop();
//Step 3. Run the task on TBB. We check the validity
//Step 3. Run the task on cuda. We check the validity
//of the task since we could be given an empty task
//when the queue is empty and we are shutting down
if (task != nullptr)
{
task(tracker);
task();
}
//Step 4. Notify the queue that we finished processing this task
@ -190,11 +187,8 @@ inline VTKM_CONT vtkm::cont::MultiBlock MultiDeviceGradient::PrepareForExecution
{
vtkm::cont::DataSet input = *block;
this->Queue.push( //build a lambda that is the work to do
[=](const vtkm::cont::RuntimeDeviceTracker& tracker) {
//make a per thread copy of the filter
//and give it the device tracker
[=]() {
vtkm::filter::Gradient perThreadGrad = gradient;
perThreadGrad.SetRuntimeDeviceTracker(tracker);
vtkm::cont::DataSet result = perThreadGrad.Execute(input, policy);
outPtr->ReplaceBlock(0, result);
@ -212,11 +206,8 @@ inline VTKM_CONT vtkm::cont::MultiBlock MultiDeviceGradient::PrepareForExecution
//will allows us to have multiple works execute in a non
//blocking manner
this->Queue.push( //build a lambda that is the work to do
[=](const vtkm::cont::RuntimeDeviceTracker& tracker) {
//make a per thread copy of the filter
//and give it the device tracker
[=]() {
vtkm::filter::Gradient perThreadGrad = gradient;
perThreadGrad.SetRuntimeDeviceTracker(tracker);
vtkm::cont::DataSet result = perThreadGrad.Execute(input, policy);
outPtr->ReplaceBlock(index, result);

10
examples/particle_advection/ParticleAdvection.cxx
View File

@ -18,10 +18,6 @@
// this software.
//============================================================================
#ifndef VTKM_DEVICE_ADAPTER
#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_SERIAL
#endif
#include <vtkm/cont/DataSet.h>
#include <vtkm/worklet/ParticleAdvection.h>
#include <vtkm/worklet/particleadvection/GridEvaluators.h>
@ -66,8 +62,6 @@ void RunTest(const std::string& fname,
vtkm::Id advectType,
vtkm::Id seeding)
{
using DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG;
using FieldType = vtkm::Float32;
using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>>;
@ -163,12 +157,12 @@ void RunTest(const std::string& fname,
if (advectType == 0)
{
vtkm::worklet::ParticleAdvection particleAdvection;
particleAdvection.Run(rk4, seedArray, numSteps, DeviceAdapter());
particleAdvection.Run(rk4, seedArray, numSteps);
}
else
{
vtkm::worklet::Streamline streamline;
streamline.Run(rk4, seedArray, numSteps, DeviceAdapter());
streamline.Run(rk4, seedArray, numSteps);
}
auto t1 = std::chrono::high_resolution_clock::now() - t0;

10
examples/temporal_advection/TemporalAdvection.cxx
View File

@ -18,10 +18,6 @@
// this software.
//============================================================================
#ifndef VTKM_DEVICE_ADAPTER
#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_SERIAL
#endif
#include <vtkm/cont/DataSet.h>
#include <vtkm/worklet/ParticleAdvection.h>
#include <vtkm/worklet/particleadvection/Integrators.h>
@ -49,7 +45,6 @@ int renderAndWriteDataSet(const vtkm::cont::DataSet& dataset)
void RunTest(vtkm::Id numSteps, vtkm::Float32 stepSize, vtkm::Id advectType)
{
using DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG;
using FieldType = vtkm::Float32;
using FieldHandle = vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>>;
@ -104,13 +99,12 @@ void RunTest(vtkm::Id numSteps, vtkm::Float32 stepSize, vtkm::Id advectType)
if (advectType == 0)
{
vtkm::worklet::ParticleAdvection particleAdvection;
particleAdvection.Run(integrator, seedArray, numSteps, DeviceAdapter());
particleAdvection.Run(integrator, seedArray, numSteps);
}
else
{
vtkm::worklet::Streamline streamline;
vtkm::worklet::StreamlineResult res =
streamline.Run(integrator, seedArray, numSteps, DeviceAdapter());
vtkm::worklet::StreamlineResult res = streamline.Run(integrator, seedArray, numSteps);
vtkm::cont::DataSet outData;
vtkm::cont::CoordinateSystem outputCoords("coordinates", res.positions);
outData.AddCellSet(res.polyLines);

4
vtkm/cont/Algorithm.h
View File

@ -202,10 +202,6 @@ template <typename T>
struct ScanExclusiveFunctor
{
T result;
ScanExclusiveFunctor()
: result(T(0))
{
}
template <typename Device, typename... Args>
VTKM_CONT bool operator()(Device, Args&&... args)

13
vtkm/cont/CellLocatorHelper.h
View File

@ -53,9 +53,11 @@ public:
/// Builds the cell locator lookup structure
///
template <typename DeviceAdapter, typename CellSetList = VTKM_DEFAULT_CELL_SET_LIST_TAG>
void Build(DeviceAdapter device, CellSetList cellSetTypes = CellSetList())
template <typename CellSetList = VTKM_DEFAULT_CELL_SET_LIST_TAG>
void Build(CellSetList cellSetTypes = CellSetList())
{
VTKM_IS_LIST_TAG(CellSetList);
if (IsUniformGrid(this->CellSet, this->Coordinates))
{
// nothing to build for uniform grid
@ -64,7 +66,7 @@ public:
{
this->Locator.SetCellSet(this->CellSet);
this->Locator.SetCoordinates(this->Coordinates);
this->Locator.Build(device, cellSetTypes);
this->Locator.Build(cellSetTypes);
}
}
@ -124,13 +126,11 @@ public:
///
template <typename PointComponentType,
typename PointStorageType,
typename DeviceAdapter,
typename CellSetList = VTKM_DEFAULT_CELL_SET_LIST_TAG>
void FindCells(
const vtkm::cont::ArrayHandle<vtkm::Vec<PointComponentType, 3>, PointStorageType>& points,
vtkm::cont::ArrayHandle<vtkm::Id>& cellIds,
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>>& parametricCoords,
DeviceAdapter device,
CellSetList cellSetTypes = CellSetList()) const
{
if (IsUniformGrid(this->CellSet, this->Coordinates))
@ -139,12 +139,11 @@ public:
this->Coordinates.GetData().Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
auto cellset = this->CellSet.ResetCellSetList(StructuredCellSetList());
vtkm::worklet::DispatcherMapField<FindCellWorklet> dispatcher;
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(points, cellset, coordinates, cellIds, parametricCoords);
}
else
{
this->Locator.FindCells(points, cellIds, parametricCoords, device, cellSetTypes);
this->Locator.FindCells(points, cellIds, parametricCoords, cellSetTypes);
}
}

60
vtkm/cont/CellLocatorTwoLevelUniformGrid.h
View File

@ -20,11 +20,12 @@
#ifndef vtk_m_cont_CellLocatorTwoLevelUniformGrid_h
#define vtk_m_cont_CellLocatorTwoLevelUniformGrid_h
#include <vtkm/cont/Algorithm.h>
#include <vtkm/cont/ArrayCopy.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleConstant.h>
#include <vtkm/cont/ArrayHandleTransform.h>
#include <vtkm/cont/CoordinateSystem.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/exec/internal/TwoLevelUniformGridExecutionObject.h>
@ -483,11 +484,12 @@ public:
/// Builds the cell locator lookup structure
///
template <typename DeviceAdapter, typename CellSetList = VTKM_DEFAULT_CELL_SET_LIST_TAG>
void Build(DeviceAdapter, CellSetList cellSetTypes = CellSetList())
template <typename CellSetList = VTKM_DEFAULT_CELL_SET_LIST_TAG>
void Build(CellSetList cellSetTypes = CellSetList())
{
using Algorithm = vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter>;
vtkm::worklet::Invoker invoke(DeviceAdapter{});
VTKM_IS_LIST_TAG(CellSetList);
vtkm::worklet::Invoker invoke;
auto cellset = this->CellSet.ResetCellSetList(cellSetTypes);
const auto& coords = this->Coordinates;
@ -516,7 +518,7 @@ public:
invoke(countL1, cellset, coords, binCounts);
// 3: Total number of unique (cell, bin) pairs (for pre-allocating arrays)
vtkm::Id numPairsL1 = Algorithm::ScanExclusive(binCounts, binCounts);
vtkm::Id numPairsL1 = vtkm::cont::Algorithm::ScanExclusive(binCounts, binCounts);
// 4: For each cell find the top level bins that intersect it
vtkm::cont::ArrayHandle<vtkm::Id> binIds;
@ -526,28 +528,29 @@ public:
binCounts.ReleaseResources();
// 5: From above, find the number of cells that intersect each top level bin
Algorithm::Sort(binIds);
vtkm::cont::Algorithm::Sort(binIds);
vtkm::cont::ArrayHandle<vtkm::Id> bins;
vtkm::cont::ArrayHandle<vtkm::Id> cellsPerBin;
Algorithm::ReduceByKey(binIds,
vtkm::cont::make_ArrayHandleConstant(vtkm::Id(1), numPairsL1),
bins,
cellsPerBin,
vtkm::Sum());
vtkm::cont::Algorithm::ReduceByKey(
binIds,
vtkm::cont::make_ArrayHandleConstant(vtkm::Id(1), numPairsL1),
bins,
cellsPerBin,
vtkm::Sum());
binIds.ReleaseResources();
// 6: Compute level-2 dimensions
vtkm::Id numberOfBins =
ls.TopLevel.Dimensions[0] * ls.TopLevel.Dimensions[1] * ls.TopLevel.Dimensions[2];
Algorithm::Copy(vtkm::cont::make_ArrayHandleConstant(DimVec3(0), numberOfBins),
ls.LeafDimensions);
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandleConstant(DimVec3(0), numberOfBins),
ls.LeafDimensions);
GenerateBinsL1 generateL1(ls.TopLevel.BinSize, this->DensityL2);
invoke(generateL1, bins, cellsPerBin, ls.LeafDimensions);
bins.ReleaseResources();
cellsPerBin.ReleaseResources();
// 7: Compute number of level-2 bins
vtkm::Id numberOfLeaves = Algorithm::ScanExclusive(
vtkm::Id numberOfLeaves = vtkm::cont::Algorithm::ScanExclusive(
vtkm::cont::make_ArrayHandleTransform(ls.LeafDimensions, DimensionsToCount()),
ls.LeafStartIndex);
@ -557,7 +560,7 @@ public:
invoke(countL2, cellset, coords, ls.LeafDimensions, binCounts);
// 9: Total number of unique (cell, bin) pairs (for pre-allocating arrays)
vtkm::Id numPairsL2 = Algorithm::ScanExclusive(binCounts, binCounts);
vtkm::Id numPairsL2 = vtkm::cont::Algorithm::ScanExclusive(binCounts, binCounts);
// 10: For each cell, find the l2 bins they intersect
binIds.Allocate(numPairsL2);
@ -568,21 +571,23 @@ public:
binCounts.ReleaseResources();
// 11: From above, find the cells that each l2 bin intersects
Algorithm::SortByKey(binIds, ls.CellIds);
Algorithm::ReduceByKey(binIds,
vtkm::cont::make_ArrayHandleConstant(vtkm::Id(1), numPairsL2),
bins,
cellsPerBin,
vtkm::Sum());
vtkm::cont::Algorithm::SortByKey(binIds, ls.CellIds);
vtkm::cont::Algorithm::ReduceByKey(
binIds,
vtkm::cont::make_ArrayHandleConstant(vtkm::Id(1), numPairsL2),
bins,
cellsPerBin,
vtkm::Sum());
binIds.ReleaseResources();
// 12: Generate the leaf bin arrays
vtkm::cont::ArrayHandle<vtkm::Id> cellsStart;
Algorithm::ScanExclusive(cellsPerBin, cellsStart);
vtkm::cont::Algorithm::ScanExclusive(cellsPerBin, cellsStart);
Algorithm::Copy(vtkm::cont::ArrayHandleConstant<vtkm::Id>(0, numberOfLeaves),
ls.CellStartIndex);
Algorithm::Copy(vtkm::cont::ArrayHandleConstant<vtkm::Id>(0, numberOfLeaves), ls.CellCount);
vtkm::cont::ArrayCopy(vtkm::cont::ArrayHandleConstant<vtkm::Id>(0, numberOfLeaves),
ls.CellStartIndex);
vtkm::cont::ArrayCopy(vtkm::cont::ArrayHandleConstant<vtkm::Id>(0, numberOfLeaves),
ls.CellCount);
invoke(GenerateBinsL2{}, bins, cellsStart, cellsPerBin, ls.CellStartIndex, ls.CellCount);
std::swap(this->LookupStructure, ls);
@ -694,17 +699,14 @@ public:
///
template <typename PointComponentType,
typename PointStorageType,
typename DeviceAdapter,
typename CellSetList = VTKM_DEFAULT_CELL_SET_LIST_TAG>
void FindCells(
const vtkm::cont::ArrayHandle<vtkm::Vec<PointComponentType, 3>, PointStorageType>& points,
vtkm::cont::ArrayHandle<vtkm::Id>& cellIds,
vtkm::cont::ArrayHandle<FloatVec3>& parametricCoords,
DeviceAdapter,
CellSetList cellSetTypes = CellSetList()) const
{
vtkm::worklet::DispatcherMapField<FindCellWorklet> dispatcher;
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(points,
this->CellSet.ResetCellSetList(cellSetTypes),
this->Coordinates,

67
vtkm/cont/ImplicitFunctionHandle.h
View File

@ -72,6 +72,73 @@ VTKM_CONT ImplicitFunctionHandle make_ImplicitFunctionHandle(Args&&... args)
return ImplicitFunctionHandle(
new ImplicitFunctionType(std::forward<Args>(args)...), true, DeviceAdapterList());
}
//============================================================================
/// A helpful wrapper that returns a functor that calls the (virtual) value method of a given
/// ImplicitFunction. Can be passed to things that expect a functor instead of an ImplictFunction
/// class (like an array transform).
///
class VTKM_ALWAYS_EXPORT ImplicitFunctionValueHandle
: public vtkm::cont::ExecutionAndControlObjectBase
{
vtkm::cont::ImplicitFunctionHandle Handle;
public:
ImplicitFunctionValueHandle() = default;
ImplicitFunctionValueHandle(const ImplicitFunctionHandle& handle)
: Handle(handle)
{
}
template <typename ImplicitFunctionType,
typename DeviceAdapterList = VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG>
explicit ImplicitFunctionValueHandle(ImplicitFunctionType* function,
bool acquireOwnership = true,
DeviceAdapterList devices = DeviceAdapterList())
: Handle(function, acquireOwnership, devices)
{
}
VTKM_CONT const vtkm::cont::ImplicitFunctionHandle& GetHandle() const { return this->Handle; }
VTKM_CONT
vtkm::ImplicitFunctionValue PrepareForExecution(vtkm::cont::DeviceAdapterId device) const
{
return vtkm::ImplicitFunctionValue(this->Handle.PrepareForExecution(device));
}
VTKM_CONT vtkm::ImplicitFunctionValue PrepareForControl() const
{
return vtkm::ImplicitFunctionValue(this->Handle.PrepareForControl());
}
};
template <typename ImplicitFunctionType,
typename DeviceAdapterList = VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG>
VTKM_CONT ImplicitFunctionValueHandle
make_ImplicitFunctionValueHandle(ImplicitFunctionType&& func,
DeviceAdapterList devices = DeviceAdapterList())
{
using IFType = typename std::remove_reference<ImplicitFunctionType>::type;
return ImplicitFunctionValueHandle(
new IFType(std::forward<ImplicitFunctionType>(func)), true, devices);
}
template <typename ImplicitFunctionType, typename... Args>
VTKM_CONT ImplicitFunctionValueHandle make_ImplicitFunctionValueHandle(Args&&... args)
{
return ImplicitFunctionValueHandle(new ImplicitFunctionType(std::forward<Args>(args)...),
true,
VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG());
}
template <typename ImplicitFunctionType, typename DeviceAdapterList, typename... Args>
VTKM_CONT ImplicitFunctionValueHandle make_ImplicitFunctionValueHandle(Args&&... args)
{
return ImplicitFunctionValueHandle(
new ImplicitFunctionType(std::forward<Args>(args)...), true, DeviceAdapterList());
}
}
} // vtkm::cont

6
vtkm/cont/VirtualObjectHandle.h
View File

@ -21,6 +21,7 @@
#define vtk_m_cont_VirtualObjectHandle_h
#include <vtkm/cont/DeviceAdapterListTag.h>
#include <vtkm/cont/ExecutionAndControlObjectBase.h>
#include <vtkm/cont/internal/DeviceAdapterListHelpers.h>
#include <vtkm/cont/internal/VirtualObjectTransfer.h>
@ -68,7 +69,7 @@ struct CreateTransferInterface
/// \sa vtkm::VirtualObjectBase
///
template <typename VirtualBaseType>
class VTKM_ALWAYS_EXPORT VirtualObjectHandle
class VTKM_ALWAYS_EXPORT VirtualObjectHandle : public vtkm::cont::ExecutionAndControlObjectBase
{
VTKM_STATIC_ASSERT_MSG((std::is_base_of<vtkm::VirtualObjectBase, VirtualBaseType>::value),
"All virtual objects must be subclass of vtkm::VirtualObjectBase.");
@ -154,6 +155,9 @@ public:
return static_cast<const VirtualBaseType*>(this->Internals->PrepareForExecution(deviceId));
}
/// Used as part of the \c ExecutionAndControlObjectBase interface. Returns the same pointer
/// as \c Get.
VTKM_CONT const VirtualBaseType* PrepareForControl() const { return this->Get(); }
private:
std::shared_ptr<internal::TransferState> Internals;

35
vtkm/cont/testing/TestingCellLocatorTwoLevelUniformGrid.h
View File

@ -20,6 +20,7 @@
#ifndef vtk_m_cont_testing_TestingCellLocatorTwoLevelUniformGrid_h
#define vtk_m_cont_testing_TestingCellLocatorTwoLevelUniformGrid_h
#include <vtkm/cont/ArrayCopy.h>
#include <vtkm/cont/CellLocatorTwoLevelUniformGrid.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/testing/Testing.h>
@ -71,11 +72,9 @@ public:
}
};
template <vtkm::IdComponent DIMENSIONS, typename DeviceAdapter>
vtkm::cont::DataSet MakeTestDataSet(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dims,
DeviceAdapter device)
template <vtkm::IdComponent DIMENSIONS>
vtkm::cont::DataSet MakeTestDataSet(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dims)
{
using Algorithm = vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter>;
using Connectivity = vtkm::internal::ConnectivityStructuredInternals<DIMENSIONS>;
const vtkm::IdComponent PointsPerCell = 1 << DIMENSIONS;
@ -87,7 +86,7 @@ vtkm::cont::DataSet MakeTestDataSet(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dims,
// copy points
vtkm::cont::ArrayHandle<PointType> points;
Algorithm::Copy(uniformDs.GetCoordinateSystem().GetData(), points);
vtkm::cont::ArrayCopy(uniformDs.GetCoordinateSystem().GetData(), points);
vtkm::Id numberOfCells = uniformDs.GetCellSet().GetNumberOfCells();
vtkm::Id numberOfIndices = numberOfCells * PointsPerCell;
@ -115,7 +114,7 @@ vtkm::cont::DataSet MakeTestDataSet(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dims,
switch (DIMENSIONS)
{
case 2:
cellset = vtkm::worklet::Triangulate().Run(uniformCs, device);
cellset = vtkm::worklet::Triangulate().Run(uniformCs);
break;
case 3:
cellset = vtkm::worklet::Tetrahedralize().Run(uniformCs);
@ -148,7 +147,7 @@ vtkm::cont::DataSet MakeTestDataSet(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dims,
return out;
}
template <vtkm::IdComponent DIMENSIONS, typename DeviceAdapter>
template <vtkm::IdComponent DIMENSIONS>
void GenerateRandomInput(const vtkm::cont::DataSet& ds,
vtkm::Id count,
vtkm::cont::ArrayHandle<vtkm::Id>& cellIds,
@ -183,16 +182,13 @@ void GenerateRandomInput(const vtkm::cont::DataSet& ds,
vtkm::worklet::DispatcherMapTopology<ParametricToWorldCoordinates> dispatcher(
ParametricToWorldCoordinates::MakeScatter(cellIds));
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(ds.GetCellSet(), ds.GetCoordinateSystem().GetData(), pcoords, wcoords);
}
template <vtkm::IdComponent DIMENSIONS, typename DeviceAdapter>
void TestCellLocator(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dim,
vtkm::Id numberOfPoints,
DeviceAdapter device)
template <vtkm::IdComponent DIMENSIONS>
void TestCellLocator(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dim, vtkm::Id numberOfPoints)
{
auto ds = MakeTestDataSet(dim, device);
auto ds = MakeTestDataSet(dim);
std::cout << "Testing " << DIMENSIONS << "D dataset with " << ds.GetCellSet().GetNumberOfCells()
<< " cells\n";
@ -202,18 +198,17 @@ void TestCellLocator(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dim,
locator.SetDensityL2(1.0f);
locator.SetCellSet(ds.GetCellSet());
locator.SetCoordinates(ds.GetCoordinateSystem());
locator.Build(device);
locator.Build();
vtkm::cont::ArrayHandle<vtkm::Id> expCellIds;
vtkm::cont::ArrayHandle<PointType> expPCoords;
vtkm::cont::ArrayHandle<PointType> points;
GenerateRandomInput<DIMENSIONS, DeviceAdapter>(
ds, numberOfPoints, expCellIds, expPCoords, points);
GenerateRandomInput<DIMENSIONS>(ds, numberOfPoints, expCellIds, expPCoords, points);
std::cout << "Finding cells for " << numberOfPoints << " points\n";
vtkm::cont::ArrayHandle<vtkm::Id> cellIds;
vtkm::cont::ArrayHandle<PointType> pcoords;
locator.FindCells(points, cellIds, pcoords, device);
locator.FindCells(points, cellIds, pcoords);
for (vtkm::Id i = 0; i < numberOfPoints; ++i)
{
@ -232,12 +227,14 @@ void TestCellLocator(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dim,
template <typename DeviceAdapter>
void TestingCellLocatorTwoLevelUniformGrid()
{
vtkm::cont::GetGlobalRuntimeDeviceTracker().ForceDevice(DeviceAdapter());
vtkm::UInt32 seed = static_cast<vtkm::UInt32>(std::time(nullptr));
std::cout << "Seed: " << seed << std::endl;
RandomGenerator.seed(seed);
TestCellLocator(vtkm::Id3(8), 512, DeviceAdapter()); // 3D dataset
TestCellLocator(vtkm::Id2(18), 512, DeviceAdapter()); // 2D dataset
TestCellLocator(vtkm::Id3(8), 512); // 3D dataset
TestCellLocator(vtkm::Id2(18), 512); // 2D dataset
}
#endif // vtk_m_cont_testing_TestingCellLocatorTwoLevelUniformGrid_h

6
vtkm/cont/testing/UnitTestCellLocator.cxx
View File

@ -27,7 +27,6 @@ namespace
void TestCellLocator()
{
using PointType = vtkm::Vec<vtkm::FloatDefault, 3>;
VTKM_DEFAULT_DEVICE_ADAPTER_TAG device;
const vtkm::Id SIZE = 4;
auto ds =
@ -36,7 +35,7 @@ void TestCellLocator()
vtkm::cont::CellLocatorHelper locator;
locator.SetCellSet(ds.GetCellSet());
locator.SetCoordinates(ds.GetCoordinateSystem());
locator.Build(device);
locator.Build();
PointType points[] = {
{ 0.25, 0.25, 0.25 }, { 1.25, 1.25, 1.25 }, { 2.25, 2.25, 2.25 }, { 3.25, 3.25, 3.25 }
@ -44,7 +43,7 @@ void TestCellLocator()
vtkm::cont::ArrayHandle<vtkm::Id> cellIds;
vtkm::cont::ArrayHandle<PointType> parametricCoords;
locator.FindCells(vtkm::cont::make_ArrayHandle(points, 4), cellIds, parametricCoords, device);
locator.FindCells(vtkm::cont::make_ArrayHandle(points, 4), cellIds, parametricCoords);
const vtkm::Id NCELLS_PER_AXIS = SIZE - 1;
const vtkm::Id DIA_STRIDE = (NCELLS_PER_AXIS * NCELLS_PER_AXIS) + NCELLS_PER_AXIS + 1;
@ -62,5 +61,6 @@ void TestCellLocator()
int UnitTestCellLocator(int, char* [])
{
vtkm::cont::GetGlobalRuntimeDeviceTracker().ForceDevice(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
return vtkm::cont::testing::Testing::Run(TestCellLocator);
}

5
vtkm/filter/CellAverage.h
View File

@ -41,12 +41,11 @@ public:
VTKM_CONT
CellAverage();
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
vtkm::worklet::CellAverage Worklet;

6
vtkm/filter/CellAverage.hxx
View File

@ -36,13 +36,12 @@ inline VTKM_CONT CellAverage::CellAverage()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet CellAverage::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
if (!fieldMetadata.IsPointField())
{
@ -56,7 +55,6 @@ inline VTKM_CONT vtkm::cont::DataSet CellAverage::DoExecute(
vtkm::cont::ArrayHandle<T> outArray;
vtkm::worklet::DispatcherMapTopology<vtkm::worklet::CellAverage> dispatcher(this->Worklet);
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(vtkm::filter::ApplyPolicy(cellSet, policy), inField, outArray);

5
vtkm/filter/CellMeasures.h
View File

@ -47,13 +47,12 @@ public:
void SetCellMeasureName(const std::string& name) { this->SetOutputFieldName(name); }
const std::string& GetCellMeasureName() const { return this->GetOutputFieldName(); }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& points,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
};
template <typename IntegrationType>

6
vtkm/filter/CellMeasures.hxx
View File

@ -38,20 +38,18 @@ inline VTKM_CONT CellMeasures<IntegrationType>::CellMeasures()
//-----------------------------------------------------------------------------
template <typename IntegrationType>
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet CellMeasures<IntegrationType>::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& points,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
VTKM_ASSERT(fieldMeta.IsPointField());
const auto& cellset = input.GetCellSet(this->GetActiveCellSetIndex());
vtkm::cont::ArrayHandle<T> outArray;
vtkm::worklet::DispatcherMapTopology<vtkm::worklet::CellMeasure<IntegrationType>> dispatcher;
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(vtkm::filter::ApplyPolicy(cellset, policy), points, outArray);
vtkm::cont::DataSet result;

15
vtkm/filter/CleanGrid.h
View File

@ -57,22 +57,19 @@ public:
VTKM_CONT
void SetCompactPointFields(bool flag) { this->CompactPointFields = flag; }
template <typename Policy, typename Device>
template <typename Policy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy,
Device);
vtkm::filter::PolicyBase<Policy> policy);
template <typename ValueType, typename Storage, typename Policy, typename Device>
template <typename ValueType, typename Storage, typename Policy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<ValueType, Storage>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<Policy>,
Device);
vtkm::filter::PolicyBase<Policy>);
template <typename ValueType, typename Storage, typename Device>
template <typename ValueType, typename Storage>
VTKM_CONT vtkm::cont::ArrayHandle<ValueType> MapPointField(
const vtkm::cont::ArrayHandle<ValueType, Storage>& inArray,
Device) const;
const vtkm::cont::ArrayHandle<ValueType, Storage>& inArray) const;
private:
bool CompactPointFields;

36
vtkm/filter/CleanGrid.hxx
View File

@ -33,13 +33,10 @@ inline VTKM_CONT CleanGrid::CleanGrid()
{
}
template <typename Policy, typename Device>
template <typename Policy>
inline VTKM_CONT vtkm::cont::DataSet CleanGrid::DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy,
Device)
vtkm::filter::PolicyBase<Policy> policy)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
using CellSetType = vtkm::cont::CellSetExplicit<>;
using VecId = std::vector<CellSetType>::size_type;
@ -53,24 +50,23 @@ inline VTKM_CONT vtkm::cont::DataSet CleanGrid::DoExecute(const vtkm::cont::Data
vtkm::cont::DynamicCellSet inCellSet =
inData.GetCellSet(static_cast<vtkm::IdComponent>(cellSetIndex));
vtkm::worklet::CellDeepCopy::Run(
vtkm::filter::ApplyPolicy(inCellSet, policy), outputCellSets[cellSetIndex], Device());
vtkm::worklet::CellDeepCopy::Run(vtkm::filter::ApplyPolicy(inCellSet, policy),
outputCellSets[cellSetIndex]);
}
// Optionally adjust the cell set indices to remove all unused points
if (this->GetCompactPointFields())
{
this->PointCompactor.FindPointsStart(Device());
this->PointCompactor.FindPointsStart();
for (VecId cellSetIndex = 0; cellSetIndex < numCellSets; cellSetIndex++)
{
this->PointCompactor.FindPoints(outputCellSets[cellSetIndex], Device());
this->PointCompactor.FindPoints(outputCellSets[cellSetIndex]);
}
this->PointCompactor.FindPointsEnd(Device());
this->PointCompactor.FindPointsEnd();
for (VecId cellSetIndex = 0; cellSetIndex < numCellSets; cellSetIndex++)
{
outputCellSets[cellSetIndex] =
this->PointCompactor.MapCellSet(outputCellSets[cellSetIndex], Device());
outputCellSets[cellSetIndex] = this->PointCompactor.MapCellSet(outputCellSets[cellSetIndex]);
}
}
@ -96,7 +92,7 @@ inline VTKM_CONT vtkm::cont::DataSet CleanGrid::DoExecute(const vtkm::cont::Data
if (this->GetCompactPointFields())
{
auto outArray = this->MapPointField(coordSystem.GetData(), Device());
auto outArray = this->MapPointField(coordSystem.GetData());
outData.AddCoordinateSystem(vtkm::cont::CoordinateSystem(coordSystem.GetName(), outArray));
}
else
@ -108,17 +104,16 @@ inline VTKM_CONT vtkm::cont::DataSet CleanGrid::DoExecute(const vtkm::cont::Data
return outData;
}
template <typename ValueType, typename Storage, typename Policy, typename Device>
template <typename ValueType, typename Storage, typename Policy>
inline VTKM_CONT bool CleanGrid::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<ValueType, Storage>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<Policy>,
Device)
vtkm::filter::PolicyBase<Policy>)
{
if (this->GetCompactPointFields() && fieldMeta.IsPointField())
{
vtkm::cont::ArrayHandle<ValueType> compactedArray = this->MapPointField(input, Device());
vtkm::cont::ArrayHandle<ValueType> compactedArray = this->MapPointField(input);
result.AddField(fieldMeta.AsField(compactedArray));
}
else
@ -129,14 +124,13 @@ inline VTKM_CONT bool CleanGrid::DoMapField(
return true;
}
template <typename ValueType, typename Storage, typename Device>
template <typename ValueType, typename Storage>
inline VTKM_CONT vtkm::cont::ArrayHandle<ValueType> CleanGrid::MapPointField(
const vtkm::cont::ArrayHandle<ValueType, Storage>& inArray,
Device) const
const vtkm::cont::ArrayHandle<ValueType, Storage>& inArray) const
{
VTKM_ASSERT(this->GetCompactPointFields());
return this->PointCompactor.MapPointFieldDeep(inArray, Device());
return this->PointCompactor.MapPointFieldDeep(inArray);
}
}
}

10
vtkm/filter/ClipWithField.h
View File

@ -49,21 +49,19 @@ public:
VTKM_CONT
vtkm::Float64 GetClipValue() const { return this->ClipValue; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter.
//This call is only valid after Execute has been called.
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::Float64 ClipValue;

21
vtkm/filter/ClipWithField.hxx
View File

@ -34,7 +34,6 @@ namespace filter
namespace clipwithfield
{
template <typename Device>
struct PointMapHelper
{
PointMapHelper(const vtkm::worklet::Clip& worklet, vtkm::cont::DynamicArrayHandle& output)
@ -46,7 +45,7 @@ struct PointMapHelper
template <typename ArrayType>
void operator()(const ArrayType& array) const
{
this->Output = this->Worklet.ProcessPointField(array, Device());
this->Output = this->Worklet.ProcessPointField(array);
}
const vtkm::worklet::Clip& Worklet;
@ -65,13 +64,12 @@ inline VTKM_CONT ClipWithField::ClipWithField()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet ClipWithField::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
using namespace clipwithfield;
@ -87,37 +85,36 @@ inline VTKM_CONT vtkm::cont::DataSet ClipWithField::DoExecute(
input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex());
vtkm::cont::CellSetExplicit<> outputCellSet = this->Worklet.Run(
vtkm::filter::ApplyPolicy(cells, policy), field, this->ClipValue, this->Invert, device);
vtkm::filter::ApplyPolicy(cells, policy), field, this->ClipValue, this->Invert);
//create the output data
vtkm::cont::DataSet output;
output.AddCellSet(outputCellSet);
// Compute the new boundary points and add them to the output:
auto outputCoordsArray = this->Worklet.ProcessPointField(inputCoords.GetData(), device);
auto outputCoordsArray = this->Worklet.ProcessPointField(inputCoords.GetData());
vtkm::cont::CoordinateSystem outputCoords(inputCoords.GetName(), outputCoordsArray);
output.AddCoordinateSystem(outputCoords);
return output;
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool ClipWithField::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
vtkm::cont::ArrayHandle<T> output;
if (fieldMeta.IsPointField())
{
output = this->Worklet.ProcessPointField(input, device);
output = this->Worklet.ProcessPointField(input);
}
else if (fieldMeta.IsCellField())
{
output = this->Worklet.ProcessCellField(input, device);
output = this->Worklet.ProcessCellField(input);
}
else
{

10
vtkm/filter/ClipWithImplicitFunction.h
View File

@ -49,19 +49,17 @@ public:
const vtkm::cont::ImplicitFunctionHandle& GetImplicitFunction() const { return this->Function; }
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
//Map a new field onto the resulting dataset after running the filter.
//This call is only valid after Execute has been called.
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
vtkm::cont::ImplicitFunctionHandle Function;

21
vtkm/filter/ClipWithImplicitFunction.hxx
View File

@ -32,7 +32,6 @@ namespace filter
namespace clipwithimplicitfunction
{
template <typename Device>
struct PointMapHelper
{
PointMapHelper(const vtkm::worklet::Clip& worklet, vtkm::cont::DynamicArrayHandle& output)
@ -44,7 +43,7 @@ struct PointMapHelper
template <typename ArrayType>
void operator()(const ArrayType& array) const
{
this->Output = this->Worklet.ProcessPointField(array, Device());
this->Output = this->Worklet.ProcessPointField(array);
}
const vtkm::worklet::Clip& Worklet;
@ -60,11 +59,10 @@ ClipWithImplicitFunction::ClipWithImplicitFunction()
{
}
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
inline vtkm::cont::DataSet ClipWithImplicitFunction::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
using namespace clipwithimplicitfunction;
@ -75,10 +73,10 @@ inline vtkm::cont::DataSet ClipWithImplicitFunction::DoExecute(
input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex());
vtkm::cont::CellSetExplicit<> outputCellSet = this->Worklet.Run(
vtkm::filter::ApplyPolicy(cells, policy), this->Function, inputCoords, this->Invert, device);
vtkm::filter::ApplyPolicy(cells, policy), this->Function, inputCoords, this->Invert);
// compute output coordinates
auto outputCoordsArray = this->Worklet.ProcessPointField(inputCoords.GetData(), device);
auto outputCoordsArray = this->Worklet.ProcessPointField(inputCoords.GetData());
vtkm::cont::CoordinateSystem outputCoords(inputCoords.GetName(), outputCoordsArray);
//create the output data
@ -90,23 +88,22 @@ inline vtkm::cont::DataSet ClipWithImplicitFunction::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline bool ClipWithImplicitFunction::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
vtkm::cont::ArrayHandle<T> output;
if (fieldMeta.IsPointField())
{
output = this->Worklet.ProcessPointField(input, device);
output = this->Worklet.ProcessPointField(input);
}
else if (fieldMeta.IsCellField())
{
output = this->Worklet.ProcessCellField(input, device);
output = this->Worklet.ProcessCellField(input);
}
else
{

10
vtkm/filter/ContourTreeUniform.h
View File

@ -87,12 +87,11 @@ public:
ContourTreeMesh2D();
/// Output field
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
};
template <>
@ -115,12 +114,11 @@ public:
ContourTreeMesh3D();
/// Output field "saddlePeak" which is pairs of vertex ids indicating saddle and peak of contour
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
};
template <>

14
vtkm/filter/ContourTreeUniform.hxx
View File

@ -81,13 +81,12 @@ ContourTreeMesh2D::ContourTreeMesh2D()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
vtkm::cont::DataSet ContourTreeMesh2D::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
if (fieldMeta.IsPointField() == false)
{
@ -108,7 +107,7 @@ vtkm::cont::DataSet ContourTreeMesh2D::DoExecute(
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
vtkm::worklet::ContourTreeMesh2D worklet;
worklet.Run(field, nRows, nCols, saddlePeak, device);
worklet.Run(field, nRows, nCols, saddlePeak);
return internal::CreateResult(input,
saddlePeak,
@ -123,13 +122,12 @@ ContourTreeMesh3D::ContourTreeMesh3D()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
vtkm::cont::DataSet ContourTreeMesh3D::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
if (fieldMeta.IsPointField() == false)
{
@ -151,7 +149,7 @@ vtkm::cont::DataSet ContourTreeMesh3D::DoExecute(
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
vtkm::worklet::ContourTreeMesh3D worklet;
worklet.Run(field, nRows, nCols, nSlices, saddlePeak, device);
worklet.Run(field, nRows, nCols, nSlices, saddlePeak);
return internal::CreateResult(input,
saddlePeak,

5
vtkm/filter/ContourTreeUniformAugmented.h
View File

@ -86,12 +86,11 @@ public:
ContourTreePPP2(bool useMarchingCubes = false, bool computeRegularStructure = true);
// Output field "saddlePeak" which is pairs of vertex ids indicating saddle and peak of contour
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
const vtkm::worklet::contourtree_augmented::ContourTree& GetContourTree() const;
const vtkm::worklet::contourtree_augmented::IdArrayType& GetSortOrder() const;

17
vtkm/filter/ContourTreeUniformAugmented.hxx
View File

@ -62,6 +62,7 @@
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/filter/ContourTreeUniformAugmented.h>
#include <vtkm/filter/internal/CreateResult.h>
#include <vtkm/worklet/ContourTreeUniformAugmented.h>
@ -100,16 +101,15 @@ const std::vector<std::pair<std::string, vtkm::Float64>>& ContourTreePPP2::GetTi
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
vtkm::cont::DataSet ContourTreePPP2::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
template <typename T, typename StorageType, typename DerivedPolicy>
vtkm::cont::DataSet ContourTreePPP2::DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// TODO: This should be switched to use the logging macros defined in vtkm/cont/logging.h
// Start the timer
vtkm::cont::Timer<DeviceAdapter> timer;
vtkm::cont::Timer<> timer;
Timings.clear();
// Check that the field is Ok
@ -132,7 +132,6 @@ vtkm::cont::DataSet ContourTreePPP2::DoExecute(
this->ContourTreeData,
this->MeshSortOrder,
this->NumIterations,
device,
nRows,
nCols,
nSlices,

17
vtkm/filter/CoordinateSystemTransform.h
View File

@ -41,12 +41,11 @@ public:
VTKM_CONT void SetCartesianToCylindrical() { Worklet.SetCartesianToCylindrical(); }
VTKM_CONT void SetCylindricalToCartesian() { Worklet.SetCylindricalToCartesian(); }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
vtkm::worklet::CylindricalCoordinateTransform Worklet;
@ -69,12 +68,12 @@ public:
VTKM_CONT void SetCartesianToSpherical() { Worklet.SetCartesianToSpherical(); }
VTKM_CONT void SetSphericalToCartesian() { Worklet.SetSphericalToCartesian(); }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag) const;
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy) const;
private:
vtkm::worklet::SphericalCoordinateTransform Worklet;

14
vtkm/filter/CoordinateSystemTransform.hxx
View File

@ -34,16 +34,15 @@ inline VTKM_CONT CylindricalCoordinateTransform::CylindricalCoordinateTransform(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet CylindricalCoordinateTransform::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
vtkm::cont::ArrayHandle<T> outArray;
Worklet.Run(field, outArray, device);
this->Worklet.Run(field, outArray);
return internal::CreateResult(inDataSet,
outArray,
this->GetOutputFieldName(),
@ -59,16 +58,15 @@ inline VTKM_CONT SphericalCoordinateTransform::SphericalCoordinateTransform()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet SphericalCoordinateTransform::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device) const
const vtkm::filter::PolicyBase<DerivedPolicy>&) const
{
vtkm::cont::ArrayHandle<T> outArray;
Worklet.Run(field, outArray, device);
Worklet.Run(field, outArray);
return internal::CreateResult(inDataSet,
outArray,
this->GetOutputFieldName(),

10
vtkm/filter/CrossProduct.h
View File

@ -129,20 +129,18 @@ public:
}
//@}
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
std::string SecondaryFieldName;

15
vtkm/filter/CrossProduct.hxx
View File

@ -30,7 +30,7 @@ namespace filter
namespace detail
{
template <typename T, typename DeviceAdapter>
template <typename T>
struct CrossProductFunctor
{
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> OutArray;
@ -39,7 +39,6 @@ struct CrossProductFunctor
void operator()(const SecondaryFieldType& secondaryField, const PrimaryFieldType& primaryField)
{
vtkm::worklet::DispatcherMapField<vtkm::worklet::CrossProduct> dispatcher;
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(primaryField,
vtkm::cont::make_ArrayHandleCast<vtkm::Vec<T, 3>>(secondaryField),
this->OutArray);
@ -60,15 +59,14 @@ inline VTKM_CONT CrossProduct::CrossProduct()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet CrossProduct::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
detail::CrossProductFunctor<T, DeviceAdapter> functor;
detail::CrossProductFunctor<T> functor;
try
{
if (this->UseCoordinateSystemAsSecondaryField)
@ -102,12 +100,11 @@ inline VTKM_CONT vtkm::cont::DataSet CrossProduct::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool CrossProduct::DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
DeviceAdapter)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
//we copy the input handle to the result dataset, reusing the metadata
result.AddField(fieldMeta.AsField(input));

10
vtkm/filter/DotProduct.h
View File

@ -129,20 +129,18 @@ public:
}
//@}
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
std::string SecondaryFieldName;

15
vtkm/filter/DotProduct.hxx
View File

@ -31,7 +31,7 @@ namespace filter
namespace detail
{
template <typename T, typename DeviceAdapter>
template <typename T>
struct DotProductFunctor
{
vtkm::cont::ArrayHandle<T> OutArray;
@ -40,7 +40,6 @@ struct DotProductFunctor
void operator()(const SecondaryFieldType& secondaryField, const PrimaryFieldType& primaryField)
{
vtkm::worklet::DispatcherMapField<vtkm::worklet::DotProduct> dispatcher;
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(primaryField,
vtkm::cont::make_ArrayHandleCast<vtkm::Vec<T, 3>>(secondaryField),
this->OutArray);
@ -61,15 +60,14 @@ inline VTKM_CONT DotProduct::DotProduct()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet DotProduct::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
detail::DotProductFunctor<T, DeviceAdapter> functor;
detail::DotProductFunctor<T> functor;
try
{
if (this->UseCoordinateSystemAsSecondaryField)
@ -102,12 +100,11 @@ inline VTKM_CONT vtkm::cont::DataSet DotProduct::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool DotProduct::DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
DeviceAdapter)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
//we copy the input handle to the result dataset, reusing the metadata
result.AddField(fieldMeta.AsField(input));

5
vtkm/filter/Entropy.h
View File

@ -42,12 +42,11 @@ public:
VTKM_CONT
void SetNumberOfBins(vtkm::Id count) { this->NumberOfBins = count; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
vtkm::Id NumberOfBins;

7
vtkm/filter/Entropy.hxx
View File

@ -36,17 +36,16 @@ inline VTKM_CONT Entropy::Entropy()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Entropy::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
vtkm::worklet::FieldEntropy worklet;
vtkm::Float64 e = worklet.Run(field, this->NumberOfBins, device);
vtkm::Float64 e = worklet.Run(field, this->NumberOfBins);
//the entropy vector only contain one element, the entorpy of the input field
vtkm::cont::ArrayHandle<vtkm::Float64> entropy;

10
vtkm/filter/ExternalFaces.h
View File

@ -63,19 +63,17 @@ public:
this->Worklet.SetPassPolyData(value);
}
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
public:
bool CompactPoints;

22
vtkm/filter/ExternalFaces.hxx
View File

@ -51,11 +51,10 @@ inline vtkm::filter::PolicyBase<CellSetExplicitPolicy<DerivedPolicy>> GetCellSet
} // anonymous namespace
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet ExternalFaces::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
//1. extract the cell set
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
@ -68,13 +67,11 @@ inline VTKM_CONT vtkm::cont::DataSet ExternalFaces::DoExecute(
{
this->Worklet.Run(cells.Cast<vtkm::cont::CellSetStructured<3>>(),
input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex()),
outCellSet,
DeviceAdapter());
outCellSet);
}
else
{
this->Worklet.Run(
vtkm::filter::ApplyPolicyUnstructured(cells, policy), outCellSet, DeviceAdapter());
this->Worklet.Run(vtkm::filter::ApplyPolicyUnstructured(cells, policy), outCellSet);
}
//3. Check the fields of the dataset to see what kinds of fields are present so
@ -103,7 +100,7 @@ inline VTKM_CONT vtkm::cont::DataSet ExternalFaces::DoExecute(
if (this->CompactPoints)
{
this->Compactor.SetCompactPointFields(true);
return this->Compactor.DoExecute(output, GetCellSetExplicitPolicy(policy), DeviceAdapter());
return this->Compactor.DoExecute(output, GetCellSetExplicitPolicy(policy));
}
else
{
@ -112,19 +109,18 @@ inline VTKM_CONT vtkm::cont::DataSet ExternalFaces::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool ExternalFaces::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
if (fieldMeta.IsPointField())
{
if (this->CompactPoints)
{
return this->Compactor.DoMapField(result, input, fieldMeta, policy, DeviceAdapter());
return this->Compactor.DoMapField(result, input, fieldMeta, policy);
}
else
{
@ -135,7 +131,7 @@ inline VTKM_CONT bool ExternalFaces::DoMapField(
else if (fieldMeta.IsCellField())
{
vtkm::cont::ArrayHandle<T> fieldArray;
fieldArray = this->Worklet.ProcessCellField(input, device);
fieldArray = this->Worklet.ProcessCellField(input);
result.AddField(fieldMeta.AsField(fieldArray));
return true;
}

10
vtkm/filter/ExtractGeometry.h
View File

@ -86,18 +86,16 @@ public:
VTKM_CONT
void ExtractOnlyBoundaryCellsOff() { this->ExtractOnlyBoundaryCells = false; }
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
//Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
bool ExtractInside;

30
vtkm/filter/ExtractGeometry.hxx
View File

@ -28,7 +28,6 @@
namespace
{
template <typename DeviceTag>
struct CallWorker
{
vtkm::cont::DynamicCellSet& Output;
@ -64,8 +63,7 @@ struct CallWorker
this->Function,
this->ExtractInside,
this->ExtractBoundaryCells,
this->ExtractOnlyBoundaryCells,
DeviceTag());
this->ExtractOnlyBoundaryCells);
}
};
@ -86,11 +84,10 @@ inline VTKM_CONT ExtractGeometry::ExtractGeometry()
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet ExtractGeometry::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
// extract the input cell set and coordinates
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
@ -98,13 +95,13 @@ inline VTKM_CONT vtkm::cont::DataSet ExtractGeometry::DoExecute(
input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex());
vtkm::cont::DynamicCellSet outCells;
CallWorker<DeviceAdapter> worker(outCells,
this->Worklet,
coords,
this->Function,
this->ExtractInside,
this->ExtractBoundaryCells,
this->ExtractOnlyBoundaryCells);
CallWorker worker(outCells,
this->Worklet,
coords,
this->Function,
this->ExtractInside,
this->ExtractBoundaryCells,
this->ExtractOnlyBoundaryCells);
vtkm::filter::ApplyPolicy(cells, policy).CastAndCall(worker);
// create the output dataset
@ -115,13 +112,12 @@ inline VTKM_CONT vtkm::cont::DataSet ExtractGeometry::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool ExtractGeometry::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
vtkm::cont::DynamicArrayHandle output;
@ -131,7 +127,7 @@ inline VTKM_CONT bool ExtractGeometry::DoMapField(
}
else if (fieldMeta.IsCellField())
{
output = this->Worklet.ProcessCellField(input, device);
output = this->Worklet.ProcessCellField(input);
}
else
{

10
vtkm/filter/ExtractPoints.h
View File

@ -69,18 +69,16 @@ public:
VTKM_CONT
void ExtractInsideOff() { this->ExtractInside = false; }
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
bool ExtractInside;

20
vtkm/filter/ExtractPoints.hxx
View File

@ -53,11 +53,9 @@ inline VTKM_CONT ExtractPoints::ExtractPoints()
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline vtkm::cont::DataSet ExtractPoints::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
template <typename DerivedPolicy>
inline vtkm::cont::DataSet ExtractPoints::DoExecute(const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// extract the input cell set and coordinates
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
@ -71,8 +69,7 @@ inline vtkm::cont::DataSet ExtractPoints::DoExecute(
outCellSet = worklet.Run(vtkm::filter::ApplyPolicy(cells, policy),
coords.GetData(),
this->Function,
this->ExtractInside,
device);
this->ExtractInside);
// create the output dataset
vtkm::cont::DataSet output;
@ -83,7 +80,7 @@ inline vtkm::cont::DataSet ExtractPoints::DoExecute(
if (this->CompactPoints)
{
this->Compactor.SetCompactPointFields(true);
return this->Compactor.DoExecute(output, GetCellSetSingleTypePolicy(policy), DeviceAdapter());
return this->Compactor.DoExecute(output, GetCellSetSingleTypePolicy(policy));
}
else
{
@ -92,20 +89,19 @@ inline vtkm::cont::DataSet ExtractPoints::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool ExtractPoints::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField())
{
if (this->CompactPoints)
{
return this->Compactor.DoMapField(result, input, fieldMeta, policy, DeviceAdapter());
return this->Compactor.DoMapField(result, input, fieldMeta, policy);
}
else
{

10
vtkm/filter/ExtractStructured.h
View File

@ -88,18 +88,16 @@ public:
VTKM_CONT
void SetIncludeBoundary(bool value) { this->IncludeBoundary = value; }
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
// Map new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::RangeId3 VOI;

19
vtkm/filter/ExtractStructured.hxx
View File

@ -36,11 +36,10 @@ inline VTKM_CONT ExtractStructured::ExtractStructured()
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet ExtractStructured::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
const vtkm::cont::CoordinateSystem& coordinates =
@ -49,10 +48,9 @@ inline VTKM_CONT vtkm::cont::DataSet ExtractStructured::DoExecute(
auto cellset = this->Worklet.Run(vtkm::filter::ApplyPolicyStructured(cells, policy),
this->VOI,
this->SampleRate,
this->IncludeBoundary,
device);
this->IncludeBoundary);
auto coords = this->Worklet.MapCoordinates(coordinates, device);
auto coords = this->Worklet.MapCoordinates(coordinates);
vtkm::cont::CoordinateSystem outputCoordinates(coordinates.GetName(), coords);
vtkm::cont::DataSet output;
@ -62,17 +60,16 @@ inline VTKM_CONT vtkm::cont::DataSet ExtractStructured::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool ExtractStructured::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
if (fieldMeta.IsPointField())
{
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessPointField(input, device);
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessPointField(input);
result.AddField(fieldMeta.AsField(output));
return true;
@ -81,7 +78,7 @@ inline VTKM_CONT bool ExtractStructured::DoMapField(
// cell data must be scattered to the cells created per input cell
if (fieldMeta.IsCellField())
{
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessCellField(input, device);
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessCellField(input);
result.AddField(fieldMeta.AsField(output));
return true;

5
vtkm/filter/FieldToColors.h
View File

@ -80,12 +80,11 @@ public:
void SetNumberOfSamplingPoints(vtkm::Int32 count);
vtkm::Int32 GetNumberOfSamplingPoints() const { return this->SampleCount; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::cont::ColorTable Table;

5
vtkm/filter/FieldToColors.hxx
View File

@ -144,13 +144,12 @@ inline VTKM_CONT void FieldToColors::SetNumberOfSamplingPoints(vtkm::Int32 count
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet FieldToColors::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
//If the table has been modified we need to rebuild our
//sample tables

17
vtkm/filter/Filter.h
View File

@ -24,7 +24,6 @@
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/Field.h>
#include <vtkm/cont/MultiBlock.h>
#include <vtkm/cont/RuntimeDeviceTracker.h>
#include <vtkm/filter/FieldSelection.h>
#include <vtkm/filter/FilterTraits.h>
@ -184,21 +183,6 @@ public:
VTKM_CONT
~Filter();
//@{
/// The runtime device tracker determines what devices the filter will be executed on.
///
VTKM_CONT
void SetRuntimeDeviceTracker(const vtkm::cont::RuntimeDeviceTracker& tracker)
{
this->Tracker = tracker;
}
VTKM_CONT
const vtkm::cont::RuntimeDeviceTracker& GetRuntimeDeviceTracker() const { return this->Tracker; }
VTKM_CONT
vtkm::cont::RuntimeDeviceTracker& GetRuntimeDeviceTracker() { return this->Tracker; }
//@}
//@{
/// \brief Specify which fields get passed from input to output.
///
@ -269,7 +253,6 @@ public:
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
vtkm::cont::RuntimeDeviceTracker Tracker;
vtkm::filter::FieldSelection FieldsToPass;
};
}

3
vtkm/filter/Filter.hxx
View File

@ -247,8 +247,7 @@ void CallPostExecute(Derived* self,
//----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT Filter<Derived>::Filter()
: Tracker(vtkm::cont::GetGlobalRuntimeDeviceTracker())
, FieldsToPass(vtkm::filter::FieldSelection::MODE_ALL)
: FieldsToPass(vtkm::filter::FieldSelection::MODE_ALL)
{
}

47
vtkm/filter/FilterDataSet.hxx
View File

@ -48,55 +48,13 @@ inline VTKM_CONT FilterDataSet<Derived>::~FilterDataSet()
}
//-----------------------------------------------------------------------------
namespace detail
{
template <typename Derived, typename DerivedPolicy>
struct FilterDataSetPrepareForExecutionFunctor
{
vtkm::cont::DataSet Result;
Derived* Self;
const vtkm::cont::DataSet& Input;
const vtkm::filter::PolicyBase<DerivedPolicy>& Policy;
VTKM_CONT
FilterDataSetPrepareForExecutionFunctor(Derived* self,
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
: Self(self)
, Input(input)
, Policy(policy)
{
}
template <typename Device>
VTKM_CONT bool operator()(Device)
{
this->Result = this->Self->DoExecute(this->Input, this->Policy, Device());
// `DoExecute` is expected to throw an exception on any failure. If it
// returned anything, it's taken as a success and we won't try executing on
// other available devices.
return true;
}
private:
void operator=(FilterDataSetPrepareForExecutionFunctor<Derived, DerivedPolicy>&) = delete;
};
} // namespace detail
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet FilterDataSet<Derived>::PrepareForExecution(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
// When we move to C++11, this could probably be an anonymous class
detail::FilterDataSetPrepareForExecutionFunctor<Derived, DerivedPolicy> functor(
static_cast<Derived*>(this), input, policy);
vtkm::cont::TryExecute(
functor, this->GetRuntimeDeviceTracker(), typename DerivedPolicy::DeviceAdapterList());
return functor.Result;
return (static_cast<Derived*>(this))->DoExecute(input, policy);
}
//-----------------------------------------------------------------------------
@ -114,8 +72,7 @@ inline VTKM_CONT bool FilterDataSet<Derived>::MapFieldOntoOutput(
FunctorType functor(static_cast<Derived*>(this), result, metaData, policy, valid);
using Traits = vtkm::filter::FilterTraits<Derived>;
vtkm::cont::CastAndCall(
vtkm::filter::ApplyPolicy(field, policy, Traits()), functor, this->GetRuntimeDeviceTracker());
vtkm::cont::CastAndCall(vtkm::filter::ApplyPolicy(field, policy, Traits()), functor);
//the bool valid will be modified by the map algorithm to hold if the
//mapping occurred or not. If the mapping was good a new field has been

31
vtkm/filter/FilterDataSetWithField.hxx
View File

@ -87,12 +87,14 @@ inline VTKM_CONT vtkm::cont::DataSet FilterDataSetWithField<Derived>::PrepareFor
vtkm::filter::FieldMetadata metaData(field);
vtkm::cont::DataSet result;
using FunctorType =
internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, vtkm::cont::DataSet>;
FunctorType functor(static_cast<Derived*>(this), input, metaData, policy, result);
using Traits = vtkm::filter::FilterTraits<Derived>;
vtkm::cont::CastAndCall(
vtkm::filter::ApplyPolicy(field, policy, Traits()), functor, this->GetRuntimeDeviceTracker());
vtkm::filter::ApplyPolicy(field, policy, vtkm::filter::FilterTraits<Derived>()),
internal::ResolveFieldTypeAndExecute(),
static_cast<Derived*>(this),
input,
metaData,
policy,
result);
return result;
}
@ -107,19 +109,21 @@ inline VTKM_CONT vtkm::cont::DataSet FilterDataSetWithField<Derived>::PrepareFor
//We have a special signature just for CoordinateSystem, so that we can ask
//the policy for the storage types and value types just for coordinate systems
vtkm::filter::FieldMetadata metaData(field);
vtkm::cont::DataSet result;
//determine the field type first
vtkm::cont::DataSet result;
using FunctorType =
internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, vtkm::cont::DataSet>;
FunctorType functor(static_cast<Derived*>(this), input, metaData, policy, result);
using Traits = vtkm::filter::FilterTraits<Derived>;
constexpr bool supportsVec3 = vtkm::ListContains<typename Traits::InputFieldTypeList,
vtkm::Vec<vtkm::FloatDefault, 3>>::value;
using supportsCoordinateSystem = std::integral_constant<bool, supportsVec3>;
vtkm::cont::ConditionalCastAndCall(
supportsCoordinateSystem(), field, functor, this->GetRuntimeDeviceTracker());
vtkm::cont::ConditionalCastAndCall(supportsCoordinateSystem(),
field,
internal::ResolveFieldTypeAndExecute(),
static_cast<Derived*>(this),
input,
metaData,
policy,
result);
return result;
}
@ -138,8 +142,7 @@ inline VTKM_CONT bool FilterDataSetWithField<Derived>::MapFieldOntoOutput(
using FunctorType = internal::ResolveFieldTypeAndMap<Derived, DerivedPolicy>;
FunctorType functor(static_cast<Derived*>(this), result, metaData, policy, valid);
vtkm::cont::CastAndCall(
vtkm::filter::ApplyPolicy(field, policy), functor, this->GetRuntimeDeviceTracker());
vtkm::cont::CastAndCall(vtkm::filter::ApplyPolicy(field, policy), functor);
//the bool valid will be modified by the map algorithm to hold if the
//mapping occurred or not. If the mapping was good a new field has been

27
vtkm/filter/FilterField.hxx
View File

@ -85,13 +85,14 @@ inline VTKM_CONT vtkm::cont::DataSet FilterField<Derived>::PrepareForExecution(
vtkm::filter::FieldMetadata metaData(field);
vtkm::cont::DataSet result;
using FunctorType =
internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, vtkm::cont::DataSet>;
FunctorType functor(static_cast<Derived*>(this), input, metaData, policy, result);
using Traits = vtkm::filter::FilterTraits<Derived>;
vtkm::cont::CastAndCall(
vtkm::filter::ApplyPolicy(field, policy, Traits()), functor, this->GetRuntimeDeviceTracker());
vtkm::filter::ApplyPolicy(field, policy, vtkm::filter::FilterTraits<Derived>()),
internal::ResolveFieldTypeAndExecute(),
static_cast<Derived*>(this),
input,
metaData,
policy,
result);
return result;
}
@ -109,17 +110,19 @@ inline VTKM_CONT vtkm::cont::DataSet FilterField<Derived>::PrepareForExecution(
vtkm::filter::FieldMetadata metaData(field);
vtkm::cont::DataSet result;
using FunctorType =
internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, vtkm::cont::DataSet>;
FunctorType functor(static_cast<Derived*>(this), input, metaData, policy, result);
using Traits = vtkm::filter::FilterTraits<Derived>;
constexpr bool supportsVec3 = vtkm::ListContains<typename Traits::InputFieldTypeList,
vtkm::Vec<vtkm::FloatDefault, 3>>::value;
using supportsCoordinateSystem = std::integral_constant<bool, supportsVec3>;
vtkm::cont::ConditionalCastAndCall(
supportsCoordinateSystem(), field, functor, this->GetRuntimeDeviceTracker());
vtkm::cont::ConditionalCastAndCall(supportsCoordinateSystem(),
field,
internal::ResolveFieldTypeAndExecute(),
static_cast<Derived*>(this),
input,
metaData,
policy,
result);
return result;
}

14
vtkm/filter/GhostZone.h
View File

@ -64,21 +64,19 @@ public:
VTKM_CONT
bool GetConvertOutputToUnstructured() { return this->ConvertToUnstructured; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
bool RemoveAll;
@ -86,10 +84,8 @@ private:
vtkm::UInt8 RemoveVals;
vtkm::worklet::Threshold Worklet;
template <typename DeviceAdapter>
VTKM_CONT vtkm::cont::CellSetExplicit<> ConvertOutputToUnstructured(
vtkm::cont::DynamicCellSet& inCells,
DeviceAdapter tag);
vtkm::cont::DynamicCellSet& inCells);
};
template <>

34
vtkm/filter/GhostZone.hxx
View File

@ -80,13 +80,12 @@ inline VTKM_CONT GhostZone::GhostZone()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet GhostZone::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
//get the cells and coordinates of the dataset
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
@ -97,14 +96,12 @@ inline VTKM_CONT vtkm::cont::DataSet GhostZone::DoExecute(
cellOut = this->Worklet.Run(vtkm::filter::ApplyPolicy(cells, policy),
field,
fieldMeta.GetAssociation(),
RemoveAllGhosts(),
DeviceAdapter());
RemoveAllGhosts());
else if (this->GetRemoveByType())
cellOut = this->Worklet.Run(vtkm::filter::ApplyPolicy(cells, policy),
field,
fieldMeta.GetAssociation(),
RemoveGhostByType(this->GetRemoveType()),
DeviceAdapter());
RemoveGhostByType(this->GetRemoveType()));
else
throw vtkm::cont::ErrorFilterExecution("Unsupported ghost cell removal type");
@ -114,8 +111,8 @@ inline VTKM_CONT vtkm::cont::DataSet GhostZone::DoExecute(
if (this->GetConvertOutputToUnstructured())
{
vtkm::cont::CellSetExplicit<> explicitCells;
//vtkm::worklet::CellDeepCopy::Run(cellOut, explicitCells, DeviceAdapter());
explicitCells = this->ConvertOutputToUnstructured(cellOut, DeviceAdapter());
//vtkm::worklet::CellDeepCopy::Run(cellOut, explicitCells);
explicitCells = this->ConvertOutputToUnstructured(cellOut);
output.AddCellSet(explicitCells);
}
else
@ -125,12 +122,11 @@ inline VTKM_CONT vtkm::cont::DataSet GhostZone::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool GhostZone::DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
DeviceAdapter device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
if (fieldMeta.IsPointField())
{
@ -140,7 +136,7 @@ inline VTKM_CONT bool GhostZone::DoMapField(vtkm::cont::DataSet& result,
}
else if (fieldMeta.IsCellField())
{
vtkm::cont::ArrayHandle<T> out = this->Worklet.ProcessCellField(input, device);
vtkm::cont::ArrayHandle<T> out = this->Worklet.ProcessCellField(input);
result.AddField(fieldMeta.AsField(out));
return true;
}
@ -150,10 +146,8 @@ inline VTKM_CONT bool GhostZone::DoMapField(vtkm::cont::DataSet& result,
}
}
template <typename DeviceAdapter>
inline VTKM_CONT vtkm::cont::CellSetExplicit<> GhostZone::ConvertOutputToUnstructured(
vtkm::cont::DynamicCellSet& inCells,
DeviceAdapter tag)
vtkm::cont::DynamicCellSet& inCells)
{
using PermStructured2d = vtkm::cont::CellSetPermutation<vtkm::cont::CellSetStructured<2>>;
using PermStructured3d = vtkm::cont::CellSetPermutation<vtkm::cont::CellSetStructured<3>>;
@ -165,22 +159,22 @@ inline VTKM_CONT vtkm::cont::CellSetExplicit<> GhostZone::ConvertOutputToUnstruc
if (inCells.IsSameType(PermStructured2d()))
{
PermStructured2d perm = inCells.Cast<PermStructured2d>();
vtkm::worklet::CellDeepCopy::Run(perm, explicitCells, tag);
vtkm::worklet::CellDeepCopy::Run(perm, explicitCells);
}
else if (inCells.IsSameType(PermStructured3d()))
{
PermStructured3d perm = inCells.Cast<PermStructured3d>();
vtkm::worklet::CellDeepCopy::Run(perm, explicitCells, tag);
vtkm::worklet::CellDeepCopy::Run(perm, explicitCells);
}
else if (inCells.IsSameType(PermExplicit()))
{
PermExplicit perm = inCells.Cast<PermExplicit>();
vtkm::worklet::CellDeepCopy::Run(perm, explicitCells, tag);
vtkm::worklet::CellDeepCopy::Run(perm, explicitCells);
}
else if (inCells.IsSameType(PermExplicitSingle()))
{
PermExplicitSingle perm = inCells.Cast<PermExplicitSingle>();
vtkm::worklet::CellDeepCopy::Run(perm, explicitCells, tag);
vtkm::worklet::CellDeepCopy::Run(perm, explicitCells);
}
else
throw vtkm::cont::ErrorFilterExecution("Unsupported permutation cell type");

5
vtkm/filter/Gradient.h
View File

@ -97,12 +97,11 @@ public:
void SetQCriterionName(const std::string& name) { this->QCriterionName = name; }
const std::string& GetQCriterionName() const { return this->QCriterionName; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
bool ComputePointGradient;

26
vtkm/filter/Gradient.hxx
View File

@ -47,17 +47,16 @@ inline void add_field(vtkm::cont::DataSet& result,
}
//-----------------------------------------------------------------------------
template <typename T, typename S, typename DeviceAdapter>
inline void transpose_3x3(vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec<T, 3>, 3>, S>& field,
DeviceAdapter adapter)
template <typename T, typename S>
inline void transpose_3x3(vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec<T, 3>, 3>, S>& field)
{
vtkm::worklet::gradient::Transpose3x3<T> transpose;
transpose.Run(field, adapter);
transpose.Run(field);
}
//-----------------------------------------------------------------------------
template <typename T, typename S, typename DeviceAdapter>
inline void transpose_3x3(vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, S>&, DeviceAdapter)
template <typename T, typename S>
inline void transpose_3x3(vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, S>&)
{ //This is not a 3x3 matrix so no transpose needed
}
@ -83,13 +82,12 @@ Gradient::Gradient()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& adapter)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
if (!fieldMetadata.IsPointField())
{
@ -116,18 +114,18 @@ inline vtkm::cont::DataSet Gradient::DoExecute(
if (this->ComputePointGradient)
{
vtkm::worklet::PointGradient gradient;
outArray = gradient.Run(
vtkm::filter::ApplyPolicy(cells, policy), coords, inField, gradientfields, adapter);
outArray =
gradient.Run(vtkm::filter::ApplyPolicy(cells, policy), coords, inField, gradientfields);
}
else
{
vtkm::worklet::CellGradient gradient;
outArray = gradient.Run(
vtkm::filter::ApplyPolicy(cells, policy), coords, inField, gradientfields, adapter);
outArray =
gradient.Run(vtkm::filter::ApplyPolicy(cells, policy), coords, inField, gradientfields);
}
if (!this->RowOrdering)
{
transpose_3x3(outArray, adapter);
transpose_3x3(outArray);
}
constexpr bool isVector = std::is_same<typename vtkm::VecTraits<T>::HasMultipleComponents,

5
vtkm/filter/Histogram.h
View File

@ -66,12 +66,11 @@ public:
VTKM_CONT
vtkm::Range GetComputedRange() const { return this->ComputedRange; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//@{
/// when operating on vtkm::cont::MultiBlock, we

10
vtkm/filter/Histogram.hxx
View File

@ -192,13 +192,12 @@ inline VTKM_CONT Histogram::Histogram()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Histogram::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata&,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
vtkm::cont::ArrayHandle<vtkm::Id> binArray;
T delta;
@ -211,12 +210,11 @@ inline VTKM_CONT vtkm::cont::DataSet Histogram::DoExecute(
static_cast<T>(this->ComputedRange.Min),
static_cast<T>(this->ComputedRange.Max),
delta,
binArray,
device);
binArray);
}
else
{
worklet.Run(field, this->NumberOfBins, this->ComputedRange, delta, binArray, device);
worklet.Run(field, this->NumberOfBins, this->ComputedRange, delta, binArray);
}
this->BinDelta = static_cast<vtkm::Float64>(delta);

10
vtkm/filter/Lagrangian.h
View File

@ -76,21 +76,19 @@ public:
VTKM_CONT
void InitializeUniformSeeds(const vtkm::cont::DataSet& input);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::Id rank;

27
vtkm/filter/Lagrangian.hxx
View File

@ -19,6 +19,7 @@
//============================================================================
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayCopy.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleIndex.h>
#include <vtkm/cont/ArrayPortalToIterators.h>
@ -202,20 +203,19 @@ inline void Lagrangian::InitializeUniformSeeds(const vtkm::cont::DataSet& input)
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
if (cycle == 0)
{
InitializeUniformSeeds(input);
BasisParticlesOriginal.Allocate(this->SeedRes[0] * this->SeedRes[1] * this->SeedRes[2]);
vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter>::Copy(BasisParticles, BasisParticlesOriginal);
vtkm::cont::ArrayCopy(BasisParticles, BasisParticlesOriginal);
}
if (!fieldMeta.IsPointField())
@ -229,7 +229,7 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
"Write frequency can not be 0. Use SetWriteFrequency().");
}
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> basisParticleArray;
vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter>::Copy(BasisParticles, basisParticleArray);
vtkm::cont::ArrayCopy(BasisParticles, basisParticleArray);
cycle += 1;
std::cout << "Cycle : " << cycle << std::endl;
@ -262,7 +262,7 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
* If Euler step is preferred.
EulerIntegratorType euler(eval, static_cast<vtkm::FloatDefault>(this->stepSize));
*/
res = particleadvection.Run(rk4, basisParticleArray, 1, device); // Taking a single step
res = particleadvection.Run(rk4, basisParticleArray, 1); // Taking a single step
}
else if (coords.GetData().IsType<UniformType>())
{
@ -278,7 +278,7 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
* If Euler step is preferred.
EulerIntegratorType euler(eval, static_cast<vtkm::FloatDefault>(this->stepSize));
*/
res = particleadvection.Run(rk4, basisParticleArray, 1, device); // Taking a single step
res = particleadvection.Run(rk4, basisParticleArray, 1); // Taking a single step
}
else
{
@ -347,12 +347,11 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
{
InitializeUniformSeeds(input);
BasisParticlesOriginal.Allocate(this->SeedRes[0] * this->SeedRes[1] * this->SeedRes[2]);
vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter>::Copy(BasisParticles,
BasisParticlesOriginal);
vtkm::cont::ArrayCopy(BasisParticles, BasisParticlesOriginal);
}
else
{
vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter>::Copy(particle_positions, BasisParticles);
vtkm::cont::ArrayCopy(particle_positions, BasisParticles);
}
}
else
@ -360,21 +359,19 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
ValidityCheck check;
check.SetBounds(bounds);
vtkm::worklet::DispatcherMapField<ValidityCheck> dispatcher(check);
dispatcher.SetDevice(device);
dispatcher.Invoke(particle_positions, particle_stepstaken, BasisParticlesValidity);
vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter>::Copy(particle_positions, BasisParticles);
vtkm::cont::ArrayCopy(particle_positions, BasisParticles);
}
return outputData;
}
//---------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool Lagrangian::DoMapField(vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<T, StorageType>&,
const vtkm::filter::FieldMetadata&,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter&)
const vtkm::filter::PolicyBase<DerivedPolicy>)
{
return false;
}

10
vtkm/filter/MarchingCubes.h
View File

@ -105,21 +105,19 @@ public:
VTKM_CONT
const std::string& GetNormalArrayName() const { return this->NormalArrayName; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
std::vector<vtkm::Float64> IsoValues;

24
vtkm/filter/MarchingCubes.hxx
View File

@ -102,13 +102,12 @@ inline vtkm::Float64 MarchingCubes::GetIsoValue(vtkm::Id index) const
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet MarchingCubes::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
if (fieldMeta.IsPointField() == false)
{
@ -169,8 +168,7 @@ inline VTKM_CONT vtkm::cont::DataSet MarchingCubes::DoExecute(
coords.GetData(),
field,
vertices,
normals,
device);
normals);
}
else
{
@ -179,8 +177,7 @@ inline VTKM_CONT vtkm::cont::DataSet MarchingCubes::DoExecute(
vtkm::filter::ApplyPolicy(cells, policy),
coords.GetData(),
field,
vertices,
device);
vertices);
}
if (this->GenerateNormals)
@ -189,10 +186,10 @@ inline VTKM_CONT vtkm::cont::DataSet MarchingCubes::DoExecute(
{
Vec3HandleType faceNormals;
vtkm::worklet::FacetedSurfaceNormals faceted;
faceted.Run(outputCells, vertices, faceNormals, device);
faceted.Run(outputCells, vertices, faceNormals);
vtkm::worklet::SmoothSurfaceNormals smooth;
smooth.Run(outputCells, faceNormals, normals, device);
smooth.Run(outputCells, faceNormals, normals);
}
vtkm::cont::Field normalField(
@ -216,23 +213,22 @@ inline VTKM_CONT vtkm::cont::DataSet MarchingCubes::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool MarchingCubes::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
vtkm::cont::ArrayHandle<T> fieldArray;
if (fieldMeta.IsPointField())
{
fieldArray = this->Worklet.ProcessPointField(input, device);
fieldArray = this->Worklet.ProcessPointField(input);
}
else if (fieldMeta.IsCellField())
{
fieldArray = this->Worklet.ProcessCellField(input, device);
fieldArray = this->Worklet.ProcessCellField(input);
}
else
{

10
vtkm/filter/Mask.h
View File

@ -51,18 +51,16 @@ public:
VTKM_CONT
void SetStride(vtkm::Id& stride) { this->Stride = stride; }
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::Id Stride;

20
vtkm/filter/Mask.hxx
View File

@ -21,7 +21,6 @@
namespace
{
template <typename DeviceTag>
struct CallWorklet
{
vtkm::Id Stride;
@ -38,7 +37,7 @@ struct CallWorklet
template <typename CellSetType>
void operator()(const CellSetType& cells) const
{
this->Output = this->Worklet.Run(cells, this->Stride, DeviceTag());
this->Output = this->Worklet.Run(cells, this->Stride);
}
};
@ -58,15 +57,13 @@ inline VTKM_CONT Mask::Mask()
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::cont::DataSet Mask::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Mask::DoExecute(const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
vtkm::cont::DynamicCellSet cellOut;
CallWorklet<DeviceAdapter> workletCaller(this->Stride, cellOut, this->Worklet);
CallWorklet workletCaller(this->Stride, cellOut, this->Worklet);
vtkm::filter::ApplyPolicy(cells, policy).CastAndCall(workletCaller);
// create the output dataset
@ -77,12 +74,11 @@ inline VTKM_CONT vtkm::cont::DataSet Mask::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool Mask::DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
vtkm::cont::Field output;
@ -92,7 +88,7 @@ inline VTKM_CONT bool Mask::DoMapField(vtkm::cont::DataSet& result,
}
else if (fieldMeta.IsCellField())
{
output = fieldMeta.AsField(this->Worklet.ProcessCellField(input, device));
output = fieldMeta.AsField(this->Worklet.ProcessCellField(input));
}
else
{

10
vtkm/filter/MaskPoints.h
View File

@ -51,18 +51,16 @@ public:
VTKM_CONT
void SetStride(vtkm::Id stride) { this->Stride = stride; }
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::Id Stride;

16
vtkm/filter/MaskPoints.hxx
View File

@ -50,11 +50,10 @@ inline VTKM_CONT MaskPoints::MaskPoints()
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet MaskPoints::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// extract the input cell set
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
@ -63,7 +62,7 @@ inline VTKM_CONT vtkm::cont::DataSet MaskPoints::DoExecute(
vtkm::cont::CellSetSingleType<> outCellSet;
vtkm::worklet::MaskPoints worklet;
outCellSet = worklet.Run(vtkm::filter::ApplyPolicy(cells, policy), this->Stride, device);
outCellSet = worklet.Run(vtkm::filter::ApplyPolicy(cells, policy), this->Stride);
// create the output dataset
vtkm::cont::DataSet output;
@ -74,7 +73,7 @@ inline VTKM_CONT vtkm::cont::DataSet MaskPoints::DoExecute(
if (this->CompactPoints)
{
this->Compactor.SetCompactPointFields(true);
return this->Compactor.DoExecute(output, GetCellSetSingleTypePolicy(policy), DeviceAdapter());
return this->Compactor.DoExecute(output, GetCellSetSingleTypePolicy(policy));
}
else
{
@ -83,19 +82,18 @@ inline VTKM_CONT vtkm::cont::DataSet MaskPoints::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool MaskPoints::DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField())
{
if (this->CompactPoints)
{
return this->Compactor.DoMapField(result, input, fieldMeta, policy, DeviceAdapter());
return this->Compactor.DoMapField(result, input, fieldMeta, policy);
}
else
{

10
vtkm/filter/NDEntropy.h
View File

@ -39,17 +39,15 @@ public:
VTKM_CONT
void AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins);
template <typename Policy, typename Device>
template <typename Policy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy,
Device);
vtkm::filter::PolicyBase<Policy> policy);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
std::vector<vtkm::Id> NumOfBins;

18
vtkm/filter/NDEntropy.hxx
View File

@ -36,26 +36,23 @@ void NDEntropy::AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins)
this->NumOfBins.push_back(numOfBins);
}
template <typename Policy, typename Device>
template <typename Policy>
inline VTKM_CONT vtkm::cont::DataSet NDEntropy::DoExecute(
const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> vtkmNotUsed(policy),
Device device)
vtkm::filter::PolicyBase<Policy> vtkmNotUsed(policy))
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::worklet::NDimsEntropy ndEntropy;
ndEntropy.SetNumOfDataPoints(inData.GetField(0).GetData().GetNumberOfValues(), device);
ndEntropy.SetNumOfDataPoints(inData.GetField(0).GetData().GetNumberOfValues());
// Add field one by one
// (By using AddFieldAndBin(), the length of FieldNames and NumOfBins must be the same)
for (size_t i = 0; i < FieldNames.size(); i++)
{
ndEntropy.AddField(inData.GetField(FieldNames[i]).GetData(), NumOfBins[i], device);
ndEntropy.AddField(inData.GetField(FieldNames[i]).GetData(), NumOfBins[i]);
}
// Run worklet to calculate multi-variate entropy
vtkm::Float64 entropy = ndEntropy.Run(device);
vtkm::Float64 entropy = ndEntropy.Run();
vtkm::cont::DataSet outputData;
outputData.AddField(vtkm::cont::make_Field(
"Entropy", vtkm::cont::Field::Association::POINTS, &entropy, 1, vtkm::CopyFlag::On));
@ -63,12 +60,11 @@ inline VTKM_CONT vtkm::cont::DataSet NDEntropy::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool NDEntropy::DoMapField(vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<T, StorageType>&,
const vtkm::filter::FieldMetadata&,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
DeviceAdapter)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
return false;
}

10
vtkm/filter/NDHistogram.h
View File

@ -47,10 +47,9 @@ public:
VTKM_CONT
void AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins);
template <typename Policy, typename Device>
template <typename Policy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy,
Device);
vtkm::filter::PolicyBase<Policy> policy);
// This index is the field position in FieldNames
// (or the input _fieldName string vector of SetFields() Function)
@ -62,12 +61,11 @@ public:
VTKM_CONT
vtkm::Range GetDataRange(size_t fieldIdx);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
std::vector<vtkm::Id> NumOfBins;

19
vtkm/filter/NDHistogram.hxx
View File

@ -47,17 +47,14 @@ vtkm::Range NDHistogram::GetDataRange(size_t fieldIdx)
return DataRanges[fieldIdx];
}
template <typename Policy, typename Device>
template <typename Policy>
inline VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy,
Device device)
vtkm::filter::PolicyBase<Policy> policy)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::worklet::NDimsHistogram ndHistogram;
// Set the number of data points
ndHistogram.SetNumOfDataPoints(inData.GetField(0).GetData().GetNumberOfValues(), device);
ndHistogram.SetNumOfDataPoints(inData.GetField(0).GetData().GetNumberOfValues());
// Add field one by one
// (By using AddFieldAndBin(), the length of FieldNames and NumOfBins must be the same)
@ -68,15 +65,14 @@ inline VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(const vtkm::cont::Da
ndHistogram.AddField(vtkm::filter::ApplyPolicy(inData.GetField(FieldNames[i]), policy),
NumOfBins[i],
rangeField,
deltaField,
device);
deltaField);
DataRanges.push_back(rangeField);
BinDeltas.push_back(deltaField);
}
std::vector<vtkm::cont::ArrayHandle<vtkm::Id>> binIds;
vtkm::cont::ArrayHandle<vtkm::Id> freqs;
ndHistogram.Run(binIds, freqs, device);
ndHistogram.Run(binIds, freqs);
vtkm::cont::DataSet outputData;
for (size_t i = 0; i < binIds.size(); i++)
@ -91,12 +87,11 @@ inline VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(const vtkm::cont::Da
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool NDHistogram::DoMapField(vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<T, StorageType>&,
const vtkm::filter::FieldMetadata&,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
DeviceAdapter)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
return false;
}

5
vtkm/filter/OscillatorSource.h
View File

@ -67,12 +67,11 @@ public:
vtkm::Float64 omega,
vtkm::Float64 zeta);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
vtkm::worklet::OscillatorSource Worklet;

6
vtkm/filter/OscillatorSource.hxx
View File

@ -75,17 +75,15 @@ inline VTKM_CONT void OscillatorSource::AddDecaying(vtkm::Float64 x,
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet OscillatorSource::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter&)
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
vtkm::cont::ArrayHandle<vtkm::Float64> outArray;
vtkm::worklet::DispatcherMapField<vtkm::worklet::OscillatorSource> dispatcher(this->Worklet);
dispatcher.SetDevice(DeviceAdapter());
//todo, we need to use the policy to determine the valid conversions
//that the dispatcher should do

5
vtkm/filter/PointAverage.h
View File

@ -40,12 +40,11 @@ public:
VTKM_CONT
PointAverage();
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
vtkm::worklet::PointAverage Worklet;

6
vtkm/filter/PointAverage.hxx
View File

@ -36,13 +36,12 @@ inline VTKM_CONT PointAverage::PointAverage()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet PointAverage::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
if (!fieldMetadata.IsCellField())
{
@ -56,7 +55,6 @@ inline VTKM_CONT vtkm::cont::DataSet PointAverage::DoExecute(
vtkm::cont::ArrayHandle<T> outArray;
vtkm::worklet::DispatcherMapTopology<vtkm::worklet::PointAverage> dispatcher(this->Worklet);
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(vtkm::filter::ApplyPolicy(cellSet, policy), inField, outArray);

5
vtkm/filter/PointElevation.h
View File

@ -50,12 +50,11 @@ public:
VTKM_CONT
void SetRange(vtkm::Float64 low, vtkm::Float64 high);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::worklet::PointElevation Worklet;

6
vtkm/filter/PointElevation.hxx
View File

@ -54,17 +54,15 @@ inline VTKM_CONT void PointElevation::SetRange(vtkm::Float64 low, vtkm::Float64
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet PointElevation::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
vtkm::cont::ArrayHandle<vtkm::Float64> outArray;
vtkm::worklet::DispatcherMapField<vtkm::worklet::PointElevation> dispatcher(this->Worklet);
dispatcher.SetDevice(DeviceAdapter());
//todo, we need to use the policy to determine the valid conversions
//that the dispatcher should do

5
vtkm/filter/PointTransform.h
View File

@ -60,12 +60,11 @@ public:
void SetTransform(const vtkm::Matrix<S, 4, 4>& mtx);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::worklet::PointTransform<S> Worklet;

6
vtkm/filter/PointTransform.hxx
View File

@ -118,17 +118,15 @@ inline VTKM_CONT void PointTransform<S>::SetTransform(const vtkm::Matrix<S, 4, 4
//-----------------------------------------------------------------------------
template <typename S>
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet PointTransform<S>::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
vtkm::cont::ArrayHandle<T> outArray;
vtkm::worklet::DispatcherMapField<vtkm::worklet::PointTransform<S>> dispatcher(this->Worklet);
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(field, outArray);

3
vtkm/filter/PolicyBase.h
View File

@ -47,9 +47,6 @@ struct PolicyBase
using StructuredCellSetList = vtkm::cont::CellSetListTagStructured;
using UnstructuredCellSetList = vtkm::cont::CellSetListTagUnstructured;
using AllCellSetList = VTKM_DEFAULT_CELL_SET_LIST_TAG;
// List of backends to try in sequence (if one fails, the next is attempted).
using DeviceAdapterList = VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG;
};
//-----------------------------------------------------------------------------

10
vtkm/filter/Probe.h
View File

@ -34,19 +34,17 @@ public:
VTKM_CONT
void SetGeometry(const vtkm::cont::DataSet& geometry);
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::cont::DataSet Geometry;

23
vtkm/filter/Probe.hxx
View File

@ -33,22 +33,20 @@ inline void Probe::SetGeometry(const vtkm::cont::DataSet& geometry)
this->Geometry.AddCoordinateSystem(geometry.GetCoordinateSystem());
}
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
VTKM_CONT inline vtkm::cont::DataSet Probe::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
this->Worklet.Run(
vtkm::filter::ApplyPolicy(input.GetCellSet(this->GetActiveCellSetIndex()), policy),
input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex()),
this->Geometry.GetCoordinateSystem().GetData(),
device);
this->Geometry.GetCoordinateSystem().GetData());
auto output = this->Geometry;
auto hpf = this->Worklet.GetHiddenPointsField(device);
auto hcf = this->Worklet.GetHiddenCellsField(
vtkm::filter::ApplyPolicy(output.GetCellSet(), policy), device);
auto hpf = this->Worklet.GetHiddenPointsField();
auto hcf =
this->Worklet.GetHiddenCellsField(vtkm::filter::ApplyPolicy(output.GetCellSet(), policy));
output.AddField(vtkm::cont::Field("HIDDEN", vtkm::cont::Field::Association::POINTS, hpf));
output.AddField(vtkm::cont::Field(
@ -57,23 +55,22 @@ VTKM_CONT inline vtkm::cont::DataSet Probe::DoExecute(
return output;
}
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT inline bool Probe::DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
if (fieldMeta.IsPointField())
{
auto fieldArray =
this->Worklet.ProcessPointField(input, device, typename DerivedPolicy::AllCellSetList());
this->Worklet.ProcessPointField(input, typename DerivedPolicy::AllCellSetList());
result.AddField(fieldMeta.AsField(fieldArray));
return true;
}
else if (fieldMeta.IsCellField())
{
auto fieldArray = this->Worklet.ProcessCellField(input, device);
auto fieldArray = this->Worklet.ProcessCellField(input);
result.AddField(fieldMeta.AsField(fieldArray));
return true;
}

10
vtkm/filter/SplitSharpEdges.h
View File

@ -54,20 +54,18 @@ public:
VTKM_CONT
vtkm::FloatDefault GetFeatureAngle() const { return this->FeatureAngle; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::FloatDefault FeatureAngle;

15
vtkm/filter/SplitSharpEdges.hxx
View File

@ -38,13 +38,12 @@ inline VTKM_CONT SplitSharpEdges::SplitSharpEdges()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet SplitSharpEdges::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& vtkmNotUsed(fieldMeta),
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// Get the cells and coordinates of the dataset
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
@ -56,8 +55,7 @@ inline VTKM_CONT vtkm::cont::DataSet SplitSharpEdges::DoExecute(
field,
input.GetCoordinateSystem().GetData(),
newCoords,
newCellset,
DeviceAdapter());
newCellset);
vtkm::cont::DataSet output;
output.AddCellSet(newCellset);
@ -67,18 +65,17 @@ inline VTKM_CONT vtkm::cont::DataSet SplitSharpEdges::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool SplitSharpEdges::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
DeviceAdapter device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
if (fieldMeta.IsPointField())
{
// We copy the input handle to the result dataset, reusing the metadata
vtkm::cont::ArrayHandle<T> out = this->Worklet.ProcessPointField(input, device);
vtkm::cont::ArrayHandle<T> out = this->Worklet.ProcessPointField(input);
result.AddField(fieldMeta.AsField(out));
return true;
}

10
vtkm/filter/Streamline.h
View File

@ -48,22 +48,20 @@ public:
VTKM_CONT
void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>>& seeds);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::worklet::Streamline Worklet;

15
vtkm/filter/Streamline.hxx
View File

@ -18,6 +18,7 @@
// this software.
//============================================================================
#include <vtkm/cont/ArrayCopy.h>
#include <vtkm/cont/ArrayHandleIndex.h>
#include <vtkm/cont/ErrorFilterExecution.h>
#include <vtkm/worklet/particleadvection/GridEvaluators.h>
@ -57,13 +58,12 @@ inline VTKM_CONT void Streamline::SetSeeds(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Streamline::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
//Check for some basics.
if (this->Seeds.GetNumberOfValues() == 0)
@ -98,8 +98,8 @@ inline VTKM_CONT vtkm::cont::DataSet Streamline::DoExecute(
vtkm::worklet::StreamlineResult res;
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> seedArray;
vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter>::Copy(this->Seeds, seedArray);
res = Worklet.Run(rk4, seedArray, this->NumberOfSteps, device);
vtkm::cont::ArrayCopy(this->Seeds, seedArray);
res = Worklet.Run(rk4, seedArray, this->NumberOfSteps);
vtkm::cont::DataSet outData;
vtkm::cont::CoordinateSystem outputCoords("coordinates", res.positions);
@ -110,12 +110,11 @@ inline VTKM_CONT vtkm::cont::DataSet Streamline::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool Streamline::DoMapField(vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<T, StorageType>&,
const vtkm::filter::FieldMetadata&,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
return false;
}

5
vtkm/filter/SurfaceNormals.h
View File

@ -65,12 +65,11 @@ public:
void SetPointNormalsName(const std::string& name) { this->PointNormalsName = name; }
const std::string& GetPointNormalsName() const { return this->PointNormalsName; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& points,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
bool GenerateCellNormals;

9
vtkm/filter/SurfaceNormals.hxx
View File

@ -72,13 +72,12 @@ inline SurfaceNormals::SurfaceNormals()
this->SetUseCoordinateSystemAsField(true);
}
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline vtkm::cont::DataSet SurfaceNormals::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& points,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
VTKM_ASSERT(fieldMeta.IsPointField());
@ -92,14 +91,14 @@ inline vtkm::cont::DataSet SurfaceNormals::DoExecute(
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>> faceNormals;
vtkm::worklet::FacetedSurfaceNormals faceted;
faceted.SetNormalize(this->NormalizeCellNormals);
faceted.Run(vtkm::filter::ApplyPolicy(cellset, policy), points, faceNormals, device);
faceted.Run(vtkm::filter::ApplyPolicy(cellset, policy), points, faceNormals);
vtkm::cont::DataSet result;
if (this->GeneratePointNormals)
{
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>> pointNormals;
vtkm::worklet::SmoothSurfaceNormals smooth;
smooth.Run(vtkm::filter::ApplyPolicy(cellset, policy), faceNormals, pointNormals, device);
smooth.Run(vtkm::filter::ApplyPolicy(cellset, policy), faceNormals, pointNormals);
result = internal::CreateResult(input,
pointNormals,

10
vtkm/filter/Tetrahedralize.h
View File

@ -35,18 +35,16 @@ public:
VTKM_CONT
Tetrahedralize();
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
// Map new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::worklet::Tetrahedralize Worklet;

15
vtkm/filter/Tetrahedralize.hxx
View File

@ -23,7 +23,6 @@
namespace
{
template <typename DeviceAdapter>
class DeduceCellSet
{
mutable vtkm::worklet::Tetrahedralize Worklet;
@ -57,16 +56,15 @@ inline VTKM_CONT Tetrahedralize::Tetrahedralize()
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Tetrahedralize::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
vtkm::cont::CellSetSingleType<> outCellSet;
DeduceCellSet<DeviceAdapter> tetrahedralize(this->Worklet, outCellSet);
DeduceCellSet tetrahedralize(this->Worklet, outCellSet);
vtkm::cont::CastAndCall(vtkm::filter::ApplyPolicy(cells, policy), tetrahedralize);
@ -78,13 +76,12 @@ inline VTKM_CONT vtkm::cont::DataSet Tetrahedralize::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool Tetrahedralize::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
// point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField())
@ -96,7 +93,7 @@ inline VTKM_CONT bool Tetrahedralize::DoMapField(
// cell data must be scattered to the cells created per input cell
if (fieldMeta.IsCellField())
{
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessCellField(input, device);
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessCellField(input);
result.AddField(fieldMeta.AsField(output));
return true;

10
vtkm/filter/Threshold.h
View File

@ -54,21 +54,19 @@ public:
VTKM_CONT
vtkm::Float64 GetUpperThreshold() const { return this->UpperValue; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
double LowerValue;

19
vtkm/filter/Threshold.hxx
View File

@ -65,23 +65,19 @@ inline VTKM_CONT Threshold::Threshold()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Threshold::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
DeviceAdapter)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
//get the cells and coordinates of the dataset
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
ThresholdRange predicate(this->GetLowerThreshold(), this->GetUpperThreshold());
vtkm::cont::DynamicCellSet cellOut = this->Worklet.Run(vtkm::filter::ApplyPolicy(cells, policy),
field,
fieldMeta.GetAssociation(),
predicate,
DeviceAdapter());
vtkm::cont::DynamicCellSet cellOut = this->Worklet.Run(
vtkm::filter::ApplyPolicy(cells, policy), field, fieldMeta.GetAssociation(), predicate);
vtkm::cont::DataSet output;
output.AddCellSet(cellOut);
@ -90,12 +86,11 @@ inline VTKM_CONT vtkm::cont::DataSet Threshold::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool Threshold::DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
DeviceAdapter device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
if (fieldMeta.IsPointField())
{
@ -105,7 +100,7 @@ inline VTKM_CONT bool Threshold::DoMapField(vtkm::cont::DataSet& result,
}
else if (fieldMeta.IsCellField())
{
vtkm::cont::ArrayHandle<T> out = this->Worklet.ProcessCellField(input, device);
vtkm::cont::ArrayHandle<T> out = this->Worklet.ProcessCellField(input);
result.AddField(fieldMeta.AsField(out));
return true;
}

10
vtkm/filter/ThresholdPoints.h
View File

@ -60,21 +60,19 @@ public:
VTKM_CONT
void SetThresholdBetween(const vtkm::Float64 value1, const vtkm::Float64 value2);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
double LowerValue;

29
vtkm/filter/ThresholdPoints.hxx
View File

@ -145,13 +145,12 @@ inline VTKM_CONT void ThresholdPoints::SetThresholdBetween(const vtkm::Float64 v
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet ThresholdPoints::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// extract the input cell set
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
@ -170,18 +169,14 @@ inline VTKM_CONT vtkm::cont::DataSet ThresholdPoints::DoExecute(
{
case THRESHOLD_BELOW:
{
outCellSet = worklet.Run(vtkm::filter::ApplyPolicy(cells, policy),
field,
ValuesBelow(this->GetLowerThreshold()),
device);
outCellSet = worklet.Run(
vtkm::filter::ApplyPolicy(cells, policy), field, ValuesBelow(this->GetLowerThreshold()));
break;
}
case THRESHOLD_ABOVE:
{
outCellSet = worklet.Run(vtkm::filter::ApplyPolicy(cells, policy),
field,
ValuesAbove(this->GetUpperThreshold()),
device);
outCellSet = worklet.Run(
vtkm::filter::ApplyPolicy(cells, policy), field, ValuesAbove(this->GetUpperThreshold()));
break;
}
case THRESHOLD_BETWEEN:
@ -189,8 +184,7 @@ inline VTKM_CONT vtkm::cont::DataSet ThresholdPoints::DoExecute(
{
outCellSet = worklet.Run(vtkm::filter::ApplyPolicy(cells, policy),
field,
ValuesBetween(this->GetLowerThreshold(), this->GetUpperThreshold()),
device);
ValuesBetween(this->GetLowerThreshold(), this->GetUpperThreshold()));
break;
}
}
@ -204,7 +198,7 @@ inline VTKM_CONT vtkm::cont::DataSet ThresholdPoints::DoExecute(
if (this->CompactPoints)
{
this->Compactor.SetCompactPointFields(true);
return this->Compactor.DoExecute(output, GetCellSetSingleTypePolicy(policy), DeviceAdapter());
return this->Compactor.DoExecute(output, GetCellSetSingleTypePolicy(policy));
}
else
{
@ -213,20 +207,19 @@ inline VTKM_CONT vtkm::cont::DataSet ThresholdPoints::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool ThresholdPoints::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField())
{
if (this->CompactPoints)
{
return this->Compactor.DoMapField(result, input, fieldMeta, policy, DeviceAdapter());
return this->Compactor.DoMapField(result, input, fieldMeta, policy);
}
else
{

10
vtkm/filter/Triangulate.h
View File

@ -35,18 +35,16 @@ public:
VTKM_CONT
Triangulate();
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
// Map new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::worklet::Triangulate Worklet;

17
vtkm/filter/Triangulate.hxx
View File

@ -23,7 +23,6 @@
namespace
{
template <typename DeviceAdapter>
class DeduceCellSet
{
mutable vtkm::worklet::Triangulate Worklet;
@ -39,7 +38,7 @@ public:
template <typename CellSetType>
void operator()(const CellSetType& cellset) const
{
this->OutCellSet = Worklet.Run(cellset, DeviceAdapter());
this->OutCellSet = Worklet.Run(cellset);
}
};
}
@ -57,16 +56,15 @@ inline VTKM_CONT Triangulate::Triangulate()
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Triangulate::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
vtkm::cont::CellSetSingleType<> outCellSet;
DeduceCellSet<DeviceAdapter> triangulate(this->Worklet, outCellSet);
DeduceCellSet triangulate(this->Worklet, outCellSet);
vtkm::cont::CastAndCall(vtkm::filter::ApplyPolicy(cells, policy), triangulate);
@ -79,12 +77,11 @@ inline VTKM_CONT vtkm::cont::DataSet Triangulate::DoExecute(
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool Triangulate::DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
// point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField())
@ -96,7 +93,7 @@ inline VTKM_CONT bool Triangulate::DoMapField(vtkm::cont::DataSet& result,
// cell data must be scattered to the cells created per input cell
if (fieldMeta.IsCellField())
{
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessCellField(input, device);
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessCellField(input);
result.AddField(fieldMeta.AsField(output));
return true;

5
vtkm/filter/VectorMagnitude.h
View File

@ -35,12 +35,11 @@ public:
VTKM_CONT
VectorMagnitude();
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::worklet::Magnitude Worklet;

6
vtkm/filter/VectorMagnitude.hxx
View File

@ -37,19 +37,17 @@ inline VTKM_CONT VectorMagnitude::VectorMagnitude()
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet VectorMagnitude::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter&)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
using ReturnType = typename ::vtkm::detail::FloatingPointReturnType<T>::Type;
vtkm::cont::ArrayHandle<ReturnType> outArray;
vtkm::worklet::DispatcherMapField<vtkm::worklet::Magnitude> dispatcher(this->Worklet);
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(field, outArray);

10
vtkm/filter/VertexClustering.h
View File

@ -69,19 +69,17 @@ public:
VTKM_CONT
const vtkm::Id3& GetNumberOfDivisions() const { return this->NumberOfDivisions; }
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::worklet::VertexClustering Worklet;

17
vtkm/filter/VertexClustering.hxx
View File

@ -31,11 +31,10 @@ inline VTKM_CONT VertexClustering::VertexClustering()
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet VertexClustering::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag)
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
// todo this code needs to obey the policy for what storage types
// the output should use
@ -46,30 +45,28 @@ inline VTKM_CONT vtkm::cont::DataSet VertexClustering::DoExecute(
this->Worklet.Run(vtkm::filter::ApplyPolicyUnstructured(input.GetCellSet(), policy),
input.GetCoordinateSystem(),
bounds,
this->GetNumberOfDivisions(),
tag);
this->GetNumberOfDivisions());
return outDataSet;
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT bool VertexClustering::DoMapField(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
vtkm::filter::PolicyBase<DerivedPolicy>)
{
vtkm::cont::ArrayHandle<T> fieldArray;
if (fieldMeta.IsPointField())
{
fieldArray = this->Worklet.ProcessPointField(input, device);
fieldArray = this->Worklet.ProcessPointField(input);
}
else if (fieldMeta.IsCellField())
{
fieldArray = this->Worklet.ProcessCellField(input, device);
fieldArray = this->Worklet.ProcessCellField(input);
}
else
{

5
vtkm/filter/WarpScalar.h
View File

@ -131,13 +131,12 @@ public:
}
//@}
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
vtkm::worklet::WarpScalar Worklet;

Some files were not shown because too many files have changed in this diff Show More