Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-10-05 09:59:12 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
5fd3a18de0
vtk-m/vtkm/worklet/testing/UnitTestWorkletPointNeighborhood.cxx

357 lines
12 KiB
C++
Raw Normal View History

Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
conslidate the license statement
2019-04-15 23:24:21 +00:00
//
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/worklet/DispatcherPointNeighborhood.h>
#include <vtkm/worklet/WorkletPointNeighborhood.h>
#include <vtkm/worklet/ScatterIdentity.h>
#include <vtkm/worklet/ScatterUniform.h>
#include <vtkm/Math.h>
#include <vtkm/VecAxisAlignedPointCoordinates.h>
Get the 3D index from a BoundaryState in WorkletPointNeighborhood There are occasions when you need a worklet to opeate on 2D or 3D indices. Most worklets operate on 1D indices, which requires recomputing the 3D index in each worklet instance. A workaround is to use a worklet that does a 3D scheduling and pull the working index from that. The problem was that there was no easy way to get this 3D index. To provide this option, a feature was added to the `BoundaryState` class that can be provided by `WorkletPointNeighborhood`. Thus, to get a 3D index in a worklet, use the `WorkletPointNeighborhood`, add `Boundary` as an argument to the `ExecutionSignature`, and then call `GetCenterIndex` on the `BoundaryState` object passed to the worklet operator.
2023-05-27 21:22:49 +00:00
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/CellSetStructured.h>
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
#include <vtkm/cont/DataSet.h>
Move DeviceAdapterTag to vtkm/cont
2019-04-03 20:28:31 +00:00
#include <vtkm/cont/DeviceAdapterTag.h>
Get the 3D index from a BoundaryState in WorkletPointNeighborhood There are occasions when you need a worklet to opeate on 2D or 3D indices. Most worklets operate on 1D indices, which requires recomputing the 3D index in each worklet instance. A workaround is to use a worklet that does a 3D scheduling and pull the working index from that. The problem was that there was no easy way to get this 3D index. To provide this option, a feature was added to the `BoundaryState` class that can be provided by `WorkletPointNeighborhood`. Thus, to get a 3D index in a worklet, use the `WorkletPointNeighborhood`, add `Boundary` as an argument to the `ExecutionSignature`, and then call `GetCenterIndex` on the `BoundaryState` object passed to the worklet operator.
2023-05-27 21:22:49 +00:00
#include <vtkm/cont/Invoker.h>
Fix deprecation warning in WorkletCellNeighborhood There was a use of a deprecated method buried in a support class of `WorkletCellNeighborhood`. This fixes that deprecation and also adds a missing test for `WorkletCellNeighborhood` to prevent such things in the future.
2024-09-24 17:01:21 +00:00
#include <vtkm/cont/RuntimeDeviceTracker.h>
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/cont/testing/Testing.h>
namespace test_pointneighborhood
{
Change WorkletPointNeighborhood to specify neighborhood at runtime Previously, WorkletPointNeighborhood had a template argument to select the size of the neighborhood. This change removes that template argument. Instead, the vtkm::exec::arg::BoundaryState methods now take in a size parameter when determining when it overlaps the boundary. If in the future we want to add the ability to select the neighborhood size at compile-time (for performance reasons), I suggest adding this template argument to the OnBoundary tag for ExecutionSignature.
2018-11-18 17:41:13 +00:00
struct MaxNeighborValue : public vtkm::worklet::WorkletPointNeighborhood
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
Run the update-control-signature-tags.sh script
2019-01-10 18:59:25 +00:00
using ControlSignature = void(FieldInNeighborhood neighbors, CellSetIn, FieldOut maxV);
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
Rename boundary classes Did a bit of renaming of the support classes used for WorkletPointNeighborhood. First, the OnBoundary tag is changed to Boundary to match other tags and reflect some changes in the resulting methods. Also moved the BoundaryState and Neighborhood classes from vtkm::exec::arg to vtkm::exec to be more accessible. Finally, the Neighborhood class name was changed to FieldNeighborhood to be more specific on what role this class plays with neighborhood.
2018-12-03 19:44:17 +00:00
using ExecutionSignature = void(Boundary, _1, _3);
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
//verify input domain can be something other than first parameter
vtkm prefers 'using' over typedef.
2018-02-22 13:29:13 +00:00
using InputDomain = _2;
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
template <typename FieldIn, typename FieldOut>
Rename boundary classes Did a bit of renaming of the support classes used for WorkletPointNeighborhood. First, the OnBoundary tag is changed to Boundary to match other tags and reflect some changes in the resulting methods. Also moved the BoundaryState and Neighborhood classes from vtkm::exec::arg to vtkm::exec to be more accessible. Finally, the Neighborhood class name was changed to FieldNeighborhood to be more specific on what role this class plays with neighborhood.
2018-12-03 19:44:17 +00:00
VTKM_EXEC void operator()(const vtkm::exec::BoundaryState& boundary,
const vtkm::exec::FieldNeighborhood<FieldIn>& inputField,
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
FieldOut& output) const
{
using ValueType = typename FieldIn::ValueType;
auto* nboundary = inputField.Boundary;
Add methods to BoundaryState to query specific offsets. The existing functionality worked on radii, but it's helpful to know if a specific sample location will be in bounds, too.
2019-07-19 14:42:29 +00:00
if (!(nboundary->IsRadiusInXBoundary(1) == boundary.IsRadiusInXBoundary(1)))
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
this->RaiseError("Got invalid XPos boundary state");
}
Add methods to BoundaryState to query specific offsets. The existing functionality worked on radii, but it's helpful to know if a specific sample location will be in bounds, too.
2019-07-19 14:42:29 +00:00
if (!(nboundary->IsRadiusInYBoundary(1) == boundary.IsRadiusInYBoundary(1)))
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
this->RaiseError("Got invalid YPos boundary state");
}
Add methods to BoundaryState to query specific offsets. The existing functionality worked on radii, but it's helpful to know if a specific sample location will be in bounds, too.
2019-07-19 14:42:29 +00:00
if (!(nboundary->IsRadiusInZBoundary(1) == boundary.IsRadiusInZBoundary(1)))
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
this->RaiseError("Got invalid ZPos boundary state");
}
Add methods to BoundaryState to query specific offsets. The existing functionality worked on radii, but it's helpful to know if a specific sample location will be in bounds, too.
2019-07-19 14:42:29 +00:00
if (!(nboundary->IsRadiusInBoundary(1) == boundary.IsRadiusInBoundary(1)))
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
Change WorkletPointNeighborhood to specify neighborhood at runtime Previously, WorkletPointNeighborhood had a template argument to select the size of the neighborhood. This change removes that template argument. Instead, the vtkm::exec::arg::BoundaryState methods now take in a size parameter when determining when it overlaps the boundary. If in the future we want to add the ability to select the neighborhood size at compile-time (for performance reasons), I suggest adding this template argument to the OnBoundary tag for ExecutionSignature.
2018-11-18 17:41:13 +00:00
this->RaiseError("Got invalid boundary state");
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
}
Add methods to BoundaryState to query specific offsets. The existing functionality worked on radii, but it's helpful to know if a specific sample location will be in bounds, too.
2019-07-19 14:42:29 +00:00
if (nboundary->IsRadiusInXBoundary(1) !=
(boundary.IsNeighborInXBoundary(-1) && boundary.IsNeighborInXBoundary(1)))
{
this->RaiseError("Neighbor/Radius boundary mismatch in X dimension.");
}
if (nboundary->IsRadiusInYBoundary(1) !=
(boundary.IsNeighborInYBoundary(-1) && boundary.IsNeighborInYBoundary(1)))
{
this->RaiseError("Neighbor/Radius boundary mismatch in Y dimension.");
}
if (nboundary->IsRadiusInZBoundary(1) !=
(boundary.IsNeighborInZBoundary(-1) && boundary.IsNeighborInZBoundary(1)))
{
this->RaiseError("Neighbor/Radius boundary mismatch in Z dimension.");
}
if (nboundary->IsRadiusInBoundary(1) !=
(boundary.IsNeighborInBoundary({ -1 }) && boundary.IsNeighborInBoundary({ 1 })))
{
this->RaiseError("Neighbor/Radius boundary mismatch.");
}
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
Change WorkletPointNeighborhood to specify neighborhood at runtime Previously, WorkletPointNeighborhood had a template argument to select the size of the neighborhood. This change removes that template argument. Instead, the vtkm::exec::arg::BoundaryState methods now take in a size parameter when determining when it overlaps the boundary. If in the future we want to add the ability to select the neighborhood size at compile-time (for performance reasons), I suggest adding this template argument to the OnBoundary tag for ExecutionSignature.
2018-11-18 17:41:13 +00:00
auto minNeighbors = boundary.MinNeighborIndices(1);
auto maxNeighbors = boundary.MaxNeighborIndices(1);
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
ValueType maxV = inputField.Get(0, 0, 0); //our value
Change WorkletPointNeighborhood to specify neighborhood at runtime Previously, WorkletPointNeighborhood had a template argument to select the size of the neighborhood. This change removes that template argument. Instead, the vtkm::exec::arg::BoundaryState methods now take in a size parameter when determining when it overlaps the boundary. If in the future we want to add the ability to select the neighborhood size at compile-time (for performance reasons), I suggest adding this template argument to the OnBoundary tag for ExecutionSignature.
2018-11-18 17:41:13 +00:00
for (vtkm::IdComponent k = minNeighbors[2]; k <= maxNeighbors[2]; ++k)
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
Change WorkletPointNeighborhood to specify neighborhood at runtime Previously, WorkletPointNeighborhood had a template argument to select the size of the neighborhood. This change removes that template argument. Instead, the vtkm::exec::arg::BoundaryState methods now take in a size parameter when determining when it overlaps the boundary. If in the future we want to add the ability to select the neighborhood size at compile-time (for performance reasons), I suggest adding this template argument to the OnBoundary tag for ExecutionSignature.
2018-11-18 17:41:13 +00:00
for (vtkm::IdComponent j = minNeighbors[1]; j <= maxNeighbors[1]; ++j)
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
Change WorkletPointNeighborhood to specify neighborhood at runtime Previously, WorkletPointNeighborhood had a template argument to select the size of the neighborhood. This change removes that template argument. Instead, the vtkm::exec::arg::BoundaryState methods now take in a size parameter when determining when it overlaps the boundary. If in the future we want to add the ability to select the neighborhood size at compile-time (for performance reasons), I suggest adding this template argument to the OnBoundary tag for ExecutionSignature.
2018-11-18 17:41:13 +00:00
for (vtkm::IdComponent i = minNeighbors[0]; i <= maxNeighbors[0]; ++i)
{
maxV = vtkm::Max(maxV, inputField.Get(i, j, k));
}
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
}
}
output = static_cast<FieldOut>(maxV);
}
};
Change WorkletPointNeighborhood to specify neighborhood at runtime Previously, WorkletPointNeighborhood had a template argument to select the size of the neighborhood. This change removes that template argument. Instead, the vtkm::exec::arg::BoundaryState methods now take in a size parameter when determining when it overlaps the boundary. If in the future we want to add the ability to select the neighborhood size at compile-time (for performance reasons), I suggest adding this template argument to the OnBoundary tag for ExecutionSignature.
2018-11-18 17:41:13 +00:00
struct ScatterIdentityNeighbor : public vtkm::worklet::WorkletPointNeighborhood
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
Run the update-control-signature-tags.sh script
2019-01-10 18:59:25 +00:00
using ControlSignature = void(CellSetIn topology, FieldIn pointCoords);
Change function signatures to use 'using' aliases. Also cleaned up some lingering type typedefs.
2018-05-25 21:18:41 +00:00
using ExecutionSignature =
void(_2, WorkIndex, InputIndex, OutputIndex, ThreadIndices, VisitIndex);
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
VTKM_CONT
ScatterIdentityNeighbor() {}
template <typename T>
VTKM_EXEC void operator()(
const vtkm::Vec<T, 3>& vtkmNotUsed(coords),
const vtkm::Id& workIndex,
const vtkm::Id& inputIndex,
const vtkm::Id& outputIndex,
Change WorkletPointNeighborhood to specify neighborhood at runtime Previously, WorkletPointNeighborhood had a template argument to select the size of the neighborhood. This change removes that template argument. Instead, the vtkm::exec::arg::BoundaryState methods now take in a size parameter when determining when it overlaps the boundary. If in the future we want to add the ability to select the neighborhood size at compile-time (for performance reasons), I suggest adding this template argument to the OnBoundary tag for ExecutionSignature.
2018-11-18 17:41:13 +00:00
const vtkm::exec::arg::ThreadIndicesPointNeighborhood& vtkmNotUsed(threadIndices),
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
const vtkm::Id& visitIndex) const
{
if (workIndex != inputIndex)
{
this->RaiseError("Got wrong input value.");
}
if (outputIndex != workIndex)
{
this->RaiseError("Got work and output index don't match.");
}
if (visitIndex != 0)
{
this->RaiseError("Got wrong visit value1.");
}
}
using ScatterType = vtkm::worklet::ScatterIdentity;
};
Change WorkletPointNeighborhood to specify neighborhood at runtime Previously, WorkletPointNeighborhood had a template argument to select the size of the neighborhood. This change removes that template argument. Instead, the vtkm::exec::arg::BoundaryState methods now take in a size parameter when determining when it overlaps the boundary. If in the future we want to add the ability to select the neighborhood size at compile-time (for performance reasons), I suggest adding this template argument to the OnBoundary tag for ExecutionSignature.
2018-11-18 17:41:13 +00:00
struct ScatterUniformNeighbor : public vtkm::worklet::WorkletPointNeighborhood
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
Run the update-control-signature-tags.sh script
2019-01-10 18:59:25 +00:00
using ControlSignature = void(CellSetIn topology, FieldIn pointCoords);
Change function signatures to use 'using' aliases. Also cleaned up some lingering type typedefs.
2018-05-25 21:18:41 +00:00
using ExecutionSignature =
void(_2, WorkIndex, InputIndex, OutputIndex, ThreadIndices, VisitIndex);
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
VTKM_CONT
ScatterUniformNeighbor() {}
template <typename T>
VTKM_EXEC void operator()(
const vtkm::Vec<T, 3>& vtkmNotUsed(coords),
const vtkm::Id& workIndex,
const vtkm::Id& inputIndex,
const vtkm::Id& outputIndex,
Change WorkletPointNeighborhood to specify neighborhood at runtime Previously, WorkletPointNeighborhood had a template argument to select the size of the neighborhood. This change removes that template argument. Instead, the vtkm::exec::arg::BoundaryState methods now take in a size parameter when determining when it overlaps the boundary. If in the future we want to add the ability to select the neighborhood size at compile-time (for performance reasons), I suggest adding this template argument to the OnBoundary tag for ExecutionSignature.
2018-11-18 17:41:13 +00:00
const vtkm::exec::arg::ThreadIndicesPointNeighborhood& vtkmNotUsed(threadIndices),
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
const vtkm::Id& visitIndex) const
{
if ((workIndex / 3) != inputIndex)
{
this->RaiseError("Got wrong input value.");
}
if (outputIndex != workIndex)
{
this->RaiseError("Got work and output index don't match.");
}
if ((workIndex % 3) != visitIndex)
{
this->RaiseError("Got wrong visit value2.");
}
}
Move Scatter from Worklet to Dispatcher Previously, when a Worklet needed a scatter, the scatter object was stored in the Worklet object. That was problematic because that means the Scatter, which is a control object, was shoved into the execution environment. To prevent that, move the Scatter into the Dispatcher object. The worklet still declares a ScatterType alias, but no longer has a GetScatter method. Instead, the Dispatcher now takes a Scatter object in its constructor. If using the default scatter (ScatterIdentity), the default constructor is used. If using another type of Scatter that requires data to set up its state, then the caller of the worklet needs to provide that to the dispatcher. For convenience, worklets are encouraged to have a MakeScatter method to help construct a proper scatter object.
2018-04-27 04:43:51 +00:00
using ScatterType = vtkm::worklet::ScatterUniform<3>;
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
};
Get the 3D index from a BoundaryState in WorkletPointNeighborhood There are occasions when you need a worklet to opeate on 2D or 3D indices. Most worklets operate on 1D indices, which requires recomputing the 3D index in each worklet instance. A workaround is to use a worklet that does a 3D scheduling and pull the working index from that. The problem was that there was no easy way to get this 3D index. To provide this option, a feature was added to the `BoundaryState` class that can be provided by `WorkletPointNeighborhood`. Thus, to get a 3D index in a worklet, use the `WorkletPointNeighborhood`, add `Boundary` as an argument to the `ExecutionSignature`, and then call `GetCenterIndex` on the `BoundaryState` object passed to the worklet operator.
2023-05-27 21:22:49 +00:00
// An example of using WorkletPointNeighborhood to iterate over a structured 3D cell
// domain rather than look at an actual neighborhood. It reduces a domain by subsampling
// every other item in the input field.
struct Subsample : public vtkm::worklet::WorkletPointNeighborhood
{
using ControlSignature =
void(WholeCellSetIn<vtkm::TopologyElementTagPoint, vtkm::TopologyElementTagCell> inputTopology,
WholeArrayIn inputField,
CellSetIn outputTopology,
FieldOut sampledField);
using ExecutionSignature = void(_1, _2, Boundary, _4);
using InputDomain = _3;
template <typename InFieldPortal, typename T>
VTKM_EXEC void operator()(const vtkm::exec::ConnectivityStructured<vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell,
3>& inputTopology,
const InFieldPortal& inFieldPortal,
const vtkm::exec::BoundaryState& boundary,
T& sample) const
{
sample =
inFieldPortal.Get(inputTopology.LogicalToFlatVisitIndex(2 * boundary.GetCenterIndex()));
}
};
} // namespace test_pointneighborhood
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
namespace
{
static void TestMaxNeighborValue();
static void TestScatterIdentityNeighbor();
static void TestScatterUnfiormNeighbor();
Get the 3D index from a BoundaryState in WorkletPointNeighborhood There are occasions when you need a worklet to opeate on 2D or 3D indices. Most worklets operate on 1D indices, which requires recomputing the 3D index in each worklet instance. A workaround is to use a worklet that does a 3D scheduling and pull the working index from that. The problem was that there was no easy way to get this 3D index. To provide this option, a feature was added to the `BoundaryState` class that can be provided by `WorkletPointNeighborhood`. Thus, to get a 3D index in a worklet, use the `WorkletPointNeighborhood`, add `Boundary` as an argument to the `ExecutionSignature`, and then call `GetCenterIndex` on the `BoundaryState` object passed to the worklet operator.
2023-05-27 21:22:49 +00:00
static void TestIndexing();
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
Merge worklet testing executables into a device dependent shared library VTK-m has been updated to replace old per device worklet testing executables with a device dependent shared library so that it's able to accept a device adapter at runtime. Meanwhile, it updates the testing infrastructure APIs. vtkm::cont::testing::Run function would call ForceDevice when needed and if users need the device adapter info at runtime, RunOnDevice function would pass the adapter into the functor. Optional Parser is bumped from 1.3 to 1.7.
2018-10-17 19:17:29 +00:00
void TestWorkletPointNeighborhood(vtkm::cont::DeviceAdapterId id)
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
Merge worklet testing executables into a device dependent shared library VTK-m has been updated to replace old per device worklet testing executables with a device dependent shared library so that it's able to accept a device adapter at runtime. Meanwhile, it updates the testing infrastructure APIs. vtkm::cont::testing::Run function would call ForceDevice when needed and if users need the device adapter info at runtime, RunOnDevice function would pass the adapter into the functor. Optional Parser is bumped from 1.3 to 1.7.
2018-10-17 19:17:29 +00:00
std::cout << "Testing Point Neighborhood Worklet on device adapter: " << id.GetName()
<< std::endl;
Fix deprecation warning in WorkletCellNeighborhood There was a use of a deprecated method buried in a support class of `WorkletCellNeighborhood`. This fixes that deprecation and also adds a missing test for `WorkletCellNeighborhood` to prevent such things in the future.
2024-09-24 17:01:21 +00:00
vtkm::cont::ScopedRuntimeDeviceTracker deviceScope(id);
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
TestMaxNeighborValue();
TestScatterIdentityNeighbor();
TestScatterUnfiormNeighbor();
Get the 3D index from a BoundaryState in WorkletPointNeighborhood There are occasions when you need a worklet to opeate on 2D or 3D indices. Most worklets operate on 1D indices, which requires recomputing the 3D index in each worklet instance. A workaround is to use a worklet that does a 3D scheduling and pull the working index from that. The problem was that there was no easy way to get this 3D index. To provide this option, a feature was added to the `BoundaryState` class that can be provided by `WorkletPointNeighborhood`. Thus, to get a 3D index in a worklet, use the `WorkletPointNeighborhood`, add `Boundary` as an argument to the `ExecutionSignature`, and then call `GetCenterIndex` on the `BoundaryState` object passed to the worklet operator.
2023-05-27 21:22:49 +00:00
TestIndexing();
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
}
static void TestMaxNeighborValue()
{
Fix deprecation warning in WorkletCellNeighborhood There was a use of a deprecated method buried in a support class of `WorkletCellNeighborhood`. This fixes that deprecation and also adds a missing test for `WorkletCellNeighborhood` to prevent such things in the future.
2024-09-24 17:01:21 +00:00
std::cout << "Testing MaxNeighborValue worklet" << std::endl;
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::worklet::DispatcherPointNeighborhood<::test_pointneighborhood::MaxNeighborValue> dispatcher;
vtkm::cont::ArrayHandle<vtkm::Float32> output;
vtkm::cont::DataSet dataSet3D = testDataSet.Make3DUniformDataSet0();
Fix deprecation warnings There was an error that caused deprecation warnings in VTK-m to be suppressed, which meant that many uses of deprecated features went unnoticed. This fixes those deprecation warnings. The majority of the warnings were caused by the use of the deprecated `Cast`, `CopyTo`, and `ResetTypes` methods of `UnknownArrayHandle` (or `VariantArrayHandle`). Both `Cast` and `CopyTo` have been subsumed by `AsArrayHandle` (to make the functionality more clear). `ResetTypes` now requires a second template argument to define the storage types to try. Also fixed some issues with `SerializableField` being deprecated. This class is no longer necessary because `Field` can now be directly serialized.
2021-01-25 17:36:56 +00:00
dispatcher.Invoke(dataSet3D.GetField("pointvar")
.GetData()
.ResetTypes<vtkm::TypeListFieldScalar, VTKM_DEFAULT_STORAGE_LIST>(),
dataSet3D.GetCellSet(),
output);
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
vtkm::Float32 expected3D[18] = { 110.3f, 120.3f, 120.3f, 110.3f, 120.3f, 120.3f,
170.5f, 180.5f, 180.5f, 170.5f, 180.5f, 180.5f,
170.5f, 180.5f, 180.5f, 170.5f, 180.5f, 180.5f };
for (int i = 0; i < 18; ++i)
{
Use new ways to get array portal in control environment Also fix deadlocks that occur when portals are not destroyed in time.
2020-01-28 19:14:32 +00:00
VTKM_TEST_ASSERT(test_equal(output.ReadPortal().Get(i), expected3D[i]),
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
"Wrong result for MaxNeighborValue worklet");
}
vtkm::cont::DataSet dataSet2D = testDataSet.Make2DUniformDataSet1();
Fix deprecation warnings There was an error that caused deprecation warnings in VTK-m to be suppressed, which meant that many uses of deprecated features went unnoticed. This fixes those deprecation warnings. The majority of the warnings were caused by the use of the deprecated `Cast`, `CopyTo`, and `ResetTypes` methods of `UnknownArrayHandle` (or `VariantArrayHandle`). Both `Cast` and `CopyTo` have been subsumed by `AsArrayHandle` (to make the functionality more clear). `ResetTypes` now requires a second template argument to define the storage types to try. Also fixed some issues with `SerializableField` being deprecated. This class is no longer necessary because `Field` can now be directly serialized.
2021-01-25 17:36:56 +00:00
dispatcher.Invoke(dataSet2D.GetField("pointvar")
.GetData()
.ResetTypes<vtkm::TypeListFieldScalar, VTKM_DEFAULT_STORAGE_LIST>(),
dataSet2D.GetCellSet(),
output);
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
vtkm::Float32 expected2D[25] = { 100.0f, 100.0f, 78.0f, 49.0f, 33.0f, 100.0f, 100.0f,
78.0f, 50.0f, 48.0f, 94.0f, 94.0f, 91.0f, 91.0f,
91.0f, 52.0f, 52.0f, 91.0f, 91.0f, 91.0f, 12.0f,
51.0f, 91.0f, 91.0f, 91.0f };
for (int i = 0; i < 25; ++i)
{
Use new ways to get array portal in control environment Also fix deadlocks that occur when portals are not destroyed in time.
2020-01-28 19:14:32 +00:00
VTKM_TEST_ASSERT(test_equal(output.ReadPortal().Get(i), expected2D[i]),
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
"Wrong result for MaxNeighborValue worklet");
}
}
static void TestScatterIdentityNeighbor()
{
std::cout << "Testing identity scatter with PointNeighborhood" << std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::worklet::DispatcherPointNeighborhood<::test_pointneighborhood::ScatterIdentityNeighbor>
dispatcher;
vtkm::cont::DataSet dataSet3D = testDataSet.Make3DUniformDataSet0();
dispatcher.Invoke(dataSet3D.GetCellSet(), dataSet3D.GetCoordinateSystem());
vtkm::cont::DataSet dataSet2D = testDataSet.Make2DUniformDataSet0();
dispatcher.Invoke(dataSet2D.GetCellSet(), dataSet2D.GetCoordinateSystem());
}
static void TestScatterUnfiormNeighbor()
{
std::cout << "Testing uniform scatter with PointNeighborhood" << std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::worklet::DispatcherPointNeighborhood<::test_pointneighborhood::ScatterUniformNeighbor>
dispatcher;
vtkm::cont::DataSet dataSet3D = testDataSet.Make3DUniformDataSet0();
dispatcher.Invoke(dataSet3D.GetCellSet(), dataSet3D.GetCoordinateSystem());
vtkm::cont::DataSet dataSet2D = testDataSet.Make2DUniformDataSet0();
dispatcher.Invoke(dataSet2D.GetCellSet(), dataSet2D.GetCoordinateSystem());
}
Get the 3D index from a BoundaryState in WorkletPointNeighborhood There are occasions when you need a worklet to opeate on 2D or 3D indices. Most worklets operate on 1D indices, which requires recomputing the 3D index in each worklet instance. A workaround is to use a worklet that does a 3D scheduling and pull the working index from that. The problem was that there was no easy way to get this 3D index. To provide this option, a feature was added to the `BoundaryState` class that can be provided by `WorkletPointNeighborhood`. Thus, to get a 3D index in a worklet, use the `WorkletPointNeighborhood`, add `Boundary` as an argument to the `ExecutionSignature`, and then call `GetCenterIndex` on the `BoundaryState` object passed to the worklet operator.
2023-05-27 21:22:49 +00:00
static void TestIndexing()
{
std::cout << "Testing using PointNeighborhood for 3D indexing." << std::endl;
constexpr vtkm::Id outDim = 4;
constexpr vtkm::Id inDim = outDim * 2;
vtkm::cont::CellSetStructured<3> inCellSet;
inCellSet.SetPointDimensions({ inDim });
vtkm::cont::CellSetStructured<3> outCellSet;
outCellSet.SetPointDimensions({ outDim });
Mark ArrayHandle constructors taking buffers, as explicit This resolves a compiler ambiguity I hit during development. In my case, I created an `ArrayHandleDecorator` with one of the arrays being an `ArrayHandleTransform`. The ambiguity occurs in function `DecoratorStorageTraits<...>::BuffersToArray`, here an `ArrayHandleTransform` is constructed using buffers (`std::vector<vtkm::cont::internal::Buffer>`) This constructor is not defined for `ArrayHandleTransform`, but it's defined for its superclass (`vtkm::cont::ArrayHandle`). `ArrayHandleTransform` does have a non-explicit constructor that takes the array to be transformed and the transform-functor as parameters, where the later has a default value. This produces the following ambiguous options for the compiler: 1. Create a "to-be-transformed" ArrayHandle instance using the buffers, call the `ArrayHandleTransform` constructor with this array with the defaulted functor parameter. 2. Create the superclass instance using the buffer and call the `ArrayHandleTransform` constructor that takes the superclass. In this situation, option 2 is the correct choice. The ambiguity is resolved by marking the constructors that take buffers as explicit. These constructors are also added for the derived classess via the `VTK_M_ARRAY_HANDLE_SUBCLASS_IMPL` macro.
2023-06-05 13:21:12 +00:00
vtkm::cont::ArrayHandleUniformPointCoordinates inField(vtkm::Id3{ inDim });
Get the 3D index from a BoundaryState in WorkletPointNeighborhood There are occasions when you need a worklet to opeate on 2D or 3D indices. Most worklets operate on 1D indices, which requires recomputing the 3D index in each worklet instance. A workaround is to use a worklet that does a 3D scheduling and pull the working index from that. The problem was that there was no easy way to get this 3D index. To provide this option, a feature was added to the `BoundaryState` class that can be provided by `WorkletPointNeighborhood`. Thus, to get a 3D index in a worklet, use the `WorkletPointNeighborhood`, add `Boundary` as an argument to the `ExecutionSignature`, and then call `GetCenterIndex` on the `BoundaryState` object passed to the worklet operator.
2023-05-27 21:22:49 +00:00
vtkm::cont::ArrayHandle<vtkm::Vec3f> outField;
vtkm::cont::Invoker invoke;
invoke(::test_pointneighborhood::Subsample{}, inCellSet, inField, outCellSet, outField);
VTKM_TEST_ASSERT(outField.GetNumberOfValues() == (outDim * outDim * outDim));
vtkm::Id flatIndex = 0;
vtkm::Id3 IJK;
auto outFieldPortal = outField.WritePortal();
for (IJK[2] = 0; IJK[2] < outDim; ++IJK[2])
{
for (IJK[1] = 0; IJK[1] < outDim; ++IJK[1])
{
for (IJK[0] = 0; IJK[0] < outDim; ++IJK[0])
{
vtkm::Vec3f computed = outFieldPortal.Get(flatIndex);
VTKM_TEST_ASSERT(test_equal(computed, 2 * IJK));
++flatIndex;
}
}
}
}
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
} // anonymous namespace
Fix deprecation warning in WorkletCellNeighborhood There was a use of a deprecated method buried in a support class of `WorkletCellNeighborhood`. This fixes that deprecation and also adds a missing test for `WorkletCellNeighborhood` to prevent such things in the future.
2024-09-24 17:01:21 +00:00
int UnitTestWorkletPointNeighborhood(int argc, char* argv[])
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
{
Merge worklet testing executables into a device dependent shared library VTK-m has been updated to replace old per device worklet testing executables with a device dependent shared library so that it's able to accept a device adapter at runtime. Meanwhile, it updates the testing infrastructure APIs. vtkm::cont::testing::Run function would call ForceDevice when needed and if users need the device adapter info at runtime, RunOnDevice function would pass the adapter into the functor. Optional Parser is bumped from 1.3 to 1.7.
2018-10-17 19:17:29 +00:00
return vtkm::cont::testing::Testing::RunOnDevice(TestWorkletPointNeighborhood, argc, argv);
Adds WorkletPointNeighborhood and DispatcherPointNeighborhood types. VTK-m is now able to run algorithms on structured points that require the local point neighbors in a highly efficient manner.
2017-07-11 12:33:56 +00:00
}
Reference in New Issue Copy Permalink