mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-10-05 01:49:02 +00:00
Improvements to moving data into ArrayHandle
We have made several improvements to adding data into an `ArrayHandle`. ## Moving data from an `std::vector` For numerous reasons, it is convenient to define data in a `std::vector` and then wrap that into an `ArrayHandle`. It is often the case that an `std::vector` is filled and then becomes unused once it is converted to an `ArrayHandle`. In this case, what we really want is to pass the data off to the `ArrayHandle` so that the `ArrayHandle` is now managing the data and not the `std::vector`. C++11 has a mechanism to do this: move semantics. You can now pass variables to functions as an "rvalue" (right-hand value). When something is passed as an rvalue, it can pull state out of that variable and move it somewhere else. `std::vector` implements this movement so that an rvalue can be moved to another `std::vector` without actually copying the data. `make_ArrayHandle` now also takes advantage of this feature to move rvalue `std::vector`s. There is a special form of `make_ArrayHandle` named `make_ArrayHandleMove` that takes an rvalue. There is also a special overload of `make_ArrayHandle` itself that handles an rvalue `vector`. (However, using the explicit move version is better if you want to make sure the data is actually moved.) ## Make `ArrayHandle` from initalizer list A common use case for using `std::vector` (particularly in our unit tests) is to quickly add an initalizer list into an `ArrayHandle`. Now you can by simply passing an initializer list to `make_ArrayHandle`. ## Deprecated `make_ArrayHandle` with default shallow copy For historical reasons, passing an `std::vector` or a pointer to `make_ArrayHandle` does a shallow copy (i.e. `CopyFlag` defaults to `Off`). Although more efficient, this mode is inherintly unsafe, and making it the default is asking for trouble. To combat this, calling `make_ArrayHandle` without a copy flag is deprecated. In this way, if you wish to do the faster but more unsafe creation of an `ArrayHandle` you should explicitly express that. This requried quite a few changes through the VTK-m source (particularly in the tests). ## Similar changes to `Field` `vtkm::cont::Field` has a `make_Field` helper function that is similar to `make_ArrayHandle`. It also features the ability to create fields from `std::vector`s and C arrays. It also likewise had the same unsafe behavior by default of not copying from the source of the arrays. That behavior has similarly been depreciated. You now have to specify a copy flag. The ability to construct a `Field` from an initializer list of values has also been added.
This commit is contained in:
parent
744edbf428
commit
d1a4aecc59
@ -97,8 +97,8 @@ void BenchContToExecRead(benchmark::State& state)
|
||||
state.SetLabel(desc.str());
|
||||
}
|
||||
|
||||
std::vector<ValueType> vec(static_cast<std::size_t>(numValues));
|
||||
ArrayType array = vtkm::cont::make_ArrayHandle(vec);
|
||||
std::vector<ValueType> vec(static_cast<std::size_t>(numValues), 2);
|
||||
ArrayType array = vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::cont::Invoker invoker{ device };
|
||||
vtkm::cont::Timer timer{ device };
|
||||
@ -181,8 +181,8 @@ void BenchContToExecReadWrite(benchmark::State& state)
|
||||
state.SetLabel(desc.str());
|
||||
}
|
||||
|
||||
std::vector<ValueType> vec(static_cast<std::size_t>(numValues));
|
||||
ArrayType array = vtkm::cont::make_ArrayHandle(vec);
|
||||
std::vector<ValueType> vec(static_cast<std::size_t>(numValues), 2);
|
||||
ArrayType array = vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::cont::Invoker invoker{ device };
|
||||
vtkm::cont::Timer timer{ device };
|
||||
@ -223,8 +223,8 @@ void BenchRoundTripRead(benchmark::State& state)
|
||||
state.SetLabel(desc.str());
|
||||
}
|
||||
|
||||
std::vector<ValueType> vec(static_cast<std::size_t>(numValues));
|
||||
ArrayType array = vtkm::cont::make_ArrayHandle(vec);
|
||||
std::vector<ValueType> vec(static_cast<std::size_t>(numValues), 2);
|
||||
ArrayType array = vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::cont::Invoker invoker{ device };
|
||||
vtkm::cont::Timer timer{ device };
|
||||
@ -277,7 +277,7 @@ void BenchRoundTripReadWrite(benchmark::State& state)
|
||||
}
|
||||
|
||||
std::vector<ValueType> vec(static_cast<std::size_t>(numValues));
|
||||
ArrayType array = vtkm::cont::make_ArrayHandle(vec);
|
||||
ArrayType array = vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::cont::Invoker invoker{ device };
|
||||
vtkm::cont::Timer timer{ device };
|
||||
|
120
docs/changelog/move-std-vector.md
Normal file
120
docs/changelog/move-std-vector.md
Normal file
@ -0,0 +1,120 @@
|
||||
# Improvements to moving data into ArrayHandle
|
||||
|
||||
We have made several improvements to adding data into an `ArrayHandle`.
|
||||
|
||||
## Moving data from an `std::vector`
|
||||
|
||||
For numerous reasons, it is convenient to define data in a `std::vector`
|
||||
and then wrap that into an `ArrayHandle`. There are two obvious ways to do
|
||||
this. First, you could deep copy the data into an `ArrayHandle`, which has
|
||||
obvious drawbacks. Second, you could take the pointer for the data in the
|
||||
`std::vector` and use that as user-allocated memory in the `ArrayHandle`
|
||||
without deep copying it. The problem with this shallow copy is that it is
|
||||
unsafe. If the `std::vector` goes out of scope (or gets resized), then the
|
||||
data the `ArrayHandle` is pointing to becomes unallocated, which will lead
|
||||
to unpredictable behavior.
|
||||
|
||||
However, there is a third option. It is often the case that an
|
||||
`std::vector` is filled and then becomes unused once it is converted to an
|
||||
`ArrayHandle`. In this case, what we really want is to pass the data off to
|
||||
the `ArrayHandle` so that the `ArrayHandle` is now managing the data and
|
||||
not the `std::vector`.
|
||||
|
||||
C++11 has a mechanism to do this: move semantics. You can now pass
|
||||
variables to functions as an "rvalue" (right-hand value). When something is
|
||||
passed as an rvalue, it can pull state out of that variable and move it
|
||||
somewhere else. `std::vector` implements this movement so that an rvalue
|
||||
can be moved to another `std::vector` without actually copying the data.
|
||||
`make_ArrayHandle` now also takes advantage of this feature to move rvalue
|
||||
`std::vector`s.
|
||||
|
||||
There is a special form of `make_ArrayHandle` named `make_ArrayHandleMove`
|
||||
that takes an rvalue. There is also a special overload of
|
||||
`make_ArrayHandle` itself that handles an rvalue `vector`. (However, using
|
||||
the explicit move version is better if you want to make sure the data is
|
||||
actually moved.)
|
||||
|
||||
So if you create the `std::vector` in the call to `make_ArrayHandle`, then
|
||||
the data only gets created once.
|
||||
|
||||
``` cpp
|
||||
auto array = vtkm::cont::make_ArrayHandleMove(std::vector<vtkm::Id>{ 2, 6, 1, 7, 4, 3, 9 });
|
||||
```
|
||||
|
||||
Note that there is now a better way to express an initializer list to
|
||||
`ArrayHandle` documented below. But this form of `ArrayHandleMove` can be
|
||||
particularly useful for initializing an array to all of a particular value.
|
||||
For example, an easy way to initialize an array of 1000 elements all to 1
|
||||
is
|
||||
|
||||
``` cpp
|
||||
auto array = vtkm::cont::make_ArrayHandleMove(std::vector<vtkm::Id>(1000, 1));
|
||||
```
|
||||
|
||||
You can also move the data from an already created `std::vector` by using
|
||||
the `std::move` function to convert it to an rvalue. When you do this, the
|
||||
`std::vector` becomes invalid after the call and any use will be undefined.
|
||||
|
||||
``` cpp
|
||||
std::vector<vtkm::Id> vector;
|
||||
// fill vector
|
||||
|
||||
auto array = vtkm::cont::make_ArrayHandleMove(std::move(vector));
|
||||
```
|
||||
|
||||
## Make `ArrayHandle` from initalizer list
|
||||
|
||||
A common use case for using `std::vector` (particularly in our unit tests)
|
||||
is to quickly add an initalizer list into an `ArrayHandle`. Repeating the
|
||||
example from above:
|
||||
|
||||
``` cpp
|
||||
auto array = vtkm::cont::make_ArrayHandleMove(std::vector<vtkm::Id>{ 2, 6, 1, 7, 4, 3, 9 });
|
||||
```
|
||||
|
||||
However, creating the `std::vector` should be unnecessary. Why not be able
|
||||
to create the `ArrayHandle` directly from an initializer list? Now you can
|
||||
by simply passing an initializer list to `make_ArrayHandle`.
|
||||
|
||||
``` cpp
|
||||
auto array = vtkm::cont::make_ArrayHandle({ 2, 6, 1, 7, 4, 3, 9 });
|
||||
```
|
||||
|
||||
There is an issue here. The type here can be a little ambiguous (for
|
||||
humans). In this case, `array` will be of type
|
||||
`vtkm::cont::ArrayHandleBasic<int>`, since that is what an integer literal
|
||||
defaults to. This could be a problem if, for example, you want to use
|
||||
`array` as an array of `vtkm::Id`, which could be of type `vtkm::Int64`.
|
||||
This is easily remedied by specifying the desired value type as a template
|
||||
argument to `make_ArrayHandle`.
|
||||
|
||||
``` cpp
|
||||
auto array = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 2, 6, 1, 7, 4, 3, 9 });
|
||||
```
|
||||
|
||||
## Deprecated `make_ArrayHandle` with default shallow copy
|
||||
|
||||
For historical reasons, passing an `std::vector` or a pointer to
|
||||
`make_ArrayHandle` does a shallow copy (i.e. `CopyFlag` defaults to `Off`).
|
||||
Although more efficient, this mode is inherintly unsafe, and making it the
|
||||
default is asking for trouble.
|
||||
|
||||
To combat this, calling `make_ArrayHandle` without a copy flag is
|
||||
deprecated. In this way, if you wish to do the faster but more unsafe
|
||||
creation of an `ArrayHandle` you should explicitly express that.
|
||||
|
||||
This requried quite a few changes through the VTK-m source (particularly in
|
||||
the tests).
|
||||
|
||||
## Similar changes to `Field`
|
||||
|
||||
`vtkm::cont::Field` has a `make_Field` helper function that is similar to
|
||||
`make_ArrayHandle`. It also features the ability to create fields from
|
||||
`std::vector`s and C arrays. It also likewise had the same unsafe behavior
|
||||
by default of not copying from the source of the arrays.
|
||||
|
||||
That behavior has similarly been depreciated. You now have to specify a
|
||||
copy flag.
|
||||
|
||||
The ability to construct a `Field` from an initializer list of values has
|
||||
also been added.
|
@ -52,11 +52,11 @@ void TestCosmoCenterFinder(const char* fileName)
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32> xLocArray =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>(xLocation, nParticles);
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>(xLocation, nParticles, vtkm::CopyFlag::Off);
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32> yLocArray =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>(yLocation, nParticles);
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>(yLocation, nParticles, vtkm::CopyFlag::Off);
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32> zLocArray =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>(zLocation, nParticles);
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>(zLocation, nParticles, vtkm::CopyFlag::Off);
|
||||
|
||||
// Output MBP particleId pairs array
|
||||
vtkm::Pair<vtkm::Id, vtkm::Float32> nxnResult;
|
||||
|
@ -53,11 +53,11 @@ void TestCosmoHaloFinder(const char* fileName)
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32> xLocArray =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>(xLocation, nParticles);
|
||||
vtkm::cont::make_ArrayHandleMove<vtkm::Float32>(xLocation, nParticles);
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32> yLocArray =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>(yLocation, nParticles);
|
||||
vtkm::cont::make_ArrayHandleMove<vtkm::Float32>(yLocation, nParticles);
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32> zLocArray =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>(zLocation, nParticles);
|
||||
vtkm::cont::make_ArrayHandleMove<vtkm::Float32>(zLocation, nParticles);
|
||||
|
||||
// Output halo id, mbp id and min potential per particle
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> resultHaloId;
|
||||
@ -88,10 +88,6 @@ void TestCosmoHaloFinder(const char* fileName)
|
||||
xLocArray.ReleaseResources();
|
||||
yLocArray.ReleaseResources();
|
||||
zLocArray.ReleaseResources();
|
||||
|
||||
delete[] xLocation;
|
||||
delete[] yLocation;
|
||||
delete[] zLocation;
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////////////////
|
||||
|
@ -71,7 +71,7 @@ int main(int argc, char** argv)
|
||||
p.ID = i;
|
||||
seeds.push_back(p);
|
||||
}
|
||||
auto seedArray = vtkm::cont::make_ArrayHandle(seeds);
|
||||
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off);
|
||||
|
||||
//compute streamlines
|
||||
vtkm::filter::Streamline streamline;
|
||||
|
@ -175,12 +175,11 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
template <typename Deleter>
|
||||
ArrayHandleBasic(
|
||||
T* array,
|
||||
vtkm::Id numberOfValues,
|
||||
vtkm::cont::DeviceAdapterId device,
|
||||
Deleter deleter,
|
||||
vtkm::cont::internal::BufferInfo::Deleter deleter,
|
||||
vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::InvalidRealloc)
|
||||
: Superclass(std::vector<vtkm::cont::internal::Buffer>{
|
||||
vtkm::cont::internal::MakeBuffer(device,
|
||||
@ -192,6 +191,39 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
ArrayHandleBasic(
|
||||
T* array,
|
||||
void* container,
|
||||
vtkm::Id numberOfValues,
|
||||
vtkm::cont::internal::BufferInfo::Deleter deleter,
|
||||
vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::InvalidRealloc)
|
||||
: Superclass(std::vector<vtkm::cont::internal::Buffer>{
|
||||
vtkm::cont::internal::MakeBuffer(vtkm::cont::DeviceAdapterTagUndefined{},
|
||||
array,
|
||||
container,
|
||||
internal::detail::NumberOfBytes(numberOfValues, sizeof(T)),
|
||||
deleter,
|
||||
reallocater) })
|
||||
{
|
||||
}
|
||||
|
||||
ArrayHandleBasic(
|
||||
T* array,
|
||||
void* container,
|
||||
vtkm::Id numberOfValues,
|
||||
vtkm::cont::DeviceAdapterId device,
|
||||
vtkm::cont::internal::BufferInfo::Deleter deleter,
|
||||
vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::InvalidRealloc)
|
||||
: Superclass(std::vector<vtkm::cont::internal::Buffer>{
|
||||
vtkm::cont::internal::MakeBuffer(device,
|
||||
array,
|
||||
container,
|
||||
internal::detail::NumberOfBytes(numberOfValues, sizeof(T)),
|
||||
deleter,
|
||||
reallocater) })
|
||||
{
|
||||
}
|
||||
|
||||
/// @{
|
||||
/// \brief Gets raw access to the `ArrayHandle`'s data.
|
||||
///
|
||||
@ -238,11 +270,85 @@ public:
|
||||
/// @}
|
||||
};
|
||||
|
||||
namespace internal
|
||||
{
|
||||
|
||||
// Deletes a container object by casting it to a pointer of a given type (the template argument)
|
||||
// and then using delete[] on the object.
|
||||
template <typename T>
|
||||
VTKM_CONT inline void SimpleArrayDeleter(void* container_)
|
||||
{
|
||||
T* container = reinterpret_cast<T*>(container_);
|
||||
delete[] container;
|
||||
}
|
||||
|
||||
// Reallocates a standard C array. Note that the allocation method is different than the default
|
||||
// host allocation of vtkm::cont::internal::BufferInfo and may be less efficient.
|
||||
template <typename T>
|
||||
VTKM_CONT inline void SimpleArrayReallocater(void*& memory,
|
||||
void*& container,
|
||||
vtkm::BufferSizeType oldSize,
|
||||
vtkm::BufferSizeType newSize)
|
||||
{
|
||||
VTKM_ASSERT(memory == container);
|
||||
VTKM_ASSERT(static_cast<std::size_t>(newSize) % sizeof(T) == 0);
|
||||
|
||||
// If the new size is not much smaller than the old size, just reuse the buffer (and waste a
|
||||
// little memory).
|
||||
if ((newSize > ((3 * oldSize) / 4)) && (newSize <= oldSize))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void* newBuffer = new T[static_cast<std::size_t>(newSize) / sizeof(T)];
|
||||
std::memcpy(newBuffer, memory, static_cast<std::size_t>(newSize < oldSize ? newSize : oldSize));
|
||||
|
||||
if (memory != nullptr)
|
||||
{
|
||||
SimpleArrayDeleter<T>(memory);
|
||||
}
|
||||
|
||||
memory = container = newBuffer;
|
||||
}
|
||||
|
||||
// Deletes a container object by casting it to a pointer of a given type (the template argument)
|
||||
// and then using delete on the object.
|
||||
template <typename T>
|
||||
VTKM_CONT inline void CastDeleter(void* container_)
|
||||
{
|
||||
T* container = reinterpret_cast<T*>(container_);
|
||||
delete container;
|
||||
}
|
||||
|
||||
template <typename T, typename Allocator>
|
||||
VTKM_CONT inline void StdVectorDeleter(void* container)
|
||||
{
|
||||
CastDeleter<std::vector<T, Allocator>>(container);
|
||||
}
|
||||
|
||||
template <typename T, typename Allocator>
|
||||
VTKM_CONT inline void StdVectorReallocater(void*& memory,
|
||||
void*& container,
|
||||
vtkm::BufferSizeType oldSize,
|
||||
vtkm::BufferSizeType newSize)
|
||||
{
|
||||
using vector_type = std::vector<T, Allocator>;
|
||||
vector_type* vector = reinterpret_cast<vector_type*>(container);
|
||||
VTKM_ASSERT(memory == &vector->front());
|
||||
VTKM_ASSERT(oldSize == static_cast<vtkm::BufferSizeType>(vector->size()));
|
||||
|
||||
vector->resize(static_cast<std::size_t>(newSize));
|
||||
memory = &vector->front();
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
|
||||
/// A convenience function for creating an ArrayHandle from a standard C array.
|
||||
///
|
||||
template <typename T>
|
||||
VTKM_CONT vtkm::cont::ArrayHandleBasic<T>
|
||||
make_ArrayHandle(const T* array, vtkm::Id numberOfValues, vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
|
||||
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(const T* array,
|
||||
vtkm::Id numberOfValues,
|
||||
vtkm::CopyFlag copy)
|
||||
{
|
||||
if (copy == vtkm::CopyFlag::On)
|
||||
{
|
||||
@ -258,12 +364,35 @@ make_ArrayHandle(const T* array, vtkm::Id numberOfValues, vtkm::CopyFlag copy =
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
|
||||
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(const T* array, vtkm::Id numberOfValues)
|
||||
{
|
||||
return make_ArrayHandle(array, numberOfValues, vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
/// A convenience function to move a user-allocated array into an `ArrayHandle`.
|
||||
/// The provided array pointer will be reset to `nullptr`.
|
||||
/// If the array was not allocated with the `new[]` operator, then deleter and reallocater
|
||||
/// functions must be provided.
|
||||
///
|
||||
template <typename T>
|
||||
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandleMove(
|
||||
T*& array,
|
||||
vtkm::Id numberOfValues,
|
||||
vtkm::cont::internal::BufferInfo::Deleter deleter = internal::SimpleArrayDeleter<T>,
|
||||
vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::SimpleArrayReallocater<T>)
|
||||
{
|
||||
vtkm::cont::ArrayHandleBasic<T> arrayHandle(array, numberOfValues, deleter, reallocater);
|
||||
array = nullptr;
|
||||
return arrayHandle;
|
||||
}
|
||||
|
||||
/// A convenience function for creating an ArrayHandle from an std::vector.
|
||||
///
|
||||
template <typename T, typename Allocator>
|
||||
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(
|
||||
const std::vector<T, Allocator>& array,
|
||||
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
|
||||
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(const std::vector<T, Allocator>& array,
|
||||
vtkm::CopyFlag copy)
|
||||
{
|
||||
if (!array.empty())
|
||||
{
|
||||
@ -275,6 +404,56 @@ VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(
|
||||
return vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>();
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T, typename Allocator>
|
||||
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
|
||||
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(const std::vector<T, Allocator>& array)
|
||||
{
|
||||
return make_ArrayHandle(array, vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
/// Move an std::vector into an ArrayHandle.
|
||||
///
|
||||
template <typename T, typename Allocator>
|
||||
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandleMove(std::vector<T, Allocator>&& array)
|
||||
{
|
||||
using vector_type = std::vector<T, Allocator>;
|
||||
vector_type* container = new vector_type(std::move(array));
|
||||
return vtkm::cont::ArrayHandleBasic<T>(container->data(),
|
||||
container,
|
||||
static_cast<vtkm::Id>(container->size()),
|
||||
internal::StdVectorDeleter<T, Allocator>,
|
||||
internal::StdVectorReallocater<T, Allocator>);
|
||||
}
|
||||
|
||||
template <typename T, typename Allocator>
|
||||
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(std::vector<T, Allocator>&& array,
|
||||
vtkm::CopyFlag copy)
|
||||
{
|
||||
if (copy == vtkm::CopyFlag::On)
|
||||
{
|
||||
VTKM_LOG_S(
|
||||
vtkm::cont::LogLevel::Info,
|
||||
"CopyFlag states std::vector should be copied, but it can be moved. Ignoring copy flag.");
|
||||
}
|
||||
if (!array.empty())
|
||||
{
|
||||
return make_ArrayHandle(&array.front(), static_cast<vtkm::Id>(array.size()), copy);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Vector empty. Just return an empty array handle.
|
||||
return vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>();
|
||||
}
|
||||
}
|
||||
|
||||
/// Create an ArrayHandle directly from an initializer list of values.
|
||||
///
|
||||
template <typename T>
|
||||
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(std::initializer_list<T>&& values)
|
||||
{
|
||||
return make_ArrayHandle(values.begin(), static_cast<vtkm::Id>(values.size()), vtkm::CopyFlag::On);
|
||||
}
|
||||
}
|
||||
} // namespace vtkm::cont
|
||||
|
||||
|
@ -63,16 +63,8 @@ vtkm::cont::ArrayHandleExtrudeCoords<T> make_ArrayHandleExtrudeCoords(
|
||||
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
|
||||
{
|
||||
using StorageType = vtkm::cont::internal::Storage<vtkm::Vec<T, 3>, internal::StorageTagExtrude>;
|
||||
if (copy == vtkm::CopyFlag::Off)
|
||||
{
|
||||
return ArrayHandleExtrudeCoords<T>(StorageType(array, length, numberOfPlanes, cylindrical));
|
||||
}
|
||||
else
|
||||
{
|
||||
auto storage = StorageType(
|
||||
vtkm::cont::make_ArrayHandle(array, length, vtkm::CopyFlag::On), numberOfPlanes, cylindrical);
|
||||
return ArrayHandleExtrudeCoords<T>(storage);
|
||||
}
|
||||
return ArrayHandleExtrudeCoords<T>(
|
||||
StorageType(vtkm::cont::make_ArrayHandle(array, length, copy), numberOfPlanes, cylindrical));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
|
@ -456,19 +456,44 @@ public:
|
||||
template <typename... RemainingVectors>
|
||||
ArrayHandleSOA(vtkm::CopyFlag copy,
|
||||
const std::vector<ComponentType>& vector0,
|
||||
const RemainingVectors&... componentVectors)
|
||||
: Superclass(StorageType(vtkm::cont::make_ArrayHandle(vector0, copy),
|
||||
vtkm::cont::make_ArrayHandle(componentVectors, copy)...))
|
||||
RemainingVectors&&... componentVectors)
|
||||
: Superclass(StorageType(
|
||||
vtkm::cont::make_ArrayHandle(vector0, copy),
|
||||
vtkm::cont::make_ArrayHandle(std::forward<RemainingVectors>(componentVectors), copy)...))
|
||||
{
|
||||
VTKM_STATIC_ASSERT(sizeof...(RemainingVectors) + 1 == Traits::NUM_COMPONENTS);
|
||||
}
|
||||
|
||||
// This only works if all the templated arguments are of type std::vector<ComponentType>.
|
||||
template <typename... RemainingVectors>
|
||||
ArrayHandleSOA(vtkm::CopyFlag copy,
|
||||
std::vector<ComponentType>&& vector0,
|
||||
RemainingVectors&&... componentVectors)
|
||||
: Superclass(StorageType(
|
||||
vtkm::cont::make_ArrayHandle(std::move(vector0), copy),
|
||||
vtkm::cont::make_ArrayHandle(std::forward<RemainingVectors>(componentVectors), copy)...))
|
||||
{
|
||||
VTKM_STATIC_ASSERT(sizeof...(RemainingVectors) + 1 == Traits::NUM_COMPONENTS);
|
||||
}
|
||||
|
||||
// This only works if all the templated arguments are of type std::vector<ComponentType>.
|
||||
template <typename... RemainingVectors>
|
||||
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
|
||||
ArrayHandleSOA(const std::vector<ComponentType>& vector0,
|
||||
const RemainingVectors&... componentVectors)
|
||||
: Superclass(StorageType(vtkm::cont::make_ArrayHandle(vector0),
|
||||
vtkm::cont::make_ArrayHandle(componentVectors)...))
|
||||
: Superclass(
|
||||
StorageType(vtkm::cont::make_ArrayHandle(vector0, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(componentVectors, vtkm::CopyFlag::Off)...))
|
||||
{
|
||||
VTKM_STATIC_ASSERT(sizeof...(RemainingVectors) + 1 == Traits::NUM_COMPONENTS);
|
||||
}
|
||||
|
||||
// This only works if all the templated arguments are of type std::vector<ComponentType>.
|
||||
template <typename... RemainingVectors>
|
||||
ArrayHandleSOA(std::vector<ComponentType>&& vector0, RemainingVectors&&... componentVectors)
|
||||
: Superclass(StorageType(
|
||||
vtkm::cont::make_ArrayHandleMove(std::move(vector0)),
|
||||
vtkm::cont::make_ArrayHandleMove(std::forward<RemainingVectors>(componentVectors))...))
|
||||
{
|
||||
VTKM_STATIC_ASSERT(sizeof...(RemainingVectors) + 1 == Traits::NUM_COMPONENTS);
|
||||
}
|
||||
@ -501,11 +526,13 @@ public:
|
||||
|
||||
// This only works if all the templated arguments are of type std::vector<ComponentType>.
|
||||
template <typename... RemainingArrays>
|
||||
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
|
||||
ArrayHandleSOA(vtkm::Id length,
|
||||
const ComponentType* array0,
|
||||
const RemainingArrays&... componentArrays)
|
||||
: Superclass(StorageType(vtkm::cont::make_ArrayHandle(array0, length),
|
||||
vtkm::cont::make_ArrayHandle(componentArrays, length)...))
|
||||
: Superclass(
|
||||
StorageType(vtkm::cont::make_ArrayHandle(array0, length, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(componentArrays, length, vtkm::CopyFlag::Off)...))
|
||||
{
|
||||
VTKM_STATIC_ASSERT(sizeof...(RemainingArrays) + 1 == Traits::NUM_COMPONENTS);
|
||||
}
|
||||
@ -558,18 +585,33 @@ VTKM_CONT
|
||||
ArrayHandleSOA<vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingVectors) + 1)>>
|
||||
make_ArrayHandleSOA(vtkm::CopyFlag copy,
|
||||
const std::vector<ComponentType>& vector0,
|
||||
const RemainingVectors&... componentVectors)
|
||||
RemainingVectors&&... componentVectors)
|
||||
{
|
||||
return ArrayHandleSOA<
|
||||
vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingVectors) + 1)>>(
|
||||
vector0, componentVectors..., copy);
|
||||
copy, vector0, std::forward<RemainingVectors>(componentVectors)...);
|
||||
}
|
||||
|
||||
// This only works if all the templated arguments are of type std::vector<ComponentType>.
|
||||
template <typename ComponentType, typename... RemainingVectors>
|
||||
VTKM_CONT
|
||||
ArrayHandleSOA<vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingVectors) + 1)>>
|
||||
make_ArrayHandleSOA(const std::vector<ComponentType>& vector0,
|
||||
const RemainingVectors&... componentVectors)
|
||||
make_ArrayHandleSOA(vtkm::CopyFlag copy,
|
||||
std::vector<ComponentType>&& vector0,
|
||||
RemainingVectors&&... componentVectors)
|
||||
{
|
||||
return ArrayHandleSOA<
|
||||
vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingVectors) + 1)>>(
|
||||
copy, std::move(vector0), std::forward<RemainingVectors>(componentVectors)...);
|
||||
}
|
||||
|
||||
template <typename ComponentType, typename... RemainingVectors>
|
||||
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
|
||||
VTKM_CONT ArrayHandleSOA<
|
||||
vtkm::Vec<ComponentType,
|
||||
vtkm::IdComponent(sizeof...(RemainingVectors) +
|
||||
1)>> make_ArrayHandleSOA(const std::vector<ComponentType>& vector0,
|
||||
const RemainingVectors&... componentVectors)
|
||||
{
|
||||
return ArrayHandleSOA<
|
||||
vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingVectors) + 1)>>(
|
||||
@ -601,11 +643,13 @@ VTKM_CONT
|
||||
}
|
||||
|
||||
template <typename ComponentType, typename... RemainingArrays>
|
||||
VTKM_CONT
|
||||
ArrayHandleSOA<vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingArrays) + 1)>>
|
||||
make_ArrayHandleSOA(vtkm::Id length,
|
||||
const ComponentType* array0,
|
||||
const RemainingArrays*... componentArrays)
|
||||
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
|
||||
VTKM_CONT ArrayHandleSOA<
|
||||
vtkm::Vec<ComponentType,
|
||||
vtkm::IdComponent(sizeof...(RemainingArrays) +
|
||||
1)>> make_ArrayHandleSOA(vtkm::Id length,
|
||||
const ComponentType* array0,
|
||||
const RemainingArrays*... componentArrays)
|
||||
{
|
||||
return ArrayHandleSOA<
|
||||
vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingArrays) + 1)>>(
|
||||
|
@ -168,10 +168,23 @@ CellSetExtrude make_CellSetExtrude(const std::vector<vtkm::Int32>& conn,
|
||||
const std::vector<vtkm::Int32>& nextNode,
|
||||
bool periodic = true)
|
||||
{
|
||||
return CellSetExtrude{ vtkm::cont::make_ArrayHandle(conn),
|
||||
return CellSetExtrude{ vtkm::cont::make_ArrayHandle(conn, vtkm::CopyFlag::On),
|
||||
static_cast<vtkm::Int32>(coords.GetNumberOfPointsPerPlane()),
|
||||
coords.GetNumberOfPlanes(),
|
||||
vtkm::cont::make_ArrayHandle(nextNode),
|
||||
vtkm::cont::make_ArrayHandle(nextNode, vtkm::CopyFlag::On),
|
||||
periodic };
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
CellSetExtrude make_CellSetExtrude(std::vector<vtkm::Int32>&& conn,
|
||||
const vtkm::cont::ArrayHandleExtrudeCoords<T>& coords,
|
||||
std::vector<vtkm::Int32>&& nextNode,
|
||||
bool periodic = true)
|
||||
{
|
||||
return CellSetExtrude{ vtkm::cont::make_ArrayHandleMove(std::move(conn)),
|
||||
static_cast<vtkm::Int32>(coords.GetNumberOfPointsPerPlane()),
|
||||
coords.GetNumberOfPlanes(),
|
||||
vtkm::cont::make_ArrayHandleMove(std::move(nextNode)),
|
||||
periodic };
|
||||
}
|
||||
}
|
||||
|
@ -833,15 +833,20 @@ ColorTable::TransferState ColorTable::GetExecutionDataForTransfer() const
|
||||
|
||||
if (this->Impl->ColorArraysChanged)
|
||||
{
|
||||
this->Impl->ColorPosHandle = vtkm::cont::make_ArrayHandle(this->Impl->ColorNodePos);
|
||||
this->Impl->ColorRGBHandle = vtkm::cont::make_ArrayHandle(this->Impl->ColorRGB);
|
||||
this->Impl->ColorPosHandle =
|
||||
vtkm::cont::make_ArrayHandle(this->Impl->ColorNodePos, vtkm::CopyFlag::Off);
|
||||
this->Impl->ColorRGBHandle =
|
||||
vtkm::cont::make_ArrayHandle(this->Impl->ColorRGB, vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
if (this->Impl->OpacityArraysChanged)
|
||||
{
|
||||
this->Impl->OpacityPosHandle = vtkm::cont::make_ArrayHandle(this->Impl->OpacityNodePos);
|
||||
this->Impl->OpacityAlphaHandle = vtkm::cont::make_ArrayHandle(this->Impl->OpacityAlpha);
|
||||
this->Impl->OpacityMidSharpHandle = vtkm::cont::make_ArrayHandle(this->Impl->OpacityMidSharp);
|
||||
this->Impl->OpacityPosHandle =
|
||||
vtkm::cont::make_ArrayHandle(this->Impl->OpacityNodePos, vtkm::CopyFlag::Off);
|
||||
this->Impl->OpacityAlphaHandle =
|
||||
vtkm::cont::make_ArrayHandle(this->Impl->OpacityAlpha, vtkm::CopyFlag::Off);
|
||||
this->Impl->OpacityMidSharpHandle =
|
||||
vtkm::cont::make_ArrayHandle(this->Impl->OpacityMidSharp, vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
TransferState state = { (this->Impl->ColorArraysChanged || this->Impl->OpacityArraysChanged ||
|
||||
|
@ -27,7 +27,8 @@ class VTKM_CONT_EXPORT DataSetBuilderRectilinear
|
||||
template <typename T, typename U>
|
||||
VTKM_CONT static void CopyInto(const std::vector<T>& input, vtkm::cont::ArrayHandle<U>& output)
|
||||
{
|
||||
DataSetBuilderRectilinear::CopyInto(vtkm::cont::make_ArrayHandle(input), output);
|
||||
DataSetBuilderRectilinear::CopyInto(vtkm::cont::make_ArrayHandle(input, vtkm::CopyFlag::Off),
|
||||
output);
|
||||
}
|
||||
|
||||
template <typename T, typename U>
|
||||
@ -40,7 +41,8 @@ class VTKM_CONT_EXPORT DataSetBuilderRectilinear
|
||||
template <typename T, typename U>
|
||||
VTKM_CONT static void CopyInto(const T* input, vtkm::Id len, vtkm::cont::ArrayHandle<U>& output)
|
||||
{
|
||||
DataSetBuilderRectilinear::CopyInto(vtkm::cont::make_ArrayHandle(input, len), output);
|
||||
DataSetBuilderRectilinear::CopyInto(
|
||||
vtkm::cont::make_ArrayHandle(input, len, vtkm::CopyFlag::Off), output);
|
||||
}
|
||||
|
||||
public:
|
||||
|
@ -181,20 +181,67 @@ vtkm::cont::Field make_Field(std::string name,
|
||||
Field::Association association,
|
||||
const T* data,
|
||||
vtkm::Id size,
|
||||
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
|
||||
vtkm::CopyFlag copy)
|
||||
{
|
||||
return vtkm::cont::Field(name, association, vtkm::cont::make_ArrayHandle(data, size, copy));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_Field.")
|
||||
vtkm::cont::Field
|
||||
make_Field(std::string name, Field::Association association, const T* data, vtkm::Id size)
|
||||
{
|
||||
return make_Field(name, association, data, size, vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
vtkm::cont::Field make_Field(std::string name,
|
||||
Field::Association association,
|
||||
const std::vector<T>& data,
|
||||
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
|
||||
vtkm::CopyFlag copy)
|
||||
{
|
||||
return vtkm::cont::Field(name, association, vtkm::cont::make_ArrayHandle(data, copy));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_Field.")
|
||||
vtkm::cont::Field
|
||||
make_Field(std::string name, Field::Association association, const std::vector<T>& data)
|
||||
{
|
||||
return make_Field(name, association, data, vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
vtkm::cont::Field make_FieldMove(std::string name,
|
||||
Field::Association association,
|
||||
std::vector<T>&& data)
|
||||
{
|
||||
return vtkm::cont::Field(name, association, vtkm::cont::make_ArrayHandleMove(data));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
vtkm::cont::Field make_Field(std::string name,
|
||||
Field::Association association,
|
||||
std::vector<T>&& data,
|
||||
vtkm::CopyFlag copy)
|
||||
{
|
||||
if (copy == vtkm::CopyFlag::On)
|
||||
{
|
||||
VTKM_LOG_S(
|
||||
vtkm::cont::LogLevel::Info,
|
||||
"CopyFlag states std::vector should be copied, but it can be moved. Ignoring copy flag.");
|
||||
}
|
||||
return make_FieldMove(name, association, std::move(data));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
vtkm::cont::Field make_Field(std::string name,
|
||||
Field::Association association,
|
||||
std::initializer_list<T>&& data)
|
||||
{
|
||||
return make_FieldMove(name, association, vtkm::cont::make_ArrayHandle(std::move(data)));
|
||||
}
|
||||
|
||||
//@}
|
||||
|
||||
/// Convenience function to build point fields from vtkm::cont::ArrayHandle
|
||||
|
@ -395,15 +395,6 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
// Create with externally managed memory
|
||||
Storage(const BaseT* array, vtkm::Id arrayLength, vtkm::Int32 numberOfPlanes, bool cylindrical)
|
||||
: Array(vtkm::cont::make_ArrayHandle(array, arrayLength))
|
||||
, NumberOfPlanes(numberOfPlanes)
|
||||
, UseCylindrical(cylindrical)
|
||||
{
|
||||
VTKM_ASSERT(this->Array.GetNumberOfValues() >= 0);
|
||||
}
|
||||
|
||||
Storage(const HandleType& array, vtkm::Int32 numberOfPlanes, bool cylindrical)
|
||||
: Array(array)
|
||||
, NumberOfPlanes(numberOfPlanes)
|
||||
|
@ -51,7 +51,7 @@ struct TryArrayInType
|
||||
}
|
||||
|
||||
using ArrayHandleType = vtkm::cont::ArrayHandle<T>;
|
||||
ArrayHandleType handle = vtkm::cont::make_ArrayHandle(array, ARRAY_SIZE);
|
||||
ArrayHandleType handle = vtkm::cont::make_ArrayHandle(array, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
|
||||
using PortalType = typename ArrayHandleType::template ExecutionTypes<Device>::PortalConst;
|
||||
|
||||
|
@ -49,7 +49,7 @@ struct TryArrayInOutType
|
||||
}
|
||||
|
||||
using ArrayHandleType = vtkm::cont::ArrayHandle<T>;
|
||||
ArrayHandleType handle = vtkm::cont::make_ArrayHandle(array, ARRAY_SIZE);
|
||||
ArrayHandleType handle = vtkm::cont::make_ArrayHandle(array, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
|
||||
using PortalType = typename ArrayHandleType::template ExecutionTypes<Device>::Portal;
|
||||
|
||||
|
@ -177,7 +177,7 @@ private:
|
||||
arrayHandle.ReleaseResourcesExecution();
|
||||
arrayHandle = vtkm::cont::ArrayHandle<T>();
|
||||
arrayHandle.ReleaseResources();
|
||||
arrayHandle = vtkm::cont::make_ArrayHandle(std::vector<T>());
|
||||
arrayHandle = vtkm::cont::make_ArrayHandleMove(std::vector<T>());
|
||||
arrayHandle.PrepareForInput(DeviceAdapterTag(), token);
|
||||
arrayHandle = vtkm::cont::ArrayHandle<T>();
|
||||
arrayHandle.PrepareForInPlace(DeviceAdapterTag(), token);
|
||||
@ -361,6 +361,144 @@ private:
|
||||
}
|
||||
};
|
||||
|
||||
struct VerifyVectorMovedMemory
|
||||
{
|
||||
template <typename T>
|
||||
VTKM_CONT void operator()(T) const
|
||||
{
|
||||
std::cout << "Creating moved std::vector memory." << std::endl;
|
||||
std::vector<T> buffer(ARRAY_SIZE);
|
||||
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
|
||||
{
|
||||
buffer[static_cast<std::size_t>(index)] = TestValue(index, T());
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<T> arrayHandle = vtkm::cont::make_ArrayHandleMove(std::move(buffer));
|
||||
// buffer is now invalid
|
||||
|
||||
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE,
|
||||
"ArrayHandle has wrong number of entries.");
|
||||
|
||||
std::cout << "Check array with moved std::vector memory." << std::endl;
|
||||
array_handle_testing::CheckArray(arrayHandle);
|
||||
|
||||
std::cout << "Check out execution array behavior." << std::endl;
|
||||
{ //as input
|
||||
vtkm::cont::Token token;
|
||||
typename vtkm::cont::ArrayHandle<T>::template ExecutionTypes<DeviceAdapterTag>::PortalConst
|
||||
executionPortal;
|
||||
executionPortal = arrayHandle.PrepareForInput(DeviceAdapterTag(), token);
|
||||
token.DetachFromAll();
|
||||
|
||||
//use a worklet to verify the input transfer worked properly
|
||||
vtkm::cont::ArrayHandle<T> result;
|
||||
DispatcherPassThrough().Invoke(arrayHandle, WrapPortal(executionPortal), result);
|
||||
array_handle_testing::CheckArray(result);
|
||||
}
|
||||
|
||||
std::cout << "Check out inplace." << std::endl;
|
||||
{ //as inplace
|
||||
vtkm::cont::Token token;
|
||||
typename vtkm::cont::ArrayHandle<T>::template ExecutionTypes<DeviceAdapterTag>::Portal
|
||||
executionPortal;
|
||||
executionPortal = arrayHandle.PrepareForInPlace(DeviceAdapterTag(), token);
|
||||
token.DetachFromAll();
|
||||
|
||||
//use a worklet to verify the inplace transfer worked properly
|
||||
vtkm::cont::ArrayHandle<T> result;
|
||||
DispatcherPassThrough().Invoke(arrayHandle, WrapPortal(executionPortal), result);
|
||||
array_handle_testing::CheckArray(result);
|
||||
}
|
||||
|
||||
std::cout << "Check out output." << std::endl;
|
||||
{ //as output with same length as user provided. This should work
|
||||
//as no new memory needs to be allocated
|
||||
vtkm::cont::Token token;
|
||||
arrayHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag(), token);
|
||||
token.DetachFromAll();
|
||||
|
||||
//we can't verify output contents as those aren't fetched, we
|
||||
//can just make sure the allocation didn't throw an exception
|
||||
}
|
||||
|
||||
{ //as a vector moved to the ArrayHandle, reallocation should be possible
|
||||
vtkm::cont::Token token;
|
||||
arrayHandle.PrepareForOutput(ARRAY_SIZE * 2, DeviceAdapterTag(), token);
|
||||
token.DetachFromAll();
|
||||
|
||||
//we can't verify output contents as those aren't fetched, we
|
||||
//can just make sure the allocation didn't throw an exception
|
||||
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE * 2);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct VerifyInitializerList
|
||||
{
|
||||
template <typename T>
|
||||
VTKM_CONT void operator()(T) const
|
||||
{
|
||||
std::cout << "Creating array with initializer list memory." << std::endl;
|
||||
vtkm::cont::ArrayHandle<T> arrayHandle =
|
||||
vtkm::cont::make_ArrayHandle({ TestValue(0, T()), TestValue(1, T()), TestValue(2, T()) });
|
||||
|
||||
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == 3,
|
||||
"ArrayHandle has wrong number of entries.");
|
||||
|
||||
std::cout << "Check array with initializer list memory." << std::endl;
|
||||
array_handle_testing::CheckArray(arrayHandle);
|
||||
|
||||
std::cout << "Check out execution array behavior." << std::endl;
|
||||
{ //as input
|
||||
vtkm::cont::Token token;
|
||||
typename vtkm::cont::ArrayHandle<T>::template ExecutionTypes<DeviceAdapterTag>::PortalConst
|
||||
executionPortal;
|
||||
executionPortal = arrayHandle.PrepareForInput(DeviceAdapterTag(), token);
|
||||
token.DetachFromAll();
|
||||
|
||||
//use a worklet to verify the input transfer worked properly
|
||||
vtkm::cont::ArrayHandle<T> result;
|
||||
DispatcherPassThrough().Invoke(arrayHandle, WrapPortal(executionPortal), result);
|
||||
array_handle_testing::CheckArray(result);
|
||||
}
|
||||
|
||||
std::cout << "Check out inplace." << std::endl;
|
||||
{ //as inplace
|
||||
vtkm::cont::Token token;
|
||||
typename vtkm::cont::ArrayHandle<T>::template ExecutionTypes<DeviceAdapterTag>::Portal
|
||||
executionPortal;
|
||||
executionPortal = arrayHandle.PrepareForInPlace(DeviceAdapterTag(), token);
|
||||
token.DetachFromAll();
|
||||
|
||||
//use a worklet to verify the inplace transfer worked properly
|
||||
vtkm::cont::ArrayHandle<T> result;
|
||||
DispatcherPassThrough().Invoke(arrayHandle, WrapPortal(executionPortal), result);
|
||||
array_handle_testing::CheckArray(result);
|
||||
}
|
||||
|
||||
std::cout << "Check out output." << std::endl;
|
||||
{ //as output with same length as user provided. This should work
|
||||
//as no new memory needs to be allocated
|
||||
vtkm::cont::Token token;
|
||||
arrayHandle.PrepareForOutput(3, DeviceAdapterTag(), token);
|
||||
token.DetachFromAll();
|
||||
|
||||
//we can't verify output contents as those aren't fetched, we
|
||||
//can just make sure the allocation didn't throw an exception
|
||||
}
|
||||
|
||||
{ //as a vector moved to the ArrayHandle, reallocation should be possible
|
||||
vtkm::cont::Token token;
|
||||
arrayHandle.PrepareForOutput(ARRAY_SIZE * 2, DeviceAdapterTag(), token);
|
||||
token.DetachFromAll();
|
||||
|
||||
//we can't verify output contents as those aren't fetched, we
|
||||
//can just make sure the allocation didn't throw an exception
|
||||
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE * 2);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct VerifyVTKMAllocatedHandle
|
||||
{
|
||||
template <typename T>
|
||||
@ -497,11 +635,13 @@ private:
|
||||
{
|
||||
void operator()() const
|
||||
{
|
||||
vtkm::testing::Testing::TryTypes(VerifyEmptyArrays());
|
||||
vtkm::testing::Testing::TryTypes(VerifyUserOwnedMemory());
|
||||
vtkm::testing::Testing::TryTypes(VerifyUserTransferredMemory());
|
||||
vtkm::testing::Testing::TryTypes(VerifyVTKMAllocatedHandle());
|
||||
vtkm::testing::Testing::TryTypes(VerifyEqualityOperators());
|
||||
vtkm::testing::Testing::TryTypes(VerifyEmptyArrays{});
|
||||
vtkm::testing::Testing::TryTypes(VerifyUserOwnedMemory{});
|
||||
vtkm::testing::Testing::TryTypes(VerifyUserTransferredMemory{});
|
||||
vtkm::testing::Testing::TryTypes(VerifyVectorMovedMemory{});
|
||||
vtkm::testing::Testing::TryTypes(VerifyInitializerList{});
|
||||
vtkm::testing::Testing::TryTypes(VerifyVTKMAllocatedHandle{});
|
||||
vtkm::testing::Testing::TryTypes(VerifyEqualityOperators{});
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -170,7 +170,8 @@ public:
|
||||
pointsVec.push_back(point);
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<PointType> points = vtkm::cont::make_ArrayHandle(pointsVec);
|
||||
vtkm::cont::ArrayHandle<PointType> points =
|
||||
vtkm::cont::make_ArrayHandle(pointsVec, vtkm::CopyFlag::Off);
|
||||
|
||||
// Initialize locator
|
||||
vtkm::cont::CellLocatorRectilinearGrid locator;
|
||||
|
@ -145,7 +145,8 @@ public:
|
||||
pointsVec.push_back(vtkm::make_Vec(0, 4, 4));
|
||||
pointsVec.push_back(vtkm::make_Vec(4, 0, 4));
|
||||
|
||||
vtkm::cont::ArrayHandle<PointType> points = vtkm::cont::make_ArrayHandle(pointsVec);
|
||||
vtkm::cont::ArrayHandle<PointType> points =
|
||||
vtkm::cont::make_ArrayHandle(pointsVec, vtkm::CopyFlag::Off);
|
||||
// Query the points using the locators.
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> cellIds;
|
||||
vtkm::cont::ArrayHandle<PointType> parametric;
|
||||
|
@ -177,9 +177,7 @@ public:
|
||||
vtkm::cont::ColorTable table(range, rgb1, rgb2, rgbspace);
|
||||
VTKM_TEST_ASSERT(table.GetClamping() == true, "clamping not setup properly");
|
||||
|
||||
constexpr vtkm::Id nvals = 4;
|
||||
constexpr int data[nvals] = { -1, 0, 1, 2 };
|
||||
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
|
||||
auto field = vtkm::cont::make_ArrayHandle({ -1, 0, 1, 2 });
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
|
||||
const bool ran = table.Map(field, colors);
|
||||
@ -202,9 +200,7 @@ public:
|
||||
table.SetClampingOff();
|
||||
VTKM_TEST_ASSERT(table.GetClamping() == false, "clamping not setup properly");
|
||||
|
||||
constexpr vtkm::Id nvals = 4;
|
||||
constexpr int data[nvals] = { -2, -1, 2, 3 };
|
||||
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
|
||||
auto field = vtkm::cont::make_ArrayHandle({ -2, -1, 2, 3 });
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
|
||||
const bool ran = table.Map(field, colors);
|
||||
@ -249,9 +245,7 @@ public:
|
||||
"rescaled has incorrect number of control points");
|
||||
|
||||
//Verify that the rescaled color table generates correct colors
|
||||
constexpr vtkm::Id nvals = 6;
|
||||
constexpr int data[nvals] = { 0, 10, 20, 30, 40, 50 };
|
||||
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
|
||||
auto field = vtkm::cont::make_ArrayHandle({ 0, 10, 20, 30, 40, 50 });
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
|
||||
const bool ran = newTable.Map(field, colors);
|
||||
@ -284,11 +278,8 @@ public:
|
||||
VTKM_TEST_ASSERT(table.GetNumberOfPoints() == 4,
|
||||
"adding points caused number of control points to be wrong");
|
||||
|
||||
constexpr vtkm::Id nvals = 3;
|
||||
constexpr float data[nvals] = { 10.0f, -5.0f, -15.0f };
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
|
||||
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
|
||||
auto field = vtkm::cont::make_ArrayHandle({ 10.0f, -5.0f, -15.0f });
|
||||
const bool ran = table.Map(field, colors);
|
||||
VTKM_TEST_ASSERT(ran, "color table failed to execute");
|
||||
|
||||
@ -322,11 +313,8 @@ public:
|
||||
VTKM_TEST_ASSERT(opacityData[3] == 0.0, "rescale modified mid/sharp of opacity");
|
||||
|
||||
|
||||
constexpr vtkm::Id nvals = 6;
|
||||
constexpr int data[nvals] = { 0, 10, 20, 30, 40, 50 };
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec4ui_8> colors;
|
||||
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
|
||||
auto field = vtkm::cont::make_ArrayHandle({ 0, 10, 20, 30, 40, 50 });
|
||||
const bool ran = table.Map(field, colors);
|
||||
VTKM_TEST_ASSERT(ran, "color table failed to execute");
|
||||
|
||||
@ -366,11 +354,8 @@ public:
|
||||
"removing points didn't update range");
|
||||
table.RescaleToRange(vtkm::Range{ 0.0, 50.0 });
|
||||
|
||||
constexpr vtkm::Id nvals = 6;
|
||||
constexpr float data[nvals] = { 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f };
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
|
||||
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
|
||||
auto field = vtkm::cont::make_ArrayHandle({ 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f });
|
||||
const bool ran = table.Map(field, colors);
|
||||
VTKM_TEST_ASSERT(ran, "color table failed to execute");
|
||||
|
||||
@ -424,11 +409,8 @@ public:
|
||||
"removing points didn't update range");
|
||||
table.RescaleToRange(vtkm::Range{ 0.0, 50.0 });
|
||||
|
||||
constexpr vtkm::Id nvals = 6;
|
||||
constexpr float data[nvals] = { 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f };
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec4ui_8> colors;
|
||||
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
|
||||
auto field = vtkm::cont::make_ArrayHandle({ 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f });
|
||||
const bool ran = table.Map(field, colors);
|
||||
VTKM_TEST_ASSERT(ran, "color table failed to execute");
|
||||
|
||||
@ -454,9 +436,7 @@ public:
|
||||
VTKM_TEST_ASSERT((table.GetNumberOfPoints() == 21),
|
||||
"loading linear green table failed with number of control points");
|
||||
|
||||
constexpr vtkm::Id nvals = 3;
|
||||
constexpr double data[3] = { 0.0, 0.5, 1.0 };
|
||||
auto samples = vtkm::cont::make_ArrayHandle(data, nvals);
|
||||
auto samples = vtkm::cont::make_ArrayHandle({ 0.0, 0.5, 1.0 });
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec4ui_8> colors;
|
||||
{
|
||||
@ -503,11 +483,8 @@ public:
|
||||
table.Sample(256, samples);
|
||||
VTKM_TEST_ASSERT((samples.Samples.GetNumberOfValues() == 260), "invalid sample length");
|
||||
|
||||
constexpr vtkm::Id nvals = 8;
|
||||
constexpr int data[nvals] = { -1, 0, 10, 20, 30, 40, 50, 60 };
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
|
||||
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
|
||||
auto field = vtkm::cont::make_ArrayHandle({ -1, 0, 10, 20, 30, 40, 50, 60 });
|
||||
const bool ran = table.Map(field, samples, colors);
|
||||
VTKM_TEST_ASSERT(ran, "color table failed to execute");
|
||||
|
||||
|
@ -51,8 +51,8 @@ private:
|
||||
std::random_device rng;
|
||||
std::mt19937 urng(rng());
|
||||
std::shuffle(data, data + nvals, urng);
|
||||
auto field =
|
||||
vtkm::cont::make_Field("TestField", vtkm::cont::Field::Association::POINTS, data, nvals);
|
||||
auto field = vtkm::cont::make_Field(
|
||||
"TestField", vtkm::cont::Field::Association::POINTS, data, nvals, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::Range result;
|
||||
field.GetRange(&result);
|
||||
@ -78,8 +78,8 @@ private:
|
||||
fieldData[j][i] = data[j];
|
||||
}
|
||||
}
|
||||
auto field =
|
||||
vtkm::cont::make_Field("TestField", vtkm::cont::Field::Association::POINTS, fieldData, nvals);
|
||||
auto field = vtkm::cont::make_Field(
|
||||
"TestField", vtkm::cont::Field::Association::POINTS, fieldData, nvals, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::Range result[NumberOfComponents];
|
||||
field.GetRange(result, CustomTypeList());
|
||||
|
@ -971,7 +971,7 @@ private:
|
||||
testData[i] = static_cast<vtkm::Id>(OFFSET + (i % 50));
|
||||
}
|
||||
|
||||
IdArrayHandle input = vtkm::cont::make_ArrayHandle(&(*testData.begin()), ARRAY_SIZE);
|
||||
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
|
||||
|
||||
//make a deep copy of input and place it into temp
|
||||
IdArrayHandle temp;
|
||||
@ -1017,7 +1017,7 @@ private:
|
||||
randomData[5] = 955; // 3 (lower), 4 (upper)
|
||||
|
||||
//change the control structure under the handle
|
||||
input = vtkm::cont::make_ArrayHandle(randomData, RANDOMDATA_SIZE);
|
||||
input = vtkm::cont::make_ArrayHandle(randomData, RANDOMDATA_SIZE, vtkm::CopyFlag::Off);
|
||||
|
||||
FloatCastHandle tempCast(temp);
|
||||
Algorithm::Copy(input, tempCast);
|
||||
@ -1064,7 +1064,7 @@ private:
|
||||
testData[i] = static_cast<vtkm::Id>(OFFSET + ((ARRAY_SIZE - i) % 50));
|
||||
}
|
||||
|
||||
IdArrayHandle unsorted = vtkm::cont::make_ArrayHandle(testData);
|
||||
IdArrayHandle unsorted = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
|
||||
IdArrayHandle sorted;
|
||||
Algorithm::Copy(unsorted, sorted);
|
||||
|
||||
@ -1095,7 +1095,7 @@ private:
|
||||
}
|
||||
|
||||
//sort the users memory in-place
|
||||
IdArrayHandle sorted = vtkm::cont::make_ArrayHandle(testData);
|
||||
IdArrayHandle sorted = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
|
||||
Algorithm::Sort(sorted);
|
||||
|
||||
//copy the sorted array into our own memory, if use the same user ptr
|
||||
@ -1136,7 +1136,7 @@ private:
|
||||
testData[i] = static_cast<vtkm::Id>(OFFSET + ((ARRAY_SIZE - i) % 50));
|
||||
}
|
||||
|
||||
IdArrayHandle unsorted = vtkm::cont::make_ArrayHandle(testData);
|
||||
IdArrayHandle unsorted = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
|
||||
IdArrayHandle sorted;
|
||||
Algorithm::Copy(unsorted, sorted);
|
||||
|
||||
@ -1202,8 +1202,8 @@ private:
|
||||
testValues[index] = TestValue(i, Vec3());
|
||||
}
|
||||
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(testKeys);
|
||||
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues);
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(testKeys, vtkm::CopyFlag::Off);
|
||||
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues, vtkm::CopyFlag::Off);
|
||||
|
||||
Algorithm::SortByKey(keys, values);
|
||||
|
||||
@ -1261,7 +1261,7 @@ private:
|
||||
{
|
||||
testData[i] = static_cast<vtkm::Id>(OFFSET + (i % 50));
|
||||
}
|
||||
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData);
|
||||
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
|
||||
|
||||
//make a deep copy of input and place it into temp
|
||||
IdArrayHandle temp;
|
||||
@ -1297,7 +1297,7 @@ private:
|
||||
{
|
||||
testData[i] = static_cast<vtkm::Id>(OFFSET + (i % 50));
|
||||
}
|
||||
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData);
|
||||
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
|
||||
|
||||
//make a deep copy of input and place it into temp
|
||||
IdArrayHandle temp;
|
||||
@ -1408,7 +1408,7 @@ private:
|
||||
}
|
||||
testData[ARRAY_SIZE / 2] = maxValue;
|
||||
|
||||
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData);
|
||||
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
|
||||
vtkm::Id2 range = Algorithm::Reduce(input, vtkm::Id2(0, 0), vtkm::MinAndMax<vtkm::Id>());
|
||||
|
||||
VTKM_TEST_ASSERT(maxValue == range[1], "Got bad value from Reduce with comparison object");
|
||||
@ -1430,27 +1430,24 @@ private:
|
||||
std::cout << " Reduce bool array with vtkm::LogicalAnd to see if all values are true."
|
||||
<< std::endl;
|
||||
//construct an array of bools and verify that they aren't all true
|
||||
constexpr vtkm::Id inputLength = 60;
|
||||
constexpr bool inputValues[inputLength] = {
|
||||
true, true, true, true, true, true, false, true, true, true, true, true, true, true, true,
|
||||
true, true, true, true, true, true, true, true, true, true, true, true, true, true, true,
|
||||
true, true, true, true, true, true, true, true, true, true, true, true, true, true, true,
|
||||
true, true, true, true, true, true, true, true, true, true, true, true, true, true, true
|
||||
};
|
||||
auto barray = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
auto barray =
|
||||
vtkm::cont::make_ArrayHandle({ true, true, true, true, true, true, false, true, true, true,
|
||||
true, true, true, true, true, true, true, true, true, true,
|
||||
true, true, true, true, true, true, true, true, true, true,
|
||||
true, true, true, true, true, true, true, true, true, true,
|
||||
true, true, true, true, true, true, true, true, true, true,
|
||||
true, true, true, true, true, true, true, true, true, true });
|
||||
bool all_true = Algorithm::Reduce(barray, true, vtkm::LogicalAnd());
|
||||
VTKM_TEST_ASSERT(all_true == false, "reduction with vtkm::LogicalAnd should return false");
|
||||
|
||||
std::cout << " Reduce with custom value type and custom comparison operator." << std::endl;
|
||||
//test with a custom value type with the reduction value being a vtkm::Vec<float,2>
|
||||
constexpr CustomTForReduce inputFValues[inputLength] = {
|
||||
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 413.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
|
||||
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
|
||||
13.1f, -2.1f, -11.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
|
||||
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -211.1f, -1.0f,
|
||||
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 113.1f, -2.1f, -1.0f
|
||||
};
|
||||
auto farray = vtkm::cont::make_ArrayHandle(inputFValues, inputLength);
|
||||
auto farray = vtkm::cont::make_ArrayHandle<CustomTForReduce>(
|
||||
{ 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 413.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
|
||||
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
|
||||
13.1f, -2.1f, -11.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
|
||||
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -211.1f, -1.0f,
|
||||
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 113.1f, -2.1f, -1.0f });
|
||||
vtkm::Vec2f_32 frange =
|
||||
Algorithm::Reduce(farray, vtkm::Vec2f_32(0.0f, 0.0f), CustomMinAndMax<CustomTForReduce>());
|
||||
VTKM_TEST_ASSERT(-211.1f == frange[0],
|
||||
@ -1494,20 +1491,15 @@ private:
|
||||
{
|
||||
//lastly test with heterogeneous zip values ( vec3, and constant array handle),
|
||||
//and a custom reduce binary functor
|
||||
const vtkm::Id indexLength = 30;
|
||||
const vtkm::Id valuesLength = 10;
|
||||
using ValueType = vtkm::Float32;
|
||||
|
||||
vtkm::Id indexs[indexLength] = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,
|
||||
5, 5, 5, 1, 4, 9, 7, 7, 7, 8, 8, 8, 0, 1, 2 };
|
||||
ValueType values[valuesLength] = {
|
||||
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, -2.0f
|
||||
};
|
||||
const ValueType expectedSum = 125;
|
||||
IdArrayHandle indexHandle =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,
|
||||
5, 5, 5, 1, 4, 9, 7, 7, 7, 8, 8, 8, 0, 1, 2 });
|
||||
vtkm::cont::ArrayHandle<ValueType> valueHandle = vtkm::cont::make_ArrayHandle(
|
||||
{ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, -2.0f });
|
||||
|
||||
IdArrayHandle indexHandle = vtkm::cont::make_ArrayHandle(indexs, indexLength);
|
||||
vtkm::cont::ArrayHandle<ValueType> valueHandle =
|
||||
vtkm::cont::make_ArrayHandle(values, valuesLength);
|
||||
const ValueType expectedSum = 125;
|
||||
|
||||
vtkm::cont::ArrayHandlePermutation<IdArrayHandle, vtkm::cont::ArrayHandle<ValueType>> perm;
|
||||
perm = vtkm::cont::make_ArrayHandlePermutation(indexHandle, valueHandle);
|
||||
@ -1526,15 +1518,14 @@ private:
|
||||
|
||||
//first test with very basic integer key / values
|
||||
{
|
||||
const vtkm::Id inputLength = 12;
|
||||
const vtkm::Id expectedLength = 6;
|
||||
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 4, 0, 2, 2, 2, 2, -1 }; // in keys
|
||||
vtkm::Id inputValues[inputLength] = { 13, -2, -1, 1, 1, 0, 3, 1, 2, 3, 4, -42 }; // in values
|
||||
vtkm::IdComponent expectedKeys[expectedLength] = { 0, 1, 4, 0, 2, -1 };
|
||||
vtkm::Id expectedValues[expectedLength] = { 10, 2, 0, 3, 10, -42 };
|
||||
|
||||
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
IdComponentArrayHandle keys =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 4, 0, 2, 2, 2, 2, -1 });
|
||||
IdArrayHandle values =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 13, -2, -1, 1, 1, 0, 3, 1, 2, 3, 4, -42 });
|
||||
|
||||
IdComponentArrayHandle keysOut;
|
||||
IdArrayHandle valuesOut;
|
||||
@ -1560,22 +1551,19 @@ private:
|
||||
//next test with a single key across the entire set, using vec3 as the
|
||||
//value, using a custom reduce binary functor
|
||||
{
|
||||
const vtkm::Id inputLength = 3;
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 0, 0 });
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64, StorageTag> values =
|
||||
vtkm::cont::make_ArrayHandle({ vtkm::Vec3f_64(13.1, 13.3, 13.5),
|
||||
vtkm::Vec3f_64(-2.1, -2.3, -2.5),
|
||||
vtkm::Vec3f_64(-1.0, -1.0, 1.0) });
|
||||
|
||||
const vtkm::Id expectedLength = 1;
|
||||
vtkm::Id inputKeys[inputLength] = { 0, 0, 0 }; // input keys
|
||||
vtkm::Vec3f_64 inputValues[inputLength];
|
||||
inputValues[0] = vtkm::make_Vec(13.1, 13.3, 13.5);
|
||||
inputValues[1] = vtkm::make_Vec(-2.1, -2.3, -2.5);
|
||||
inputValues[2] = vtkm::make_Vec(-1.0, -1.0, 1.0); // input keys
|
||||
|
||||
vtkm::Id expectedKeys[expectedLength] = { 0 };
|
||||
|
||||
vtkm::Vec3f_64 expectedValues[expectedLength];
|
||||
expectedValues[0] = vtkm::make_Vec(27.51, 30.59, -33.75);
|
||||
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64, StorageTag> values =
|
||||
vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
|
||||
IdArrayHandle keysOut;
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64, StorageTag> valuesOut;
|
||||
Algorithm::ReduceByKey(keys, values, keysOut, valuesOut, vtkm::Multiply());
|
||||
@ -1603,17 +1591,16 @@ private:
|
||||
std::cout << "-------------------------------------------" << std::endl;
|
||||
std::cout << "Testing Reduce By Key with Fancy Arrays" << std::endl;
|
||||
|
||||
const vtkm::Id inputLength = 12;
|
||||
IdComponentArrayHandle keys =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 4, 0, 2, 2, 2, 2, -1 });
|
||||
IdArrayHandle values =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 13, -2, -1, 1, 1, 0, 3, 1, 2, 3, 4, -42 });
|
||||
FloatCastHandle castValues(values);
|
||||
|
||||
const vtkm::Id expectedLength = 6;
|
||||
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 4, 0, 2, 2, 2, 2, -1 }; // in keys
|
||||
vtkm::Id inputValues[inputLength] = { 13, -2, -1, 1, 1, 0, 3, 1, 2, 3, 4, -42 }; // in values
|
||||
vtkm::IdComponent expectedKeys[expectedLength] = { 0, 1, 4, 0, 2, -1 };
|
||||
vtkm::Id expectedValues[expectedLength] = { 10, 2, 0, 3, 10, -42 };
|
||||
|
||||
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
FloatCastHandle castValues(values);
|
||||
|
||||
IdComponentArrayHandle keysOut;
|
||||
IdArrayHandle valuesOut;
|
||||
FloatCastHandle castValuesOut(valuesOut);
|
||||
@ -1640,21 +1627,14 @@ private:
|
||||
std::cout << "-------------------------------------------" << std::endl;
|
||||
std::cout << "Testing Scan Inclusive By Key with 1 elements" << std::endl;
|
||||
|
||||
const vtkm::Id inputLength = 1;
|
||||
vtkm::Id inputKeys[inputLength] = { 0 };
|
||||
vtkm::Id inputValues[inputLength] = { 5 };
|
||||
|
||||
const vtkm::Id expectedLength = 1;
|
||||
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0 });
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 5 });
|
||||
|
||||
IdArrayHandle valuesOut;
|
||||
|
||||
Algorithm::ScanInclusiveByKey(keys, values, valuesOut, vtkm::Add());
|
||||
|
||||
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == expectedLength,
|
||||
"Got wrong number of output values");
|
||||
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == 1, "Got wrong number of output values");
|
||||
const vtkm::Id v = valuesOut.ReadPortal().Get(0);
|
||||
VTKM_TEST_ASSERT(5 == v, "Incorrect scanned value");
|
||||
}
|
||||
@ -1664,16 +1644,12 @@ private:
|
||||
std::cout << "-------------------------------------------" << std::endl;
|
||||
std::cout << "Testing Scan Exclusive By Key with 2 elements" << std::endl;
|
||||
|
||||
const vtkm::Id inputLength = 2;
|
||||
vtkm::Id inputKeys[inputLength] = { 0, 1 };
|
||||
vtkm::Id inputValues[inputLength] = { 1, 1 };
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1 });
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1 });
|
||||
|
||||
const vtkm::Id expectedLength = 2;
|
||||
vtkm::Id expectedValues[expectedLength] = { 1, 1 };
|
||||
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
|
||||
IdArrayHandle valuesOut;
|
||||
|
||||
Algorithm::ScanInclusiveByKey(keys, values, valuesOut, vtkm::Add());
|
||||
@ -1692,8 +1668,7 @@ private:
|
||||
std::cout << "-------------------------------------------" << std::endl;
|
||||
std::cout << "Testing Scan Inclusive By Key with " << ARRAY_SIZE << " elements" << std::endl;
|
||||
|
||||
const vtkm::Id inputLength = ARRAY_SIZE;
|
||||
std::vector<vtkm::Id> inputKeys(inputLength);
|
||||
std::vector<vtkm::Id> inputKeys(ARRAY_SIZE);
|
||||
|
||||
for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
|
||||
{
|
||||
@ -1702,10 +1677,9 @@ private:
|
||||
else
|
||||
inputKeys[static_cast<std::size_t>(i)] = static_cast<vtkm::Id>(i);
|
||||
}
|
||||
std::vector<vtkm::Id> inputValues(inputLength, 1);
|
||||
std::vector<vtkm::Id> inputValues(ARRAY_SIZE, 1);
|
||||
|
||||
const vtkm::Id expectedLength = ARRAY_SIZE;
|
||||
std::vector<vtkm::Id> expectedValues(expectedLength);
|
||||
std::vector<vtkm::Id> expectedValues(ARRAY_SIZE);
|
||||
for (std::size_t i = 0; i < ARRAY_SIZE; i++)
|
||||
{
|
||||
if (i % 100 < 98)
|
||||
@ -1714,17 +1688,17 @@ private:
|
||||
expectedValues[i] = static_cast<vtkm::Id>(1);
|
||||
}
|
||||
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues);
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, vtkm::CopyFlag::Off);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, vtkm::CopyFlag::Off);
|
||||
|
||||
IdArrayHandle valuesOut;
|
||||
|
||||
Algorithm::ScanInclusiveByKey(keys, values, valuesOut, vtkm::Add());
|
||||
|
||||
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == expectedLength,
|
||||
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == ARRAY_SIZE,
|
||||
"Got wrong number of output values");
|
||||
auto values_portal = valuesOut.ReadPortal();
|
||||
for (auto i = 0; i < expectedLength; i++)
|
||||
for (auto i = 0; i < ARRAY_SIZE; i++)
|
||||
{
|
||||
const vtkm::Id v = values_portal.Get(i);
|
||||
VTKM_TEST_ASSERT(expectedValues[static_cast<std::size_t>(i)] == v, "Incorrect scanned value");
|
||||
@ -1735,16 +1709,13 @@ private:
|
||||
std::cout << "-------------------------------------------" << std::endl;
|
||||
std::cout << "Testing Scan Inclusive By Key" << std::endl;
|
||||
|
||||
const vtkm::Id inputLength = 10;
|
||||
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
|
||||
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
|
||||
IdComponentArrayHandle keys =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
|
||||
|
||||
const vtkm::Id expectedLength = 10;
|
||||
vtkm::Id expectedValues[expectedLength] = { 1, 2, 3, 1, 2, 1, 1, 2, 3, 4 };
|
||||
|
||||
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
|
||||
IdArrayHandle valuesOut;
|
||||
|
||||
Algorithm::ScanInclusiveByKey(keys, values, valuesOut);
|
||||
@ -1763,16 +1734,13 @@ private:
|
||||
std::cout << "Testing Scan Inclusive By Key In Place" << std::endl;
|
||||
|
||||
|
||||
const vtkm::Id inputLength = 10;
|
||||
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
|
||||
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
|
||||
IdComponentArrayHandle keys =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
|
||||
|
||||
const vtkm::Id expectedLength = 10;
|
||||
vtkm::Id expectedValues[expectedLength] = { 1, 2, 3, 1, 2, 1, 1, 2, 3, 4 };
|
||||
|
||||
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
|
||||
Algorithm::ScanInclusiveByKey(keys, values, values);
|
||||
VTKM_TEST_ASSERT(values.GetNumberOfValues() == expectedLength,
|
||||
"Got wrong number of output values");
|
||||
@ -1789,17 +1757,14 @@ private:
|
||||
std::cout << "Testing Scan Inclusive By Key In Place with a Fancy Array" << std::endl;
|
||||
|
||||
|
||||
const vtkm::Id inputLength = 10;
|
||||
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
|
||||
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
|
||||
IdComponentArrayHandle keys =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
|
||||
FloatCastHandle castValues(values);
|
||||
|
||||
const vtkm::Id expectedLength = 10;
|
||||
vtkm::Id expectedValues[expectedLength] = { 1, 2, 3, 1, 2, 1, 1, 2, 3, 4 };
|
||||
|
||||
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
FloatCastHandle castValues(values);
|
||||
|
||||
Algorithm::ScanInclusiveByKey(keys, castValues, castValues);
|
||||
VTKM_TEST_ASSERT(values.GetNumberOfValues() == expectedLength,
|
||||
"Got wrong number of output values");
|
||||
@ -1816,15 +1781,12 @@ private:
|
||||
std::cout << "-------------------------------------------" << std::endl;
|
||||
std::cout << "Testing Scan Exclusive By Key with 1 elements" << std::endl;
|
||||
|
||||
const vtkm::Id inputLength = 1;
|
||||
vtkm::Id inputKeys[inputLength] = { 0 };
|
||||
vtkm::Id inputValues[inputLength] = { 0 };
|
||||
vtkm::Id init = 5;
|
||||
|
||||
const vtkm::Id expectedLength = 1;
|
||||
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0 });
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0 });
|
||||
|
||||
IdArrayHandle valuesOut;
|
||||
|
||||
@ -1841,17 +1803,14 @@ private:
|
||||
std::cout << "-------------------------------------------" << std::endl;
|
||||
std::cout << "Testing Scan Exclusive By Key with 2 elements" << std::endl;
|
||||
|
||||
const vtkm::Id inputLength = 2;
|
||||
vtkm::Id inputKeys[inputLength] = { 0, 1 };
|
||||
vtkm::Id inputValues[inputLength] = { 1, 1 };
|
||||
vtkm::Id init = 5;
|
||||
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1 });
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1 });
|
||||
|
||||
const vtkm::Id expectedLength = 2;
|
||||
vtkm::Id expectedValues[expectedLength] = { 5, 5 };
|
||||
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
|
||||
IdArrayHandle valuesOut;
|
||||
|
||||
Algorithm::ScanExclusiveByKey(keys, values, valuesOut, init, vtkm::Add());
|
||||
@ -1871,8 +1830,7 @@ private:
|
||||
std::cout << "-------------------------------------------" << std::endl;
|
||||
std::cout << "Testing Scan Exclusive By Key with " << ARRAY_SIZE << " elements" << std::endl;
|
||||
|
||||
const vtkm::Id inputLength = ARRAY_SIZE;
|
||||
std::vector<vtkm::Id> inputKeys(inputLength);
|
||||
std::vector<vtkm::Id> inputKeys(ARRAY_SIZE);
|
||||
for (std::size_t i = 0; i < ARRAY_SIZE; i++)
|
||||
{
|
||||
if (i % 100 < 98)
|
||||
@ -1880,11 +1838,10 @@ private:
|
||||
else
|
||||
inputKeys[i] = static_cast<vtkm::Id>(i);
|
||||
}
|
||||
std::vector<vtkm::Id> inputValues(inputLength, 1);
|
||||
std::vector<vtkm::Id> inputValues(ARRAY_SIZE, 1);
|
||||
vtkm::Id init = 5;
|
||||
|
||||
const vtkm::Id expectedLength = ARRAY_SIZE;
|
||||
std::vector<vtkm::Id> expectedValues(expectedLength);
|
||||
std::vector<vtkm::Id> expectedValues(ARRAY_SIZE);
|
||||
for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
|
||||
{
|
||||
if (i % 100 < 98)
|
||||
@ -1893,17 +1850,17 @@ private:
|
||||
expectedValues[static_cast<std::size_t>(i)] = init;
|
||||
}
|
||||
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues);
|
||||
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, vtkm::CopyFlag::Off);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, vtkm::CopyFlag::Off);
|
||||
|
||||
IdArrayHandle valuesOut;
|
||||
|
||||
Algorithm::ScanExclusiveByKey(keys, values, valuesOut, init, vtkm::Add());
|
||||
|
||||
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == expectedLength,
|
||||
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == ARRAY_SIZE,
|
||||
"Got wrong number of output values");
|
||||
auto valuesPortal = valuesOut.ReadPortal();
|
||||
for (vtkm::Id i = 0; i < expectedLength; i++)
|
||||
for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
|
||||
{
|
||||
const vtkm::Id v = valuesPortal.Get(i);
|
||||
VTKM_TEST_ASSERT(expectedValues[static_cast<std::size_t>(i)] == v, "Incorrect scanned value");
|
||||
@ -1915,17 +1872,15 @@ private:
|
||||
std::cout << "-------------------------------------------" << std::endl;
|
||||
std::cout << "Testing Scan Exclusive By Key" << std::endl;
|
||||
|
||||
const vtkm::Id inputLength = 10;
|
||||
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
|
||||
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
|
||||
vtkm::Id init = 5;
|
||||
|
||||
IdComponentArrayHandle keys =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
|
||||
|
||||
const vtkm::Id expectedLength = 10;
|
||||
vtkm::Id expectedValues[expectedLength] = { 5, 6, 7, 5, 6, 5, 5, 6, 7, 8 };
|
||||
|
||||
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
|
||||
IdArrayHandle valuesOut;
|
||||
|
||||
Algorithm::ScanExclusiveByKey(keys, values, valuesOut, init, vtkm::Add());
|
||||
@ -1945,17 +1900,15 @@ private:
|
||||
std::cout << "Testing Scan Inclusive By Key In Place" << std::endl;
|
||||
|
||||
|
||||
const vtkm::Id inputLength = 10;
|
||||
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
|
||||
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
|
||||
vtkm::Id init = 5;
|
||||
|
||||
IdComponentArrayHandle keys =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
|
||||
|
||||
const vtkm::Id expectedLength = 10;
|
||||
vtkm::Id expectedValues[expectedLength] = { 5, 6, 7, 5, 6, 5, 5, 6, 7, 8 };
|
||||
|
||||
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
|
||||
Algorithm::ScanExclusiveByKey(keys, values, values, init, vtkm::Add());
|
||||
VTKM_TEST_ASSERT(values.GetNumberOfValues() == expectedLength,
|
||||
"Got wrong number of output values");
|
||||
@ -1972,18 +1925,16 @@ private:
|
||||
std::cout << "Testing Scan Inclusive By Key In Place with a Fancy Array" << std::endl;
|
||||
|
||||
|
||||
const vtkm::Id inputLength = 10;
|
||||
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
|
||||
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
|
||||
vtkm::FloatDefault init = 5;
|
||||
|
||||
IdComponentArrayHandle keys =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
|
||||
FloatCastHandle castValues(values);
|
||||
|
||||
const vtkm::Id expectedLength = 10;
|
||||
vtkm::Id expectedValues[expectedLength] = { 5, 6, 7, 5, 6, 5, 5, 6, 7, 8 };
|
||||
|
||||
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
|
||||
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
|
||||
FloatCastHandle castValues(values);
|
||||
|
||||
Algorithm::ScanExclusiveByKey(keys, castValues, castValues, init, vtkm::Add());
|
||||
VTKM_TEST_ASSERT(values.GetNumberOfValues() == expectedLength,
|
||||
"Got wrong number of output values");
|
||||
@ -2049,7 +2000,7 @@ private:
|
||||
inputValues[mid] = 0.0;
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64> array =
|
||||
vtkm::cont::make_ArrayHandle(&inputValues[0], ARRAY_SIZE);
|
||||
vtkm::cont::make_ArrayHandle(inputValues, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::Float64 product = Algorithm::ScanInclusive(array, array, vtkm::Multiply());
|
||||
|
||||
@ -2082,7 +2033,7 @@ private:
|
||||
{
|
||||
testValues[i] = TestValue(1, Vec3());
|
||||
}
|
||||
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues);
|
||||
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues, vtkm::CopyFlag::Off);
|
||||
|
||||
Vec3 sum = Algorithm::ScanInclusive(values, values);
|
||||
std::cout << "Sum that was returned " << sum << std::endl;
|
||||
@ -2194,7 +2145,8 @@ private:
|
||||
std::size_t mid = ARRAY_SIZE / 2;
|
||||
inputValues[mid] = 0.0;
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64> array = vtkm::cont::make_ArrayHandle(inputValues);
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64> array =
|
||||
vtkm::cont::make_ArrayHandle(inputValues, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::Float64 initialValue = 2.00;
|
||||
vtkm::Float64 product =
|
||||
@ -2231,7 +2183,7 @@ private:
|
||||
{
|
||||
testValues[i] = TestValue(1, Vec3());
|
||||
}
|
||||
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues);
|
||||
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues, vtkm::CopyFlag::Off);
|
||||
|
||||
Vec3 sum = Algorithm::ScanExclusive(values, values);
|
||||
std::cout << "Sum that was returned " << sum << std::endl;
|
||||
@ -2470,7 +2422,7 @@ private:
|
||||
testData[i] = TestCopy<T>::get(index);
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<T> input = vtkm::cont::make_ArrayHandle(&testData[0], COPY_ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<T> input = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
|
||||
|
||||
//make a deep copy of input and place it into temp
|
||||
{
|
||||
@ -2680,7 +2632,7 @@ private:
|
||||
testData[i] = static_cast<vtkm::Id>(OFFSET + (i % 50));
|
||||
}
|
||||
|
||||
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData);
|
||||
IdArrayHandle input = vtkm::cont::make_ArrayHandle<vtkm::Id>(testData, vtkm::CopyFlag::Off);
|
||||
|
||||
//make a deep copy of input and place it into temp
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64> temp;
|
||||
@ -2710,10 +2662,8 @@ private:
|
||||
// a single atomic value.
|
||||
std::cout << "Testing Atomic Add with vtkm::Int32" << std::endl;
|
||||
{
|
||||
std::vector<vtkm::Int32> singleElement;
|
||||
singleElement.push_back(0);
|
||||
vtkm::cont::ArrayHandle<vtkm::Int32> atomicElement =
|
||||
vtkm::cont::make_ArrayHandle(singleElement);
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Int32>({ 0 });
|
||||
|
||||
vtkm::cont::AtomicArray<vtkm::Int32> atomic(atomicElement);
|
||||
{
|
||||
@ -2727,10 +2677,8 @@ private:
|
||||
|
||||
std::cout << "Testing Atomic Add with vtkm::Int64" << std::endl;
|
||||
{
|
||||
std::vector<vtkm::Int64> singleElement;
|
||||
singleElement.push_back(0);
|
||||
vtkm::cont::ArrayHandle<vtkm::Int64> atomicElement =
|
||||
vtkm::cont::make_ArrayHandle(singleElement);
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Int64>({ 0 });
|
||||
|
||||
vtkm::cont::AtomicArray<vtkm::Int64> atomic(atomicElement);
|
||||
{
|
||||
@ -2744,10 +2692,8 @@ private:
|
||||
|
||||
std::cout << "Testing Atomic CAS with vtkm::Int32" << std::endl;
|
||||
{
|
||||
std::vector<vtkm::Int32> singleElement;
|
||||
singleElement.push_back(0);
|
||||
vtkm::cont::ArrayHandle<vtkm::Int32> atomicElement =
|
||||
vtkm::cont::make_ArrayHandle(singleElement);
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Int32>({ 0 });
|
||||
|
||||
vtkm::cont::AtomicArray<vtkm::Int32> atomic(atomicElement);
|
||||
{
|
||||
@ -2761,10 +2707,8 @@ private:
|
||||
|
||||
std::cout << "Testing Atomic CAS with vtkm::Int64" << std::endl;
|
||||
{
|
||||
std::vector<vtkm::Int64> singleElement;
|
||||
singleElement.push_back(0);
|
||||
vtkm::cont::ArrayHandle<vtkm::Int64> atomicElement =
|
||||
vtkm::cont::make_ArrayHandle(singleElement);
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Int64>({ 0 });
|
||||
|
||||
vtkm::cont::AtomicArray<vtkm::Int64> atomic(atomicElement);
|
||||
{
|
||||
|
@ -374,7 +374,7 @@ private:
|
||||
|
||||
{
|
||||
vtkm::cont::ArrayHandleSOA<Vec3> soaArray =
|
||||
vtkm::cont::make_ArrayHandleSOA(vector0, vector1, vector2);
|
||||
vtkm::cont::make_ArrayHandleSOA(vtkm::CopyFlag::Off, vector0, vector1, vector2);
|
||||
VTKM_TEST_ASSERT(soaArray.GetNumberOfValues() == ARRAY_SIZE);
|
||||
CheckPortal(soaArray.ReadPortal());
|
||||
}
|
||||
@ -388,7 +388,7 @@ private:
|
||||
|
||||
{
|
||||
vtkm::cont::ArrayHandleSOA<Vec3> soaArray = vtkm::cont::make_ArrayHandleSOA(
|
||||
ARRAY_SIZE, &vector0.front(), &vector1.front(), &vector2.front());
|
||||
ARRAY_SIZE, vtkm::CopyFlag::Off, &vector0.front(), &vector1.front(), &vector2.front());
|
||||
VTKM_TEST_ASSERT(soaArray.GetNumberOfValues() == ARRAY_SIZE);
|
||||
CheckPortal(soaArray.ReadPortal());
|
||||
}
|
||||
@ -436,7 +436,7 @@ private:
|
||||
const ValueType value = TestValue(13, ValueType());
|
||||
std::vector<ValueType> compositeData(ARRAY_SIZE, value);
|
||||
vtkm::cont::ArrayHandle<ValueType> compositeInput =
|
||||
vtkm::cont::make_ArrayHandle(compositeData);
|
||||
vtkm::cont::make_ArrayHandle(compositeData, vtkm::CopyFlag::Off);
|
||||
|
||||
auto composite =
|
||||
vtkm::cont::make_ArrayHandleCompositeVector(compositeInput, compositeInput, compositeInput);
|
||||
@ -597,7 +597,7 @@ private:
|
||||
basicVec.push_back(ValueType(static_cast<ComponentType>(i)));
|
||||
basicVec.push_back(ValueType(ComponentType(i)));
|
||||
}
|
||||
BasicArrayType basic = vtkm::cont::make_ArrayHandle(basicVec);
|
||||
BasicArrayType basic = vtkm::cont::make_ArrayHandle(basicVec, vtkm::CopyFlag::Off);
|
||||
|
||||
// concatenate two arrays together
|
||||
ConcatenateType concatenate = vtkm::cont::make_ArrayHandleConcatenate(implicit, basic);
|
||||
@ -986,14 +986,9 @@ private:
|
||||
{
|
||||
using ValueType = vtkm::Vec<ComponentType, NUM_COMPONENTS>;
|
||||
|
||||
ComponentType testValues[ARRAY_SIZE * NUM_COMPONENTS];
|
||||
|
||||
for (vtkm::Id index = 0; index < ARRAY_SIZE * NUM_COMPONENTS; ++index)
|
||||
{
|
||||
testValues[index] = TestValue(index, ComponentType());
|
||||
}
|
||||
vtkm::cont::ArrayHandle<ComponentType> baseArray =
|
||||
vtkm::cont::make_ArrayHandle(testValues, ARRAY_SIZE * NUM_COMPONENTS);
|
||||
vtkm::cont::ArrayHandle<ComponentType> baseArray;
|
||||
baseArray.Allocate(ARRAY_SIZE * NUM_COMPONENTS);
|
||||
SetPortal(baseArray.WritePortal());
|
||||
|
||||
vtkm::cont::ArrayHandleGroupVec<vtkm::cont::ArrayHandle<ComponentType>, NUM_COMPONENTS>
|
||||
groupArray(baseArray);
|
||||
@ -1210,9 +1205,10 @@ private:
|
||||
testKeys[i] = KeyType(static_cast<KeyComponentType>(ARRAY_SIZE - i));
|
||||
testValues[i] = ValueType(static_cast<ValueComponentType>(i));
|
||||
}
|
||||
vtkm::cont::ArrayHandle<KeyType> keys = vtkm::cont::make_ArrayHandle(testKeys, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<KeyType> keys =
|
||||
vtkm::cont::make_ArrayHandle(testKeys, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
vtkm::cont::ArrayHandle<ValueType> values =
|
||||
vtkm::cont::make_ArrayHandle(testValues, ARRAY_SIZE);
|
||||
vtkm::cont::make_ArrayHandle(testValues, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::cont::ArrayHandleZip<vtkm::cont::ArrayHandle<KeyType>,
|
||||
vtkm::cont::ArrayHandle<ValueType>>
|
||||
@ -1425,7 +1421,7 @@ private:
|
||||
ValueType(static_cast<ValueComponentType>(i)));
|
||||
}
|
||||
vtkm::cont::ArrayHandle<PairType> input =
|
||||
vtkm::cont::make_ArrayHandle(testKeysAndValues, ARRAY_SIZE);
|
||||
vtkm::cont::make_ArrayHandle(testKeysAndValues, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::cont::ArrayHandle<KeyType> result_keys;
|
||||
vtkm::cont::ArrayHandle<ValueType> result_values;
|
||||
|
@ -118,7 +118,7 @@ public:
|
||||
coordi.push_back(vtkm::make_Vec(00.0f, 10.0f, 10.0f));
|
||||
coordi.push_back(vtkm::make_Vec(10.0f, 00.0f, 10.0f));
|
||||
coordi.push_back(vtkm::make_Vec(10.0f, 10.0f, 10.0f));
|
||||
auto coordi_Handle = vtkm::cont::make_ArrayHandle(coordi);
|
||||
auto coordi_Handle = vtkm::cont::make_ArrayHandle(coordi, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::cont::CoordinateSystem coord("points", coordi_Handle);
|
||||
|
||||
@ -145,7 +145,7 @@ public:
|
||||
qcVec.push_back(vtkm::make_Vec(0.01f, 9.99f, 9.99f));
|
||||
qcVec.push_back(vtkm::make_Vec(9.99f, 0.01f, 9.99f));
|
||||
qcVec.push_back(vtkm::make_Vec(9.99f, 9.99f, 9.99f));
|
||||
auto qc_Handle = vtkm::cont::make_ArrayHandle(qcVec);
|
||||
auto qc_Handle = vtkm::cont::make_ArrayHandle(qcVec, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> nnId_Handle;
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> nnDis_Handle;
|
||||
@ -163,8 +163,7 @@ public:
|
||||
vtkm::worklet::DispatcherMapField<NearestNeighborSearchBruteForce3DWorklet> nnsbf3DDispatcher(
|
||||
nnsbf3dWorklet);
|
||||
nnsbf3DDispatcher.SetDevice(DeviceAdapter());
|
||||
nnsbf3DDispatcher.Invoke(
|
||||
qc_Handle, vtkm::cont::make_ArrayHandle(coordi), bfnnId_Handle, bfnnDis_Handle);
|
||||
nnsbf3DDispatcher.Invoke(qc_Handle, coordi_Handle, bfnnId_Handle, bfnnDis_Handle);
|
||||
|
||||
///// verify search result /////
|
||||
bool passTest = true;
|
||||
|
@ -53,8 +53,7 @@ void TryCopy()
|
||||
}
|
||||
|
||||
{ // ArrayHandle ids
|
||||
const std::vector<vtkm::Id> idsVec{ 3, 8, 7 };
|
||||
const auto ids = vtkm::cont::make_ArrayHandle(idsVec);
|
||||
const auto ids = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 3, 8, 7 });
|
||||
{ // Return vector:
|
||||
const std::vector<ValueType> output = vtkm::cont::ArrayGetValues(ids, data);
|
||||
TestValues<ValueType>(output, { 3, 8, 7 });
|
||||
|
@ -83,9 +83,9 @@ void RunTest()
|
||||
createArr(Y, nY);
|
||||
createArr(Z, nZ);
|
||||
|
||||
ArrayHandleCPBasic(vtkm::cont::make_ArrayHandle(X),
|
||||
vtkm::cont::make_ArrayHandle(Y),
|
||||
vtkm::cont::make_ArrayHandle(Z));
|
||||
ArrayHandleCPBasic(vtkm::cont::make_ArrayHandle(X, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(Y, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(Z, vtkm::CopyFlag::Off));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -52,16 +52,7 @@ vtkm::cont::ArrayHandle<ValueType, StorageTag> MakeInputArray(int arrayId)
|
||||
}
|
||||
|
||||
// Make an array handle that points to this buffer.
|
||||
using ArrayHandleType = vtkm::cont::ArrayHandle<ValueType, StorageTag>;
|
||||
ArrayHandleType bufferHandle = vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE);
|
||||
|
||||
// When this function returns, the array is going to go out of scope, which
|
||||
// will invalidate the array handle we just created. So copy to a new buffer
|
||||
// that will stick around after we return.
|
||||
ArrayHandleType copyHandle;
|
||||
vtkm::cont::ArrayCopy(bufferHandle, copyHandle);
|
||||
|
||||
return copyHandle;
|
||||
return vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE, vtkm::CopyFlag::On);
|
||||
}
|
||||
|
||||
template <typename ValueType, typename C>
|
||||
|
@ -54,7 +54,7 @@ void TestConcatenateEmptyArray()
|
||||
using ArrayConcat = vtkm::cont::ArrayHandleConcatenate<CoeffArrayTypeTmp, CoeffArrayTypeTmp>;
|
||||
using ArrayConcat2 = vtkm::cont::ArrayHandleConcatenate<ArrayConcat, CoeffArrayTypeTmp>;
|
||||
|
||||
CoeffArrayTypeTmp arr1 = vtkm::cont::make_ArrayHandle(vec);
|
||||
CoeffArrayTypeTmp arr1 = vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::Off);
|
||||
CoeffArrayTypeTmp arr2, arr3;
|
||||
|
||||
ArrayConcat arrConc(arr2, arr1);
|
||||
|
@ -60,8 +60,8 @@ struct Test
|
||||
}
|
||||
|
||||
// Prepare array handles:
|
||||
Handle keys = vtkm::cont::make_ArrayHandle(keyData, ARRAY_SIZE);
|
||||
Handle values = vtkm::cont::make_ArrayHandle(valueData, ARRAY_SIZE);
|
||||
Handle keys = vtkm::cont::make_ArrayHandle(keyData, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
Handle values = vtkm::cont::make_ArrayHandle(valueData, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
DiscardHandle output_keys;
|
||||
Handle output_values;
|
||||
|
||||
|
@ -96,7 +96,7 @@ int TestArrayHandleExtrude()
|
||||
const int numPlanes = 8;
|
||||
|
||||
auto coords = vtkm::cont::make_ArrayHandleExtrudeCoords(
|
||||
vtkm::cont::make_ArrayHandle(points_rz), numPlanes, false);
|
||||
vtkm::cont::make_ArrayHandle(points_rz, vtkm::CopyFlag::Off), numPlanes, false);
|
||||
|
||||
VTKM_TEST_ASSERT(coords.GetNumberOfValues() ==
|
||||
static_cast<vtkm::Id>(((points_rz.size() / 2) * numPlanes)),
|
||||
|
@ -196,14 +196,7 @@ struct PermutationTests
|
||||
}
|
||||
|
||||
// Create an ArrayHandle from the buffer
|
||||
ValueArrayType array = vtkm::cont::make_ArrayHandle(buffer);
|
||||
|
||||
// Copy the array so that the data is not destroyed when we return from
|
||||
// this method.
|
||||
ValueArrayType arrayCopy;
|
||||
Algorithm::Copy(array, arrayCopy);
|
||||
|
||||
return arrayCopy;
|
||||
return vtkm::cont::make_ArrayHandle(buffer, vtkm::CopyFlag::On);
|
||||
}
|
||||
|
||||
void operator()() const
|
||||
|
@ -15,26 +15,35 @@ void TestArrayHandleRandomUniformBits()
|
||||
{
|
||||
auto actual0 = vtkm::cont::ArrayHandleRandomUniformBits(10, { 0 });
|
||||
// result from Random123 sample implementation of philox2x32x10
|
||||
std::vector<vtkm::UInt64> expected0{ 0x6cd10df2ff1dae59, 0x5f3adb6bdcdce855, 0x3fbb6394049f6998,
|
||||
0xbd592d1202a74512, 0x8a115b62c08084ef, 0x1411803b3bb7eefa,
|
||||
0x7d138a2280027d0e, 0x318a7703a1da82c5, 0xdcd79c6998975579,
|
||||
0x6cb1a07c91f81109 };
|
||||
auto expected0 = vtkm::cont::make_ArrayHandle<vtkm::UInt64>({ 0x6cd10df2ff1dae59,
|
||||
0x5f3adb6bdcdce855,
|
||||
0x3fbb6394049f6998,
|
||||
0xbd592d1202a74512,
|
||||
0x8a115b62c08084ef,
|
||||
0x1411803b3bb7eefa,
|
||||
0x7d138a2280027d0e,
|
||||
0x318a7703a1da82c5,
|
||||
0xdcd79c6998975579,
|
||||
0x6cb1a07c91f81109 });
|
||||
|
||||
|
||||
auto result =
|
||||
vtkm::cont::testing::test_equal_ArrayHandles(actual0, vtkm::cont::make_ArrayHandle(expected0));
|
||||
auto result = vtkm::cont::testing::test_equal_ArrayHandles(actual0, expected0);
|
||||
VTKM_TEST_ASSERT(result, result.GetMergedMessage());
|
||||
|
||||
// initialize with seed = 100, could be "iteration number" in actual use case.
|
||||
auto actual100 = vtkm::cont::ArrayHandleRandomUniformBits(10, { 100 });
|
||||
// result from Random123 sample implementation of philox2x32x10
|
||||
std::vector<vtkm::UInt64> expected100{
|
||||
0xbd35360836122ea3, 0xe033b74acce7aa5f, 0xc0fbb65cba93ecd7, 0xe3fee2812b77e480,
|
||||
0x92e5c7d563767971, 0xd99e952fb054fc19, 0xb8f2adc12094ad29, 0xb7dcb35fea8c27ac,
|
||||
0x9c7b779e88270c45, 0x7325b123dc32e01d,
|
||||
};
|
||||
auto result100 = vtkm::cont::testing::test_equal_ArrayHandles(
|
||||
actual100, vtkm::cont::make_ArrayHandle(expected100));
|
||||
auto expected100 = vtkm::cont::make_ArrayHandle<vtkm::UInt64>({ 0xbd35360836122ea3,
|
||||
0xe033b74acce7aa5f,
|
||||
0xc0fbb65cba93ecd7,
|
||||
0xe3fee2812b77e480,
|
||||
0x92e5c7d563767971,
|
||||
0xd99e952fb054fc19,
|
||||
0xb8f2adc12094ad29,
|
||||
0xb7dcb35fea8c27ac,
|
||||
0x9c7b779e88270c45,
|
||||
0x7325b123dc32e01d });
|
||||
auto result100 = vtkm::cont::testing::test_equal_ArrayHandles(actual100, expected100);
|
||||
VTKM_TEST_ASSERT(result, result.GetMergedMessage());
|
||||
}
|
||||
|
||||
|
@ -44,7 +44,7 @@ void TestArrayHandleReverseRead()
|
||||
void TestArrayHandleReverseWrite()
|
||||
{
|
||||
std::vector<vtkm::Id> ids(ARRAY_SIZE, 0);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> handle = vtkm::cont::make_ArrayHandle(ids);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> handle = vtkm::cont::make_ArrayHandle(ids, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::cont::ArrayHandleReverse<vtkm::cont::ArrayHandle<vtkm::Id>> reverse =
|
||||
vtkm::cont::make_ArrayHandleReverse(handle);
|
||||
@ -63,10 +63,10 @@ void TestArrayHandleReverseWrite()
|
||||
|
||||
void TestArrayHandleReverseScanInclusiveByKey()
|
||||
{
|
||||
vtkm::Id ids[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
|
||||
vtkm::Id seg[] = { 0, 0, 0, 0, 1, 1, 2, 3, 3, 4 };
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> values = vtkm::cont::make_ArrayHandle(ids, 10);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> keys = vtkm::cont::make_ArrayHandle(seg, 10);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> values =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> keys =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 0, 0, 0, 1, 1, 2, 3, 3, 4 });
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> output;
|
||||
vtkm::cont::ArrayHandleReverse<vtkm::cont::ArrayHandle<vtkm::Id>> reversed =
|
||||
@ -75,9 +75,9 @@ void TestArrayHandleReverseScanInclusiveByKey()
|
||||
using Algorithm = vtkm::cont::DeviceAdapterAlgorithm<vtkm::cont::DeviceAdapterTagSerial>;
|
||||
Algorithm::ScanInclusiveByKey(keys, values, reversed);
|
||||
|
||||
vtkm::Id expected[] = { 0, 1, 3, 6, 4, 9, 6, 7, 15, 9 };
|
||||
vtkm::cont::ArrayHandleReverse<vtkm::cont::ArrayHandle<vtkm::Id>> expected_reversed =
|
||||
vtkm::cont::make_ArrayHandleReverse(vtkm::cont::make_ArrayHandle(expected, 10));
|
||||
vtkm::cont::make_ArrayHandleReverse(
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 3, 6, 4, 9, 6, 7, 15, 9 }));
|
||||
auto outputPortal = output.ReadPortal();
|
||||
auto reversePortal = expected_reversed.ReadPortal();
|
||||
for (int i = 0; i < 10; i++)
|
||||
|
@ -156,7 +156,8 @@ struct TemplatedTests
|
||||
T* end = begin + ARRAY_SIZE;
|
||||
const T* cbegin = begin;
|
||||
const T* cend = end;
|
||||
vtkm::cont::ArrayHandle<T> arrayHandle = vtkm::cont::make_ArrayHandle(begin, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<T> arrayHandle =
|
||||
vtkm::cont::make_ArrayHandle(begin, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
|
||||
std::cout
|
||||
<< " Testing ArrayPortalToIterators(ArrayPortalFromIterators) gets back simple iterator."
|
||||
|
@ -45,10 +45,11 @@ vtkm::Id ArrayLength(const T (&)[Length])
|
||||
vtkm::cont::CellSetExplicit<> MakeTestCellSet1()
|
||||
{
|
||||
vtkm::cont::CellSetExplicit<> cs;
|
||||
cs.Fill(numberOfPoints,
|
||||
vtkm::cont::make_ArrayHandle(g_shapes, ArrayLength(g_shapes)),
|
||||
vtkm::cont::make_ArrayHandle(g_connectivity, ArrayLength(g_connectivity)),
|
||||
vtkm::cont::make_ArrayHandle(g_offsets, ArrayLength(g_offsets)));
|
||||
cs.Fill(
|
||||
numberOfPoints,
|
||||
vtkm::cont::make_ArrayHandle(g_shapes, ArrayLength(g_shapes), vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(g_connectivity, ArrayLength(g_connectivity), vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(g_offsets, ArrayLength(g_offsets), vtkm::CopyFlag::Off));
|
||||
return cs;
|
||||
}
|
||||
|
||||
@ -57,9 +58,10 @@ vtkm::cont::CellSetExplicit<> MakeTestCellSet2()
|
||||
{
|
||||
vtkm::cont::CellSetExplicit<> cs;
|
||||
cs.Fill(numberOfPoints,
|
||||
vtkm::cont::make_ArrayHandle(g_shapes2, ArrayLength(g_shapes2)),
|
||||
vtkm::cont::make_ArrayHandle(g_connectivity2, ArrayLength(g_connectivity2)),
|
||||
vtkm::cont::make_ArrayHandle(g_offsets2, ArrayLength(g_offsets2)));
|
||||
vtkm::cont::make_ArrayHandle(g_shapes2, ArrayLength(g_shapes2), vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(
|
||||
g_connectivity2, ArrayLength(g_connectivity2), vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(g_offsets2, ArrayLength(g_offsets2), vtkm::CopyFlag::Off));
|
||||
return cs;
|
||||
}
|
||||
|
||||
|
@ -129,14 +129,14 @@ int TestCellSetExtrude()
|
||||
|
||||
// verify that a constant value point field can be accessed
|
||||
std::vector<float> pvalues(static_cast<size_t>(coords.GetNumberOfValues()), 42.0f);
|
||||
vtkm::cont::Field pfield(
|
||||
"pfield", vtkm::cont::Field::Association::POINTS, vtkm::cont::make_ArrayHandle(pvalues));
|
||||
vtkm::cont::Field pfield = vtkm::cont::make_Field(
|
||||
"pfield", vtkm::cont::Field::Association::POINTS, pvalues, vtkm::CopyFlag::Off);
|
||||
dataset.AddField(pfield);
|
||||
|
||||
// verify that a constant cell value can be accessed
|
||||
std::vector<float> cvalues(static_cast<size_t>(cells.GetNumberOfCells()), 42.0f);
|
||||
vtkm::cont::Field cfield =
|
||||
vtkm::cont::make_FieldCell("cfield", vtkm::cont::make_ArrayHandle(cvalues));
|
||||
vtkm::cont::Field cfield = vtkm::cont::make_Field(
|
||||
"cfield", vtkm::cont::Field::Association::CELL_SET, cvalues, vtkm::CopyFlag::Off);
|
||||
dataset.AddField(cfield);
|
||||
|
||||
vtkm::filter::PointAverage avg;
|
||||
|
@ -83,9 +83,7 @@ std::vector<T> createVec(std::size_t n, const T* data)
|
||||
template <typename T>
|
||||
vtkm::cont::ArrayHandle<T> createAH(std::size_t n, const T* data)
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> arr;
|
||||
DFA::Copy(vtkm::cont::make_ArrayHandle(data, static_cast<vtkm::Id>(n)), arr);
|
||||
return arr;
|
||||
return vtkm::cont::make_ArrayHandle(data, static_cast<vtkm::Id>(n), vtkm::CopyFlag::On);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
@ -128,9 +126,8 @@ vtkm::cont::DataSet CreateDataSetArr(bool useSeparatedCoords,
|
||||
}
|
||||
dataSet = dsb.Create(xvals, yvals, zvals, shapevals, indicesvals, connvals);
|
||||
|
||||
vtkm::cont::ArrayHandle<T> P, C;
|
||||
DFA::Copy(vtkm::cont::make_ArrayHandle(varP), P);
|
||||
DFA::Copy(vtkm::cont::make_ArrayHandle(varC), C);
|
||||
vtkm::cont::ArrayHandle<T> P = vtkm::cont::make_ArrayHandle(varP, vtkm::CopyFlag::On);
|
||||
vtkm::cont::ArrayHandle<T> C = vtkm::cont::make_ArrayHandle(varC, vtkm::CopyFlag::On);
|
||||
dataSet.AddPointField("pointvar", P);
|
||||
dataSet.AddCellField("cellvar", C);
|
||||
return dataSet;
|
||||
@ -151,8 +148,8 @@ vtkm::cont::DataSet CreateDataSetArr(bool useSeparatedCoords,
|
||||
{
|
||||
varC[i][0] = static_cast<T>(f * 1.1f);
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> pts;
|
||||
DFA::Copy(vtkm::cont::make_ArrayHandle(tmp), pts);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> pts =
|
||||
vtkm::cont::make_ArrayHandle(tmp, vtkm::CopyFlag::On);
|
||||
dataSet = dsb.Create(
|
||||
pts, createAH(numCells, shape), createAH(numCells, indices), createAH(numConn, conn));
|
||||
dataSet.AddPointField("pointvar", varP);
|
||||
|
@ -121,7 +121,6 @@ void RectilinearTests()
|
||||
const vtkm::Id NUM_FILL_METHODS = 5;
|
||||
|
||||
vtkm::cont::DataSetBuilderRectilinear dataSetBuilder;
|
||||
vtkm::cont::DataSet dataSet;
|
||||
|
||||
std::uniform_int_distribution<vtkm::Id> randomDim(1, MAX_DIM_SIZE);
|
||||
std::uniform_int_distribution<vtkm::IdComponent> randomFill(0, NUM_FILL_METHODS - 1);
|
||||
@ -130,6 +129,8 @@ void RectilinearTests()
|
||||
{
|
||||
std::cout << "Trial " << trial << std::endl;
|
||||
|
||||
vtkm::cont::DataSet dataSet;
|
||||
|
||||
vtkm::Id3 dimensions(
|
||||
randomDim(g_RandomGenerator), randomDim(g_RandomGenerator), randomDim(g_RandomGenerator));
|
||||
std::cout << "Dimensions: " << dimensions << std::endl;
|
||||
@ -216,10 +217,11 @@ void RectilinearTests()
|
||||
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
|
||||
|
||||
std::cout << " Create with ArrayHandle" << std::endl;
|
||||
dataSet = dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates),
|
||||
vtkm::cont::make_ArrayHandle(yCoordinates));
|
||||
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP2D));
|
||||
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC2D));
|
||||
dataSet =
|
||||
dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(yCoordinates, vtkm::CopyFlag::Off));
|
||||
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP2D, vtkm::CopyFlag::Off));
|
||||
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC2D, vtkm::CopyFlag::Off));
|
||||
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
|
||||
}
|
||||
|
||||
@ -259,16 +261,17 @@ void RectilinearTests()
|
||||
&xCoordinates.front(),
|
||||
&yCoordinates.front(),
|
||||
&zCoordinates.front());
|
||||
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP3D));
|
||||
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC3D));
|
||||
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP3D, vtkm::CopyFlag::Off));
|
||||
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC3D, vtkm::CopyFlag::Off));
|
||||
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
|
||||
|
||||
std::cout << " Create with ArrayHandle" << std::endl;
|
||||
dataSet = dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates),
|
||||
vtkm::cont::make_ArrayHandle(yCoordinates),
|
||||
vtkm::cont::make_ArrayHandle(zCoordinates));
|
||||
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP3D));
|
||||
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC3D));
|
||||
dataSet =
|
||||
dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(yCoordinates, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(zCoordinates, vtkm::CopyFlag::Off));
|
||||
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP3D, vtkm::CopyFlag::Off));
|
||||
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC3D, vtkm::CopyFlag::Off));
|
||||
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
|
||||
}
|
||||
}
|
||||
|
@ -86,12 +86,9 @@ void TestDataSet_Explicit()
|
||||
|
||||
vtkm::cont::DataSet dataSet = make_SingleTypeDataSet();
|
||||
|
||||
std::vector<vtkm::Id> validIds;
|
||||
validIds.push_back(1); //iterate the 2nd cell 4 times
|
||||
validIds.push_back(1);
|
||||
validIds.push_back(1);
|
||||
validIds.push_back(1);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds = vtkm::cont::make_ArrayHandle(validIds);
|
||||
//iterate the 2nd cell 4 times
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1 });
|
||||
|
||||
//get the cellset single type from the dataset
|
||||
vtkm::cont::CellSetSingleType<> cellSet;
|
||||
@ -125,12 +122,9 @@ void TestDataSet_Structured2D()
|
||||
vtkm::cont::testing::MakeTestDataSet testDataSet;
|
||||
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
|
||||
|
||||
std::vector<vtkm::Id> validIds;
|
||||
validIds.push_back(1); //iterate the 2nd cell 4 times
|
||||
validIds.push_back(1);
|
||||
validIds.push_back(1);
|
||||
validIds.push_back(1);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds = vtkm::cont::make_ArrayHandle(validIds);
|
||||
//iterate the 2nd cell 4 times
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1 });
|
||||
|
||||
vtkm::cont::CellSetStructured<2> cellSet;
|
||||
dataSet.GetCellSet().CopyTo(cellSet);
|
||||
@ -161,12 +155,9 @@ void TestDataSet_Structured3D()
|
||||
vtkm::cont::testing::MakeTestDataSet testDataSet;
|
||||
vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
|
||||
|
||||
std::vector<vtkm::Id> validIds;
|
||||
validIds.push_back(1); //iterate the 2nd cell 4 times
|
||||
validIds.push_back(1);
|
||||
validIds.push_back(1);
|
||||
validIds.push_back(1);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds = vtkm::cont::make_ArrayHandle(validIds);
|
||||
//iterate the 2nd cell 4 times
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1 });
|
||||
|
||||
vtkm::cont::CellSetStructured<3> cellSet;
|
||||
dataSet.GetCellSet().CopyTo(cellSet);
|
||||
|
@ -31,7 +31,7 @@ void TestParticleArrayCopy()
|
||||
|
||||
for (int i = 0; i < 2; i++)
|
||||
{
|
||||
auto particleAH = vtkm::cont::make_ArrayHandle(particles);
|
||||
auto particleAH = vtkm::cont::make_ArrayHandle(particles, vtkm::CopyFlag::Off);
|
||||
|
||||
//Test copy position only
|
||||
if (i == 0)
|
||||
|
@ -206,8 +206,8 @@ struct TestArrayHandleGroupVecVariable
|
||||
return offset;
|
||||
});
|
||||
|
||||
auto array = vtkm::cont::make_ArrayHandleGroupVecVariable(RandomArrayHandle<T>::Make(size),
|
||||
vtkm::cont::make_ArrayHandle(comps));
|
||||
auto array = vtkm::cont::make_ArrayHandleGroupVecVariable(
|
||||
RandomArrayHandle<T>::Make(size), vtkm::cont::make_ArrayHandle(comps, vtkm::CopyFlag::On));
|
||||
RunTest(array);
|
||||
|
||||
// cannot make a VariantArrayHandle containing ArrayHandleGroupVecVariable
|
||||
|
@ -164,14 +164,10 @@ void CheckArrayVariant(const vtkm::cont::VariantArrayHandleBase<TypeList>& array
|
||||
template <typename T>
|
||||
vtkm::cont::VariantArrayHandle CreateArrayVariant(T)
|
||||
{
|
||||
// Declared static to prevent going out of scope.
|
||||
static T buffer[ARRAY_SIZE];
|
||||
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
|
||||
{
|
||||
buffer[index] = TestValue(index, T());
|
||||
}
|
||||
|
||||
return vtkm::cont::VariantArrayHandle(vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE));
|
||||
vtkm::cont::ArrayHandle<T> array;
|
||||
array.Allocate(ARRAY_SIZE);
|
||||
SetPortal(array.WritePortal());
|
||||
return vtkm::cont::VariantArrayHandle(array);
|
||||
}
|
||||
|
||||
template <typename ArrayHandleType>
|
||||
@ -415,7 +411,8 @@ void TryCastToArrayHandle()
|
||||
buffer[index] = TestValue(index, vtkm::Id());
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> array = vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> array =
|
||||
vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE, vtkm::CopyFlag::On);
|
||||
TryCastToArrayHandle(array);
|
||||
|
||||
std::cout << " Cast array handle." << std::endl;
|
||||
|
@ -129,8 +129,8 @@ void TestCrossProduct()
|
||||
createVectors(static_cast<std::size_t>(nVerts), i, vecs1, vecs2);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> field1, field2;
|
||||
field1 = vtkm::cont::make_ArrayHandle(vecs1);
|
||||
field2 = vtkm::cont::make_ArrayHandle(vecs2);
|
||||
field1 = vtkm::cont::make_ArrayHandle(vecs1, vtkm::CopyFlag::On);
|
||||
field2 = vtkm::cont::make_ArrayHandle(vecs2, vtkm::CopyFlag::On);
|
||||
|
||||
dataSet.AddPointField("vec1", field1);
|
||||
dataSet.AddPointField("vec2", field2);
|
||||
|
@ -118,8 +118,8 @@ void TestDotProduct()
|
||||
createVectors(static_cast<std::size_t>(nVerts), i, vecs1, vecs2);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> field1, field2;
|
||||
field1 = vtkm::cont::make_ArrayHandle(vecs1);
|
||||
field2 = vtkm::cont::make_ArrayHandle(vecs2);
|
||||
field1 = vtkm::cont::make_ArrayHandle(vecs1, vtkm::CopyFlag::On);
|
||||
field2 = vtkm::cont::make_ArrayHandle(vecs2, vtkm::CopyFlag::On);
|
||||
|
||||
dataSet.AddPointField("vec1", field1);
|
||||
dataSet.AddPointField("vec2", field2);
|
||||
|
@ -41,8 +41,9 @@ void TestFieldTypesPoint()
|
||||
VTKM_TEST_ASSERT(helperMD.IsCellField() == false, "point can't be a cell field");
|
||||
|
||||
//verify the field helper works properly
|
||||
vtkm::Float32 vars[6] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f };
|
||||
auto field = vtkm::cont::make_Field("pointvar", vtkm::cont::Field::Association::POINTS, vars, 6);
|
||||
auto field = vtkm::cont::make_FieldPoint(
|
||||
"pointvar",
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>({ 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f }));
|
||||
vtkm::filter::FieldMetadata makeMDFromField(field);
|
||||
VTKM_TEST_ASSERT(makeMDFromField.IsPointField() == true, "point should be a point field");
|
||||
VTKM_TEST_ASSERT(makeMDFromField.IsCellField() == false, "point can't be a cell field");
|
||||
@ -57,8 +58,9 @@ void TestFieldTypesCell()
|
||||
VTKM_TEST_ASSERT(helperMD.IsCellField() == true, "cell should be a cell field");
|
||||
|
||||
//verify the field helper works properly
|
||||
vtkm::Float32 vars[6] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f };
|
||||
auto field = vtkm::cont::make_FieldCell("pointvar", vtkm::cont::make_ArrayHandle(vars, 6));
|
||||
auto field = vtkm::cont::make_FieldCell(
|
||||
"pointvar",
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float32>({ 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f }));
|
||||
vtkm::filter::FieldMetadata makeMDFromField(field);
|
||||
VTKM_TEST_ASSERT(makeMDFromField.IsPointField() == false, "cell can't be a point field");
|
||||
VTKM_TEST_ASSERT(makeMDFromField.IsCellField() == true, "cell should be a cell field");
|
||||
|
@ -60,7 +60,8 @@ void TestCellGradientUniform3DWithVectorField()
|
||||
{
|
||||
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
|
||||
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
|
||||
dataSet.AddPointField("vec_pointvar", input);
|
||||
|
||||
//we need to add Vec3 array to the dataset
|
||||
@ -118,7 +119,8 @@ void TestPointGradientUniform3DWithVectorField()
|
||||
{
|
||||
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
|
||||
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
|
||||
dataSet.AddPointField("vec_pointvar", input);
|
||||
|
||||
//we need to add Vec3 array to the dataset
|
||||
|
@ -327,9 +327,12 @@ void Test2DLCS()
|
||||
|
||||
auxiliary::PopulateData(fieldVec, visitVec, diffVec, auxiliary::Option::_2D);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> diffHandle = vtkm::cont::make_ArrayHandle(diffVec);
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> visitHandle = vtkm::cont::make_ArrayHandle(visitVec);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldHandle = vtkm::cont::make_ArrayHandle(fieldVec);
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> diffHandle =
|
||||
vtkm::cont::make_ArrayHandle(diffVec, vtkm::CopyFlag::On);
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> visitHandle =
|
||||
vtkm::cont::make_ArrayHandle(visitVec, vtkm::CopyFlag::On);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldHandle =
|
||||
vtkm::cont::make_ArrayHandle(fieldVec, vtkm::CopyFlag::On);
|
||||
inputData.AddPointField("velocity", fieldHandle);
|
||||
|
||||
vtkm::filter::LagrangianStructures lagrangianStructures;
|
||||
@ -363,9 +366,12 @@ void Test3DLCS()
|
||||
|
||||
auxiliary::PopulateData(fieldVec, visitVec, diffVec, auxiliary::Option::_3D);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> diffHandle = vtkm::cont::make_ArrayHandle(diffVec);
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> visitHandle = vtkm::cont::make_ArrayHandle(visitVec);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldHandle = vtkm::cont::make_ArrayHandle(fieldVec);
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> diffHandle =
|
||||
vtkm::cont::make_ArrayHandle(diffVec, vtkm::CopyFlag::On);
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> visitHandle =
|
||||
vtkm::cont::make_ArrayHandle(visitVec, vtkm::CopyFlag::On);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldHandle =
|
||||
vtkm::cont::make_ArrayHandle(fieldVec, vtkm::CopyFlag::On);
|
||||
inputData.AddPointField("velocity", fieldHandle);
|
||||
|
||||
vtkm::filter::LagrangianStructures lagrangianStructures;
|
||||
|
@ -37,13 +37,10 @@ void TestBasic()
|
||||
const vtkm::Vec3f vecX(1, 0, 0);
|
||||
|
||||
vtkm::cont::DataSet ds = CreateDataSet(dims, vecX);
|
||||
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
|
||||
std::vector<vtkm::Massless> seeds(3);
|
||||
seeds[0] = vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0);
|
||||
seeds[1] = vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1);
|
||||
seeds[2] = vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2);
|
||||
|
||||
seedArray = vtkm::cont::make_ArrayHandle(seeds);
|
||||
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
|
||||
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
|
||||
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
|
||||
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
|
||||
|
||||
vtkm::filter::ParticleAdvection particleAdvection;
|
||||
|
||||
@ -91,7 +88,7 @@ void TestFile(const std::string& fname,
|
||||
std::vector<vtkm::Massless> seeds;
|
||||
for (vtkm::Id i = 0; i < numPoints; i++)
|
||||
seeds.push_back(vtkm::Massless(pts[static_cast<std::size_t>(i)], i));
|
||||
auto seedArray = vtkm::cont::make_ArrayHandle(seeds);
|
||||
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::filter::ParticleAdvection particleAdvection;
|
||||
particleAdvection.SetStepSize(stepSize);
|
||||
|
@ -38,14 +38,11 @@ void TestStreamSurface()
|
||||
const vtkm::Vec3f vecX(1, 0, 0);
|
||||
|
||||
vtkm::cont::DataSet ds = CreateDataSet(dims, vecX);
|
||||
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
|
||||
std::vector<vtkm::Massless> seeds(4);
|
||||
seeds[0] = vtkm::Massless(vtkm::Vec3f(.1f, 1.0f, .2f), 0);
|
||||
seeds[1] = vtkm::Massless(vtkm::Vec3f(.1f, 2.0f, .1f), 1);
|
||||
seeds[2] = vtkm::Massless(vtkm::Vec3f(.1f, 3.0f, .3f), 2);
|
||||
seeds[3] = vtkm::Massless(vtkm::Vec3f(.1f, 3.5f, .2f), 3);
|
||||
|
||||
seedArray = vtkm::cont::make_ArrayHandle(seeds);
|
||||
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
|
||||
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.1f, 1.0f, .2f), 0),
|
||||
vtkm::Massless(vtkm::Vec3f(.1f, 2.0f, .1f), 1),
|
||||
vtkm::Massless(vtkm::Vec3f(.1f, 3.0f, .3f), 2),
|
||||
vtkm::Massless(vtkm::Vec3f(.1f, 3.5f, .2f), 3) });
|
||||
|
||||
vtkm::filter::StreamSurface streamSrf;
|
||||
|
||||
|
@ -38,13 +38,10 @@ void TestStreamline()
|
||||
const vtkm::Vec3f vecX(1, 0, 0);
|
||||
|
||||
vtkm::cont::DataSet ds = CreateDataSet(dims, vecX);
|
||||
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
|
||||
std::vector<vtkm::Massless> seeds(3);
|
||||
seeds[0] = vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0);
|
||||
seeds[1] = vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1);
|
||||
seeds[2] = vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2);
|
||||
|
||||
seedArray = vtkm::cont::make_ArrayHandle(seeds);
|
||||
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
|
||||
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
|
||||
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
|
||||
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
|
||||
|
||||
vtkm::filter::Streamline streamline;
|
||||
|
||||
@ -75,13 +72,10 @@ void TestPathline()
|
||||
vtkm::cont::DataSet ds1 = CreateDataSet(dims, vecX);
|
||||
vtkm::cont::DataSet ds2 = CreateDataSet(dims, vecY);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
|
||||
std::vector<vtkm::Massless> seeds(3);
|
||||
seeds[0] = vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0);
|
||||
seeds[1] = vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1);
|
||||
seeds[2] = vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2);
|
||||
|
||||
seedArray = vtkm::cont::make_ArrayHandle(seeds);
|
||||
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
|
||||
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
|
||||
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
|
||||
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
|
||||
|
||||
vtkm::filter::Pathline pathline;
|
||||
|
||||
@ -129,7 +123,7 @@ void TestStreamlineFile(const std::string& fname,
|
||||
std::vector<vtkm::Massless> seeds;
|
||||
for (vtkm::Id i = 0; i < numPoints; i++)
|
||||
seeds.push_back(vtkm::Massless(pts[static_cast<std::size_t>(i)], i));
|
||||
auto seedArray = vtkm::cont::make_ArrayHandle(seeds);
|
||||
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::filter::Streamline streamline;
|
||||
streamline.SetStepSize(stepSize);
|
||||
|
@ -33,7 +33,8 @@ void TestVectorMagnitude()
|
||||
{
|
||||
fvec[i] = vtkm::make_Vec(fvars[i], fvars[i], fvars[i]);
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> finput = vtkm::cont::make_ArrayHandle(fvec);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> finput =
|
||||
vtkm::cont::make_ArrayHandle(fvec, vtkm::CopyFlag::On);
|
||||
|
||||
dataSet.AddPointField("double_vec_pointvar", finput);
|
||||
|
||||
|
@ -540,15 +540,15 @@ bool Canvas::LoadFont() const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
std::size_t numValues = textureWidth * textureHeight;
|
||||
std::vector<unsigned char> alpha(numValues);
|
||||
for (std::size_t i = 0; i < numValues; ++i)
|
||||
vtkm::Id numValues = static_cast<vtkm::Id>(textureWidth * textureHeight);
|
||||
vtkm::cont::ArrayHandle<UInt8> alpha;
|
||||
alpha.Allocate(numValues);
|
||||
auto alphaPortal = alpha.WritePortal();
|
||||
for (vtkm::Id i = 0; i < numValues; ++i)
|
||||
{
|
||||
alpha[i] = rgba[i * 4 + 3];
|
||||
alphaPortal.Set(i, rgba[static_cast<std::size_t>(i * 4 + 3)]);
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::UInt8> textureHandle = vtkm::cont::make_ArrayHandle(alpha);
|
||||
Internals->FontTexture =
|
||||
FontTextureType(vtkm::Id(textureWidth), vtkm::Id(textureHeight), textureHandle);
|
||||
Internals->FontTexture = FontTextureType(vtkm::Id(textureWidth), vtkm::Id(textureHeight), alpha);
|
||||
Internals->FontTexture.SetFilterMode(TextureFilterMode::Linear);
|
||||
Internals->FontTexture.SetWrapMode(TextureWrapMode::Clamp);
|
||||
return true;
|
||||
|
@ -55,16 +55,15 @@ struct TestBinarySearch
|
||||
{
|
||||
using Algo = vtkm::cont::DeviceAdapterAlgorithm<Device>;
|
||||
|
||||
std::vector<vtkm::Id> needlesData{ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 };
|
||||
std::vector<vtkm::Id> hayStackData{ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 };
|
||||
IdArray needles = vtkm::cont::make_ArrayHandle<vtkm::Id>({ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 });
|
||||
IdArray hayStack =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 });
|
||||
IdArray results;
|
||||
|
||||
std::vector<bool> expectedFound{
|
||||
false, true, true, false, true, true, false, false, true, false
|
||||
};
|
||||
|
||||
IdArray needles = vtkm::cont::make_ArrayHandle(needlesData);
|
||||
IdArray hayStack = vtkm::cont::make_ArrayHandle(hayStackData);
|
||||
IdArray results;
|
||||
|
||||
vtkm::cont::Token token;
|
||||
|
||||
using Functor = Impl<typename IdArray::ExecutionTypes<Device>::PortalConst,
|
||||
@ -128,14 +127,13 @@ struct TestLowerBound
|
||||
{
|
||||
using Algo = vtkm::cont::DeviceAdapterAlgorithm<Device>;
|
||||
|
||||
std::vector<vtkm::Id> needlesData{ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 };
|
||||
std::vector<vtkm::Id> hayStackData{ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 };
|
||||
std::vector<vtkm::Id> expected{ 0, 0, 1, 4, 4, 6, 9, 9, 9, 11 };
|
||||
|
||||
IdArray needles = vtkm::cont::make_ArrayHandle(needlesData);
|
||||
IdArray hayStack = vtkm::cont::make_ArrayHandle(hayStackData);
|
||||
IdArray needles = vtkm::cont::make_ArrayHandle<vtkm::Id>({ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 });
|
||||
IdArray hayStack =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 });
|
||||
IdArray results;
|
||||
|
||||
std::vector<vtkm::Id> expected{ 0, 0, 1, 4, 4, 6, 9, 9, 9, 11 };
|
||||
|
||||
vtkm::cont::Token token;
|
||||
|
||||
using Functor = Impl<typename IdArray::ExecutionTypes<Device>::PortalConst,
|
||||
@ -187,14 +185,13 @@ struct TestUpperBound
|
||||
{
|
||||
using Algo = vtkm::cont::DeviceAdapterAlgorithm<Device>;
|
||||
|
||||
std::vector<vtkm::Id> needlesData{ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 };
|
||||
std::vector<vtkm::Id> hayStackData{ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 };
|
||||
std::vector<vtkm::Id> expected{ 0, 1, 4, 4, 6, 9, 9, 9, 11, 11 };
|
||||
|
||||
IdArray needles = vtkm::cont::make_ArrayHandle(needlesData);
|
||||
IdArray hayStack = vtkm::cont::make_ArrayHandle(hayStackData);
|
||||
IdArray needles = vtkm::cont::make_ArrayHandle<vtkm::Id>({ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 });
|
||||
IdArray hayStack =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 });
|
||||
IdArray results;
|
||||
|
||||
std::vector<vtkm::Id> expected{ 0, 1, 4, 4, 6, 9, 9, 9, 11, 11 };
|
||||
|
||||
vtkm::cont::Token token;
|
||||
|
||||
using Functor = Impl<typename IdArray::ExecutionTypes<Device>::PortalConst,
|
||||
|
@ -334,18 +334,20 @@ public:
|
||||
InDataSet.GetField("vecData").GetData().CopyTo(fieldArray);
|
||||
|
||||
// Generate random seeds for starting streamlines
|
||||
std::vector<vtkm::Vec<FieldType, 3>> seeds;
|
||||
for (vtkm::Id i = 0; i < numSeeds; i++)
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> seedPosArray;
|
||||
seedPosArray.Allocate(numSeeds);
|
||||
{
|
||||
vtkm::Vec<FieldType, 3> seed;
|
||||
seed[0] = static_cast<FieldType>(rand() % vdims[0]);
|
||||
seed[1] = static_cast<FieldType>(rand() % vdims[1]);
|
||||
seed[2] = static_cast<FieldType>(rand() % vdims[2]);
|
||||
seeds.push_back(seed);
|
||||
auto seedPosPortal = seedPosArray.WritePortal();
|
||||
for (vtkm::Id i = 0; i < numSeeds; i++)
|
||||
{
|
||||
vtkm::Vec<FieldType, 3> seed;
|
||||
seed[0] = static_cast<FieldType>(rand() % vdims[0]);
|
||||
seed[1] = static_cast<FieldType>(rand() % vdims[1]);
|
||||
seed[2] = static_cast<FieldType>(rand() % vdims[2]);
|
||||
seedPosPortal.Set(i, seed);
|
||||
}
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> seedPosArray =
|
||||
vtkm::cont::make_ArrayHandle(&seeds[0], numSeeds);
|
||||
vtkm::cont::ArrayHandleCounting<vtkm::Id> seedIdArray(0, 1, numSeeds);
|
||||
vtkm::cont::ArrayHandleIndex seedIdArray(numSeeds);
|
||||
|
||||
// Number of streams * number of steps * [forward, backward]
|
||||
vtkm::Id numCells = numSeeds * 2;
|
||||
|
@ -111,10 +111,8 @@ template <typename T, vtkm::IdComponent N>
|
||||
vtkm::cont::ArrayHandle<T> copyFromVec(vtkm::cont::ArrayHandle<vtkm::Vec<T, N>> const& other)
|
||||
{
|
||||
const T* vmem = reinterpret_cast<const T*>(&*other.ReadPortal().GetIteratorBegin());
|
||||
vtkm::cont::ArrayHandle<T> mem =
|
||||
vtkm::cont::make_ArrayHandle(vmem, other.GetNumberOfValues() * N);
|
||||
vtkm::cont::ArrayHandle<T> result;
|
||||
vtkm::cont::ArrayCopy(mem, result);
|
||||
vtkm::cont::ArrayHandle<T> result =
|
||||
vtkm::cont::make_ArrayHandle(vmem, other.GetNumberOfValues() * N, vtkm::CopyFlag::On);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
@ -2522,10 +2522,12 @@ public:
|
||||
};
|
||||
|
||||
ClipTables()
|
||||
: ClipTablesDataArray(vtkm::cont::make_ArrayHandle(ClipTablesData, CLIP_TABLES_DATA_SIZE))
|
||||
, ClipTablesIndicesArray(
|
||||
vtkm::cont::make_ArrayHandle(ClipTablesIndices, CLIP_TABLES_INDICES_SIZE))
|
||||
, CellEdgesArray(vtkm::cont::make_ArrayHandle(CellEdges, CELL_EDGES_SIZE))
|
||||
: ClipTablesDataArray(
|
||||
vtkm::cont::make_ArrayHandle(ClipTablesData, CLIP_TABLES_DATA_SIZE, vtkm::CopyFlag::Off))
|
||||
, ClipTablesIndicesArray(vtkm::cont::make_ArrayHandle(ClipTablesIndices,
|
||||
CLIP_TABLES_INDICES_SIZE,
|
||||
vtkm::CopyFlag::Off))
|
||||
, CellEdgesArray(vtkm::cont::make_ArrayHandle(CellEdges, CELL_EDGES_SIZE, vtkm::CopyFlag::Off))
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -506,13 +506,16 @@ public:
|
||||
};
|
||||
|
||||
CellClassifyTable()
|
||||
: NumVerticesPerCellArray(
|
||||
vtkm::cont::make_ArrayHandle(NumVerticesPerCellTable, vtkm::NUMBER_OF_CELL_SHAPES))
|
||||
, NumTrianglesTableOffsetArray(
|
||||
vtkm::cont::make_ArrayHandle(NumTrianglesTableOffset, vtkm::NUMBER_OF_CELL_SHAPES))
|
||||
: NumVerticesPerCellArray(vtkm::cont::make_ArrayHandle(NumVerticesPerCellTable,
|
||||
vtkm::NUMBER_OF_CELL_SHAPES,
|
||||
vtkm::CopyFlag::Off))
|
||||
, NumTrianglesTableOffsetArray(vtkm::cont::make_ArrayHandle(NumTrianglesTableOffset,
|
||||
vtkm::NUMBER_OF_CELL_SHAPES,
|
||||
vtkm::CopyFlag::Off))
|
||||
, NumTrianglesTableArray(
|
||||
vtkm::cont::make_ArrayHandle(NumTrianglesTable,
|
||||
sizeof(NumTrianglesTable) / sizeof(NumTrianglesTable[0])))
|
||||
sizeof(NumTrianglesTable) / sizeof(NumTrianglesTable[0]),
|
||||
vtkm::CopyFlag::Off))
|
||||
{
|
||||
}
|
||||
|
||||
@ -603,17 +606,21 @@ public:
|
||||
}
|
||||
|
||||
TriangleGenerationTable()
|
||||
: EdgeTableArray(
|
||||
vtkm::cont::make_ArrayHandle(EdgeTable, sizeof(EdgeTable) / sizeof(EdgeTable[0])))
|
||||
: EdgeTableArray(vtkm::cont::make_ArrayHandle(EdgeTable,
|
||||
sizeof(EdgeTable) / sizeof(EdgeTable[0]),
|
||||
vtkm::CopyFlag::Off))
|
||||
, EdgeTableOffsetArray(
|
||||
vtkm::cont::make_ArrayHandle(EdgeTableOffset,
|
||||
sizeof(EdgeTableOffset) / sizeof(EdgeTableOffset[0])))
|
||||
sizeof(EdgeTableOffset) / sizeof(EdgeTableOffset[0]),
|
||||
vtkm::CopyFlag::Off))
|
||||
, TriangleTableArray(
|
||||
vtkm::cont::make_ArrayHandle(TriangleTable,
|
||||
sizeof(TriangleTable) / sizeof(TriangleTable[0])))
|
||||
sizeof(TriangleTable) / sizeof(TriangleTable[0]),
|
||||
vtkm::CopyFlag::Off))
|
||||
, TriangleTableOffsetArray(
|
||||
vtkm::cont::make_ArrayHandle(TriangleTableOffset,
|
||||
sizeof(TriangleTableOffset) / sizeof(TriangleTableOffset[0])))
|
||||
sizeof(TriangleTableOffset) / sizeof(TriangleTableOffset[0]),
|
||||
vtkm::CopyFlag::Off))
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -626,7 +626,8 @@ vtkm::cont::CellSetSingleType<> execute(
|
||||
// Setup the invoker
|
||||
vtkm::cont::Invoker invoker;
|
||||
|
||||
vtkm::cont::ArrayHandle<ValueType> isoValuesHandle = vtkm::cont::make_ArrayHandle(isovalues);
|
||||
vtkm::cont::ArrayHandle<ValueType> isoValuesHandle =
|
||||
vtkm::cont::make_ArrayHandle(isovalues, vtkm::CopyFlag::Off);
|
||||
|
||||
// Call the ClassifyCell functor to compute the Marching Cubes case numbers
|
||||
// for each cell, and the number of vertices to be generated
|
||||
|
@ -903,7 +903,7 @@ void ContourTree<T, StorageType>::CollectSaddlePeak(
|
||||
|
||||
// Setting saddlePeak reference to the make_ArrayHandle directly does not work
|
||||
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> tempArray =
|
||||
vtkm::cont::make_ArrayHandle(superarcVector);
|
||||
vtkm::cont::make_ArrayHandle(superarcVector, vtkm::CopyFlag::Off);
|
||||
|
||||
// now sort it
|
||||
vtkm::cont::Algorithm::Sort(tempArray, SaddlePeakSort());
|
||||
|
@ -149,10 +149,10 @@ Mesh3D_DEM_Triangulation<T, StorageType>::Mesh3D_DEM_Triangulation(
|
||||
for (vtkm::Id shifter = NumVertices; shifter > 0; shifter >>= 1)
|
||||
nLogSteps++;
|
||||
|
||||
neighbourOffsets3D =
|
||||
vtkm::cont::make_ArrayHandle(vtkm::worklet::contourtree::neighbourOffsets3D, 42);
|
||||
linkComponentCaseTable3D =
|
||||
vtkm::cont::make_ArrayHandle(vtkm::worklet::contourtree::linkComponentCaseTable3D, 16384);
|
||||
neighbourOffsets3D = vtkm::cont::make_ArrayHandle(
|
||||
vtkm::worklet::contourtree::neighbourOffsets3D, 42, vtkm::CopyFlag::Off);
|
||||
linkComponentCaseTable3D = vtkm::cont::make_ArrayHandle(
|
||||
vtkm::worklet::contourtree::linkComponentCaseTable3D, 16384, vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
// sets outgoing paths for saddles
|
||||
|
@ -146,9 +146,8 @@ public:
|
||||
|
||||
// now sort it
|
||||
// Setting saddlePeak reference to the make_ArrayHandle directly does not work
|
||||
EdgePairArray tempArray = vtkm::cont::make_ArrayHandle(arcSorter);
|
||||
vtkm::cont::Algorithm::Sort(tempArray, SaddlePeakSort());
|
||||
vtkm::cont::ArrayCopy(tempArray, sortedArcs);
|
||||
sortedArcs = vtkm::cont::make_ArrayHandle(arcSorter, vtkm::CopyFlag::On);
|
||||
vtkm::cont::Algorithm::Sort(sortedArcs, SaddlePeakSort());
|
||||
} // CollectSortedArcs
|
||||
|
||||
// collect the sorted superarcs
|
||||
@ -202,11 +201,10 @@ public:
|
||||
} // per vertex
|
||||
|
||||
// Setting saddlePeak reference to the make_ArrayHandle directly does not work
|
||||
EdgePairArray tempArray = vtkm::cont::make_ArrayHandle(superarcSorter);
|
||||
saddlePeak = vtkm::cont::make_ArrayHandle(superarcSorter, vtkm::CopyFlag::On);
|
||||
|
||||
// now sort it
|
||||
vtkm::cont::Algorithm::Sort(tempArray, SaddlePeakSort());
|
||||
vtkm::cont::ArrayCopy(tempArray, saddlePeak);
|
||||
vtkm::cont::Algorithm::Sort(saddlePeak, SaddlePeakSort());
|
||||
} // CollectSortedSuperarcs()
|
||||
|
||||
// routine to compute the volume for each hyperarc and superarc
|
||||
|
@ -107,8 +107,10 @@ Mesh_DEM_Triangulation_2D_Freudenthal<T, StorageType>::Mesh_DEM_Triangulation_2D
|
||||
: Mesh_DEM_Triangulation_2D<T, StorageType>(ncols, nrows)
|
||||
|
||||
{
|
||||
this->EdgeBoundaryDetectionMasks = vtkm::cont::make_ArrayHandle(
|
||||
m2d_freudenthal::EdgeBoundaryDetectionMasks, m2d_freudenthal::N_INCIDENT_EDGES);
|
||||
this->EdgeBoundaryDetectionMasks =
|
||||
vtkm::cont::make_ArrayHandle(m2d_freudenthal::EdgeBoundaryDetectionMasks,
|
||||
m2d_freudenthal::N_INCIDENT_EDGES,
|
||||
vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
template <typename T, typename StorageType>
|
||||
|
@ -114,12 +114,16 @@ Mesh_DEM_Triangulation_3D_Freudenthal<T, StorageType>::Mesh_DEM_Triangulation_3D
|
||||
|
||||
{
|
||||
// Initialize the case tables in vtkm
|
||||
this->EdgeBoundaryDetectionMasks = vtkm::cont::make_ArrayHandle(
|
||||
m3d_freudenthal::EdgeBoundaryDetectionMasks, m3d_freudenthal::N_INCIDENT_EDGES);
|
||||
this->EdgeBoundaryDetectionMasks =
|
||||
vtkm::cont::make_ArrayHandle(m3d_freudenthal::EdgeBoundaryDetectionMasks,
|
||||
m3d_freudenthal::N_INCIDENT_EDGES,
|
||||
vtkm::CopyFlag::Off);
|
||||
this->NeighbourOffsets = vtkm::cont::make_ArrayHandleGroupVec<3>(vtkm::cont::make_ArrayHandle(
|
||||
m3d_freudenthal::NeighbourOffsets, m3d_freudenthal::N_INCIDENT_EDGES * 3));
|
||||
this->LinkComponentCaseTable = vtkm::cont::make_ArrayHandle(
|
||||
m3d_freudenthal::LinkComponentCaseTable, m3d_freudenthal::LINK_COMPONENT_CASES);
|
||||
m3d_freudenthal::NeighbourOffsets, m3d_freudenthal::N_INCIDENT_EDGES * 3, vtkm::CopyFlag::Off));
|
||||
this->LinkComponentCaseTable =
|
||||
vtkm::cont::make_ArrayHandle(m3d_freudenthal::LinkComponentCaseTable,
|
||||
m3d_freudenthal::LINK_COMPONENT_CASES,
|
||||
vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
|
||||
|
@ -118,37 +118,42 @@ Mesh_DEM_Triangulation_3D_MarchingCubes<T, StorageType>::Mesh_DEM_Triangulation_
|
||||
|
||||
{
|
||||
// Initialize the case tables in vtkm
|
||||
this->EdgeBoundaryDetectionMasks = vtkm::cont::make_ArrayHandle(
|
||||
m3d_marchingcubes::EdgeBoundaryDetectionMasks, m3d_marchingcubes::N_ALL_NEIGHBOURS);
|
||||
this->EdgeBoundaryDetectionMasks =
|
||||
vtkm::cont::make_ArrayHandle(m3d_marchingcubes::EdgeBoundaryDetectionMasks,
|
||||
m3d_marchingcubes::N_ALL_NEIGHBOURS,
|
||||
vtkm::CopyFlag::Off);
|
||||
this->CubeVertexPermutations = vtkm::cont::make_ArrayHandleGroupVec<
|
||||
m3d_marchingcubes::
|
||||
CubeVertexPermutations_PermVecLength>( // create 2D array of vectors of lenghts ...PermVecLength
|
||||
vtkm::cont::make_ArrayHandle(
|
||||
m3d_marchingcubes::CubeVertexPermutations, // the array to convert
|
||||
m3d_marchingcubes::CubeVertexPermutations_NumPermutations *
|
||||
m3d_marchingcubes::CubeVertexPermutations_PermVecLength // total number of elements
|
||||
));
|
||||
m3d_marchingcubes::CubeVertexPermutations_PermVecLength, // total number of elements
|
||||
vtkm::CopyFlag::Off));
|
||||
this->LinkVertexConnectionsSix = vtkm::cont::make_ArrayHandleGroupVec<
|
||||
m3d_marchingcubes::
|
||||
VertexConnections_VecLength>( // create 2D array of vectors o lenght ...VecLength
|
||||
vtkm::cont::make_ArrayHandle(
|
||||
m3d_marchingcubes::LinkVertexConnectionsSix, // the array to convert
|
||||
m3d_marchingcubes::LinkVertexConnectionsSix_NumPairs *
|
||||
m3d_marchingcubes::VertexConnections_VecLength // total number of elements
|
||||
));
|
||||
m3d_marchingcubes::VertexConnections_VecLength, // total number of elements
|
||||
vtkm::CopyFlag::Off));
|
||||
this->LinkVertexConnectionsEighteen = vtkm::cont::make_ArrayHandleGroupVec<
|
||||
m3d_marchingcubes::
|
||||
VertexConnections_VecLength>( // create 2D array of vectors o lenght ...VecLength
|
||||
vtkm::cont::make_ArrayHandle(
|
||||
m3d_marchingcubes::LinkVertexConnectionsEighteen, // the array to convert
|
||||
m3d_marchingcubes::LinkVertexConnectionsEighteen_NumPairs *
|
||||
m3d_marchingcubes::VertexConnections_VecLength // total number of elements
|
||||
));
|
||||
this->InCubeConnectionsSix = vtkm::cont::make_ArrayHandle(
|
||||
m3d_marchingcubes::InCubeConnectionsSix, m3d_marchingcubes::InCubeConnectionsSix_NumElements);
|
||||
m3d_marchingcubes::VertexConnections_VecLength, // total number of elements
|
||||
vtkm::CopyFlag::Off));
|
||||
this->InCubeConnectionsSix =
|
||||
vtkm::cont::make_ArrayHandle(m3d_marchingcubes::InCubeConnectionsSix,
|
||||
m3d_marchingcubes::InCubeConnectionsSix_NumElements,
|
||||
vtkm::CopyFlag::Off);
|
||||
this->InCubeConnectionsEighteen =
|
||||
vtkm::cont::make_ArrayHandle(m3d_marchingcubes::InCubeConnectionsEighteen,
|
||||
m3d_marchingcubes::InCubeConnectionsEighteen_NumElements);
|
||||
m3d_marchingcubes::InCubeConnectionsEighteen_NumElements,
|
||||
vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
template <typename T, typename StorageType>
|
||||
|
@ -115,14 +115,10 @@ public:
|
||||
//cont::ArrayHandle<Id> first;
|
||||
cont::ArrayHandle<Id> next;
|
||||
|
||||
vtkm::cont::ArrayCopy(
|
||||
vtkm::cont::make_ArrayHandle(std::vector<Id>(
|
||||
static_cast<unsigned long>(superarcs.GetNumberOfValues()), NO_SUCH_ELEMENT)),
|
||||
first);
|
||||
vtkm::cont::ArrayCopy(
|
||||
vtkm::cont::make_ArrayHandle(
|
||||
std::vector<Id>(static_cast<unsigned long>(edges.GetNumberOfValues()), NO_SUCH_ELEMENT)),
|
||||
next);
|
||||
first = vtkm::cont::make_ArrayHandleMove(
|
||||
std::vector<Id>(static_cast<unsigned long>(superarcs.GetNumberOfValues()), NO_SUCH_ELEMENT));
|
||||
next = vtkm::cont::make_ArrayHandleMove(
|
||||
std::vector<Id>(static_cast<unsigned long>(edges.GetNumberOfValues()), NO_SUCH_ELEMENT));
|
||||
|
||||
//
|
||||
// Compute First and Next arrays that are needed to compute the euler tour linked list
|
||||
|
@ -181,10 +181,14 @@ public:
|
||||
VTKM_CONT
|
||||
TriangulateTables()
|
||||
: Counts(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TriangleCountData,
|
||||
vtkm::NUMBER_OF_CELL_SHAPES))
|
||||
vtkm::NUMBER_OF_CELL_SHAPES,
|
||||
vtkm::CopyFlag::Off))
|
||||
, Offsets(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TriangleOffsetData,
|
||||
vtkm::NUMBER_OF_CELL_SHAPES))
|
||||
, Indices(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TriangleIndexData, vtkm::Id(9)))
|
||||
vtkm::NUMBER_OF_CELL_SHAPES,
|
||||
vtkm::CopyFlag::Off))
|
||||
, Indices(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TriangleIndexData,
|
||||
vtkm::Id(9),
|
||||
vtkm::CopyFlag::Off))
|
||||
{
|
||||
}
|
||||
|
||||
@ -382,11 +386,14 @@ public:
|
||||
VTKM_CONT
|
||||
TetrahedralizeTables()
|
||||
: Counts(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TetrahedronCountData,
|
||||
vtkm::NUMBER_OF_CELL_SHAPES))
|
||||
vtkm::NUMBER_OF_CELL_SHAPES,
|
||||
vtkm::CopyFlag::Off))
|
||||
, Offsets(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TetrahedronOffsetData,
|
||||
vtkm::NUMBER_OF_CELL_SHAPES))
|
||||
, Indices(
|
||||
vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TetrahedronIndexData, vtkm::Id(44)))
|
||||
vtkm::NUMBER_OF_CELL_SHAPES,
|
||||
vtkm::CopyFlag::Off))
|
||||
, Indices(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TetrahedronIndexData,
|
||||
vtkm::Id(44),
|
||||
vtkm::CopyFlag::Off))
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -60,7 +60,8 @@ void TryKeyType(KeyType)
|
||||
{
|
||||
keyBuffer[index] = TestValue(index % NUM_UNIQUE, KeyType());
|
||||
}
|
||||
vtkm::cont::ArrayHandle<KeyType> keysArray = vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<KeyType> keysArray =
|
||||
vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
|
||||
// Create Keys object
|
||||
vtkm::cont::ArrayHandle<KeyType> sortedKeys;
|
||||
|
@ -84,7 +84,8 @@ void TestCellGradientUniform3DWithVectorField()
|
||||
{
|
||||
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
|
||||
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::Off);
|
||||
|
||||
//we need to add Vec3 array to the dataset
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_64, 3>> result;
|
||||
@ -159,7 +160,8 @@ void TestCellGradientUniform3DWithVectorField2()
|
||||
{
|
||||
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
|
||||
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::worklet::GradientOutputFields<vtkm::Vec3f_64> extraOutput;
|
||||
extraOutput.SetComputeGradient(false);
|
||||
|
@ -40,10 +40,11 @@ private:
|
||||
public:
|
||||
void TestTriangleMesh() const
|
||||
{
|
||||
std::vector<vtkm::Id> connectivity = { 0, 2, 4, 1, 3, 5, 2, 6, 4, 5, 3, 7, 2, 9, 6, 4, 6, 8 };
|
||||
auto connectivity = vtkm::cont::make_ArrayHandle<vtkm::Id>(
|
||||
{ 0, 2, 4, 1, 3, 5, 2, 6, 4, 5, 3, 7, 2, 9, 6, 4, 6, 8 });
|
||||
|
||||
vtkm::cont::CellSetSingleType<> cellSet;
|
||||
cellSet.Fill(8, vtkm::CELL_SHAPE_TRIANGLE, 3, vtkm::cont::make_ArrayHandle(connectivity));
|
||||
cellSet.Fill(8, vtkm::CELL_SHAPE_TRIANGLE, 3, connectivity);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> numIndicesArray;
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> indexOffsetArray;
|
||||
|
@ -964,7 +964,7 @@ public:
|
||||
37, 83, 91, 33, 41, 82, 92, 32, 42, 86, 88, 36, 38, 81, 93, 31, 43
|
||||
};
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType expectedSortOrder =
|
||||
vtkm::cont::make_ArrayHandle(expectedSortOrderArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(expectedSortOrderArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id expectedSortIndicesArr[125] = {
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
|
||||
@ -976,7 +976,7 @@ public:
|
||||
81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
|
||||
};
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType expectedSortIndices =
|
||||
vtkm::cont::make_ArrayHandle(expectedSortIndicesArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(expectedSortIndicesArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
//
|
||||
// Join Tree Set Starts
|
||||
@ -996,7 +996,7 @@ public:
|
||||
meshExtremaPeaksJoinArr[i] | vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
|
||||
}
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPeaksJoin =
|
||||
vtkm::cont::make_ArrayHandle(meshExtremaPeaksJoinArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(meshExtremaPeaksJoinArr, 125, vtkm::CopyFlag::On);
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPitsJoin;
|
||||
vtkm::cont::Algorithm::Copy(vtkm::cont::ArrayHandleConstant<vtkm::Id>(0, 125),
|
||||
meshExtremaPitsJoin);
|
||||
@ -1019,7 +1019,8 @@ public:
|
||||
vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
|
||||
}
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPeaksBuildRegularChainsJoin =
|
||||
vtkm::cont::make_ArrayHandle(meshExtremaPeaksBuildRegularChainsJoinArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(
|
||||
meshExtremaPeaksBuildRegularChainsJoinArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPitsBuildRegularChainsJoin =
|
||||
meshExtremaPitsJoin; // should remain all at 0
|
||||
@ -1043,7 +1044,7 @@ public:
|
||||
meshExtremaPeaksSplitArr[i] | vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
|
||||
}
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPeaksSplit =
|
||||
vtkm::cont::make_ArrayHandle(meshExtremaPeaksSplitArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(meshExtremaPeaksSplitArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id meshExtremaPitsSplitArr[125] = {
|
||||
0, 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||||
@ -1058,7 +1059,7 @@ public:
|
||||
meshExtremaPitsSplitArr[98] =
|
||||
meshExtremaPitsSplitArr[97] | vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPitsSplit =
|
||||
vtkm::cont::make_ArrayHandle(meshExtremaPitsSplitArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(meshExtremaPitsSplitArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
//
|
||||
// Split Tree Build Regular chains
|
||||
@ -1079,7 +1080,8 @@ public:
|
||||
vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
|
||||
}
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPeaksBuildRegularChainsSplit =
|
||||
vtkm::cont::make_ArrayHandle(meshExtremaPeaksBuildRegularChainsSplitArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(
|
||||
meshExtremaPeaksBuildRegularChainsSplitArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id meshExtremaPitsBuildRegularChainsSplitArr[125] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
@ -1094,7 +1096,8 @@ public:
|
||||
vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
|
||||
}
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPitsBuildRegularChainsSplit =
|
||||
vtkm::cont::make_ArrayHandle(meshExtremaPitsBuildRegularChainsSplitArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(
|
||||
meshExtremaPitsBuildRegularChainsSplitArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
//
|
||||
// Join Graph Initialize
|
||||
@ -1103,19 +1106,19 @@ public:
|
||||
vtkm::Id activeGraphJoinTreeInitGlobalIndexArr[12] = { 103, 104, 105, 106, 113, 114,
|
||||
115, 116, 121, 122, 123, 124 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitGlobalIndex =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitGlobalIndexArr, 12);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitGlobalIndexArr, 12, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize FirstEdge
|
||||
vtkm::Id activeGraphJoinTreeInitFirstEdgeArr[12] = {
|
||||
0, 2, 4, 6, 8, 10, 12, 14, 16, 16, 16, 16
|
||||
};
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitFirstEdge =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitFirstEdgeArr, 12);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitFirstEdgeArr, 12, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize Outdegree
|
||||
vtkm::Id activeGraphJoinTreeInitOutdegreeArr[12] = { 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitOutdegree =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitOutdegreeArr, 12);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitOutdegreeArr, 12, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize Hyperarcs
|
||||
vtkm::Id activeGraphJoinTreeInitHyperarcsArr[12] = {
|
||||
@ -1127,32 +1130,33 @@ public:
|
||||
vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
|
||||
}
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitHyperarcs =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitHyperarcsArr, 12);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitHyperarcsArr, 12, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize ActiveVertices
|
||||
vtkm::Id activeGraphJoinTreeInitActiveVerticesArr[12] = {
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
|
||||
};
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitActiveVertices =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitActiveVerticesArr, 12);
|
||||
vtkm::cont::make_ArrayHandle(
|
||||
activeGraphJoinTreeInitActiveVerticesArr, 12, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize EdgeNear
|
||||
vtkm::Id activeGraphJoinTreeInitEdgeNearArr[16] = { 0, 0, 1, 1, 2, 2, 3, 3,
|
||||
4, 4, 5, 5, 6, 6, 7, 7 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitEdgeNear =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitEdgeNearArr, 16);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitEdgeNearArr, 16, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize , EdgeFar
|
||||
vtkm::Id activeGraphJoinTreeInitEdgeFarArr[16] = { 10, 8, 10, 9, 10, 9, 10, 8,
|
||||
8, 9, 8, 9, 10, 11, 10, 11 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitEdgeFar =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitEdgeFarArr, 16);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitEdgeFarArr, 16, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize , ActiveEdges
|
||||
vtkm::Id activeGraphJoinTreeInitActiveEdgesArr[16] = { 0, 1, 2, 3, 4, 5, 6, 7,
|
||||
8, 9, 10, 11, 12, 13, 14, 15 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitActiveEdges =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitActiveEdgesArr, 16);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitActiveEdgesArr, 16, vtkm::CopyFlag::On);
|
||||
|
||||
//
|
||||
// Split Graph Initialize
|
||||
@ -1160,17 +1164,17 @@ public:
|
||||
// Active graph join graph initialize GlobalIndex
|
||||
vtkm::Id activeGraphSplitTreeInitGlobalIndexArr[8] = { 0, 98, 99, 100, 101, 102, 107, 108 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitGlobalIndex =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitGlobalIndexArr, 8);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitGlobalIndexArr, 8, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize FirstEdge
|
||||
vtkm::Id activeGraphSplitTreeInitFirstEdgeArr[8] = { 0, 0, 0, 2, 4, 6, 8, 10 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitFirstEdge =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitFirstEdgeArr, 8);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitFirstEdgeArr, 8, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize Outdegree
|
||||
vtkm::Id activeGraphSplitTreeInitOutdegreeArr[8] = { 0, 0, 2, 2, 2, 2, 2, 2 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitOutdegree =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitOutdegreeArr, 8);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitOutdegreeArr, 8, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize Hyperarcs
|
||||
vtkm::Id activeGraphSplitTreeInitHyperarcsArr[8] = { 0, 1, 1, 1, 0, 0, 0, 0 };
|
||||
@ -1180,27 +1184,28 @@ public:
|
||||
vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
|
||||
}
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitHyperarcs =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitHyperarcsArr, 8);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitHyperarcsArr, 8, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize ActiveVertices
|
||||
vtkm::Id activeGraphSplitTreeInitActiveVerticesArr[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitActiveVertices =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitActiveVerticesArr, 8);
|
||||
vtkm::cont::make_ArrayHandle(
|
||||
activeGraphSplitTreeInitActiveVerticesArr, 8, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize EdgeNear
|
||||
vtkm::Id activeGraphSplitTreeInitEdgeNearArr[12] = { 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitEdgeNear =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitEdgeNearArr, 12);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitEdgeNearArr, 12, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize , EdgeFar
|
||||
vtkm::Id activeGraphSplitTreeInitEdgeFarArr[12] = { 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitEdgeFar =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitEdgeFarArr, 12);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitEdgeFarArr, 12, vtkm::CopyFlag::On);
|
||||
|
||||
// Active graph join graph initialize , ActiveEdges
|
||||
vtkm::Id activeGraphSplitTreeInitActiveEdgesArr[12] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitActiveEdges =
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitActiveEdgesArr, 12);
|
||||
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitActiveEdgesArr, 12, vtkm::CopyFlag::On);
|
||||
|
||||
//
|
||||
// JoinTree MakeMergeTree
|
||||
@ -1219,7 +1224,7 @@ public:
|
||||
makeJoinTreeArcsArr[0] =
|
||||
makeJoinTreeArcsArr[0] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeArcs =
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeArcsArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeArcsArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeJoinTreeSuperparentsArr[125] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
@ -1229,35 +1234,35 @@ public:
|
||||
0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 1, 2, 2, 1, 1, 2, 2, 3, 4, 5, 6, 3, 4, 5, 6
|
||||
};
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeSuperparents =
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeSuperparentsArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeSuperparentsArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeJoinTreeSupernodesArr[7] = { 106, 114, 116, 121, 122, 123, 124 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeSupernodes =
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeSupernodesArr, 7);
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeSupernodesArr, 7, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeJoinTreeSuperarcsArr[7] = { 0, 0, 0, 1, 1, 2, 2 };
|
||||
makeJoinTreeSuperarcsArr[0] =
|
||||
makeJoinTreeSuperarcsArr[0] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeSuperarcs =
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeSuperarcsArr, 7);
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeSuperarcsArr, 7, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeJoinTreeHyperparentsArr[7] = { 0, 1, 2, 3, 4, 5, 6 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeHyperparents =
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeHyperparentsArr, 7);
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeHyperparentsArr, 7, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeJoinTreeHypernodesArr[7] = { 0, 1, 2, 3, 4, 5, 6 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeHypernodes =
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeHypernodesArr, 7);
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeHypernodesArr, 7, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeJoinTreeHyperarcsArr[7] = { 0, 0, 0, 1, 1, 2, 2 };
|
||||
makeJoinTreeHyperarcsArr[0] =
|
||||
makeJoinTreeHyperarcsArr[0] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeHyperarcs =
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeHyperarcsArr, 7);
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeHyperarcsArr, 7, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeJoinTreeFirstSuperchildArr[7] = { 0, 1, 2, 3, 4, 5, 6 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeFirstSuperchild =
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeFirstSuperchildArr, 7);
|
||||
vtkm::cont::make_ArrayHandle(makeJoinTreeFirstSuperchildArr, 7, vtkm::CopyFlag::On);
|
||||
|
||||
|
||||
//
|
||||
@ -1277,7 +1282,7 @@ public:
|
||||
makeSplitTreeArcsArr[124] =
|
||||
makeSplitTreeArcsArr[124] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeArcs =
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeArcsArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeArcsArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeSplitTreeSuperparentsArr[125] = {
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
@ -1287,37 +1292,37 @@ public:
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
};
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeSuperparents =
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeSuperparentsArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeSuperparentsArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeSplitTreeSupernodesArr[3] = { 99, 98, 0 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeSupernodes =
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeSupernodesArr, 3);
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeSupernodesArr, 3, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeSplitTreeSuperarcsArr[3] = {
|
||||
0 | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT, 0, 0
|
||||
};
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeSuperarcs =
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeSuperarcsArr, 3);
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeSuperarcsArr, 3, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeSplitTreeHyperparentsArr[3] = { 2, 1, 0 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeHyperparents =
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeHyperparentsArr, 3);
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeHyperparentsArr, 3, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeSplitTreeHypernodesArr[3] = {
|
||||
2, 1, 0,
|
||||
};
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeHypernodes =
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeHypernodesArr, 3);
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeHypernodesArr, 3, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeSplitTreeHyperarcsArr[3] = {
|
||||
0, 0, 0 | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT
|
||||
};
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeHyperarcs =
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeHyperarcsArr, 3);
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeHyperarcsArr, 3, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeSplitTreeFirstSuperchildArr[3] = { 2, 1, 0 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeFirstSuperchild =
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeFirstSuperchildArr, 3);
|
||||
vtkm::cont::make_ArrayHandle(makeSplitTreeFirstSuperchildArr, 3, vtkm::CopyFlag::On);
|
||||
|
||||
//
|
||||
// Contour Tree Compute
|
||||
@ -1337,7 +1342,7 @@ public:
|
||||
|
||||
vtkm::Id makeContourTreeSupernodesArr[10] = { 121, 122, 123, 124, 0, 98, 114, 116, 99, 106 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeSupernodes =
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeSupernodesArr, 10);
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeSupernodesArr, 10, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeContourTreeSuperarcsArr[10] = { 6, 6, 7, 7, 8, 8, 9, 9, 9, 0 };
|
||||
makeContourTreeSuperarcsArr[4] =
|
||||
@ -1350,7 +1355,7 @@ public:
|
||||
makeContourTreeSuperarcsArr[9] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
|
||||
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeSuperarcs =
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeSuperarcsArr, 10);
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeSuperarcsArr, 10, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeAugmentnodes;
|
||||
|
||||
@ -1358,7 +1363,7 @@ public:
|
||||
|
||||
vtkm::Id makeContourTreeHyperparentsArr[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeHyperparents =
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeHyperparentsArr, 10);
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeHyperparentsArr, 10, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeContourTreeWhenTransferredArr[10] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 4 };
|
||||
for (vtkm::Id i = 0; i < 10; i++)
|
||||
@ -1367,11 +1372,11 @@ public:
|
||||
makeContourTreeWhenTransferredArr[i] | vtkm::worklet::contourtree_augmented::IS_HYPERNODE;
|
||||
}
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeWhenTransferred =
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeWhenTransferredArr, 10);
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeWhenTransferredArr, 10, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeContourTreeHypernodesArr[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeHypernodes =
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeHypernodesArr, 10);
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeHypernodesArr, 10, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::Id makeContourTreeHyperarcsArr[10] = { 6, 6, 7, 7, 8, 8, 9, 9, 9, 0 };
|
||||
makeContourTreeHyperarcsArr[4] =
|
||||
@ -1383,7 +1388,7 @@ public:
|
||||
makeContourTreeHyperarcsArr[9] =
|
||||
makeContourTreeHyperarcsArr[9] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeHyperarcs =
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeHyperarcsArr, 10);
|
||||
vtkm::cont::make_ArrayHandle(makeContourTreeHyperarcsArr, 10, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeRegularStructureNodes;
|
||||
vtkm::worklet::contourtree_augmented::IdArrayType makeRegularStructureArcs;
|
||||
@ -1432,7 +1437,8 @@ public:
|
||||
82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 114,
|
||||
113, 110, 109, 107, 116, 115, 112, 111, 108, 99, 100, 101, 102, 103, 104, 105, 106
|
||||
};
|
||||
makeRegularStructureNodes = vtkm::cont::make_ArrayHandle(makeRegularStructureNodesArr, 125);
|
||||
makeRegularStructureNodes =
|
||||
vtkm::cont::make_ArrayHandle(makeRegularStructureNodesArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
makeRegularStructureArcsArr = new vtkm::Id[125]{
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
|
||||
@ -1450,7 +1456,8 @@ public:
|
||||
makeRegularStructureArcsArr[i] =
|
||||
makeRegularStructureArcsArr[i] | vtkm::worklet::contourtree_augmented::IS_ASCENDING;
|
||||
}
|
||||
makeRegularStructureArcs = vtkm::cont::make_ArrayHandle(makeRegularStructureArcsArr, 125);
|
||||
makeRegularStructureArcs =
|
||||
vtkm::cont::make_ArrayHandle(makeRegularStructureArcsArr, 125, vtkm::CopyFlag::On);
|
||||
|
||||
makeRegularStructureSuperparentsArr =
|
||||
new vtkm::Id[125]{ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
@ -1460,7 +1467,7 @@ public:
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 8, 8, 8, 8, 8, 8,
|
||||
8, 9, 6, 7, 6, 6, 7, 7, 6, 6, 7, 7, 0, 1, 2, 3, 0, 1, 2, 3 };
|
||||
makeRegularStructureSuperparents =
|
||||
vtkm::cont::make_ArrayHandle(makeRegularStructureSuperparentsArr, 125);
|
||||
vtkm::cont::make_ArrayHandle(makeRegularStructureSuperparentsArr, 125, vtkm::CopyFlag::On);
|
||||
makeRegularStructureSupernodes = makeContourTreeSupernodes;
|
||||
makeRegularStructureSuperarcs = makeContourTreeSuperarcs;
|
||||
makeRegularStructureAugmentnodes = makeContourTreeAugmentnodes;
|
||||
@ -1487,7 +1494,7 @@ public:
|
||||
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
|
||||
96, 97, 98, 99, 106, 114, 116, 121, 122, 123, 124 };
|
||||
makeRegularStructureAugmentnodes =
|
||||
vtkm::cont::make_ArrayHandle(makeRegularStructureAugmentnodesArr, 107);
|
||||
vtkm::cont::make_ArrayHandle(makeRegularStructureAugmentnodesArr, 107, vtkm::CopyFlag::On);
|
||||
|
||||
makeRegularStructureAugmentarcsArr =
|
||||
new vtkm::Id[107]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
|
||||
@ -1506,7 +1513,7 @@ public:
|
||||
}
|
||||
|
||||
makeRegularStructureAugmentarcs =
|
||||
vtkm::cont::make_ArrayHandle(makeRegularStructureAugmentarcsArr, 107);
|
||||
vtkm::cont::make_ArrayHandle(makeRegularStructureAugmentarcsArr, 107, vtkm::CopyFlag::On);
|
||||
|
||||
|
||||
makeRegularStructureHyperparents = makeContourTreeHyperparents;
|
||||
|
@ -66,8 +66,8 @@ void TestCrossProduct()
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> inputArray1, inputArray2;
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> outputArray;
|
||||
inputArray1 = vtkm::cont::make_ArrayHandle(inputVecs1);
|
||||
inputArray2 = vtkm::cont::make_ArrayHandle(inputVecs2);
|
||||
inputArray1 = vtkm::cont::make_ArrayHandle(inputVecs1, vtkm::CopyFlag::Off);
|
||||
inputArray2 = vtkm::cont::make_ArrayHandle(inputVecs2, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::worklet::CrossProduct crossProductWorklet;
|
||||
vtkm::worklet::DispatcherMapField<vtkm::worklet::CrossProduct> dispatcherCrossProduct(
|
||||
|
@ -15,8 +15,7 @@
|
||||
|
||||
void TestSingle()
|
||||
{
|
||||
std::vector<vtkm::Float32> single(1, 42);
|
||||
auto single_array = vtkm::cont::make_ArrayHandle(single);
|
||||
auto single_array = vtkm::cont::make_ArrayHandle<vtkm::Float32>({ 42 });
|
||||
auto result = vtkm::worklet::DescriptiveStatistics::Run(single_array);
|
||||
|
||||
VTKM_TEST_ASSERT(test_equal(result.N(), 1));
|
||||
@ -70,7 +69,7 @@ void TestStandardNormal()
|
||||
std::vector<vtkm::Float32> x(1000000);
|
||||
std::generate(x.begin(), x.end(), [&gen, &dis]() { return dis(gen); });
|
||||
|
||||
auto array = vtkm::cont::make_ArrayHandle(x);
|
||||
auto array = vtkm::cont::make_ArrayHandle(x, vtkm::CopyFlag::Off);
|
||||
auto result = vtkm::worklet::DescriptiveStatistics::Run(array);
|
||||
|
||||
// Variance should be positive
|
||||
@ -84,8 +83,8 @@ void TestStandardNormal()
|
||||
void TestCatastrophicCancellation()
|
||||
{
|
||||
// Good examples of the effect of catastrophic cancellation from Wikipedia.
|
||||
std::vector<vtkm::Float64> okay{ 1e8 + 4, 1e8 + 7, 1e8 + 13, 1.0e8 + 16 };
|
||||
auto arrayOK = vtkm::cont::make_ArrayHandle(okay);
|
||||
auto arrayOK =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float64>({ 1e8 + 4, 1e8 + 7, 1e8 + 13, 1.0e8 + 16 });
|
||||
auto resultOK = vtkm::worklet::DescriptiveStatistics::Run(arrayOK);
|
||||
|
||||
VTKM_TEST_ASSERT(test_equal(resultOK.N(), 4));
|
||||
@ -97,8 +96,8 @@ void TestCatastrophicCancellation()
|
||||
|
||||
// Bad examples of the effect of catastrophic cancellation from Wikipedia.
|
||||
// A naive algorithm will fail in calculating the correct variance
|
||||
std::vector<vtkm::Float64> evil{ 1e9 + 4, 1e9 + 7, 1e9 + 13, 1.0e9 + 16 };
|
||||
auto arrayEvil = vtkm::cont::make_ArrayHandle(evil);
|
||||
auto arrayEvil =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Float64>({ 1e9 + 4, 1e9 + 7, 1e9 + 13, 1.0e9 + 16 });
|
||||
auto resultEvil = vtkm::worklet::DescriptiveStatistics::Run(arrayEvil);
|
||||
|
||||
VTKM_TEST_ASSERT(test_equal(resultEvil.N(), 4));
|
||||
@ -125,7 +124,7 @@ void TestGeneGolub()
|
||||
i = dis(gen);
|
||||
}
|
||||
|
||||
auto array = vtkm::cont::make_ArrayHandle(v);
|
||||
auto array = vtkm::cont::make_ArrayHandle(v, vtkm::CopyFlag::Off);
|
||||
auto result = vtkm::worklet::DescriptiveStatistics::Run(array);
|
||||
|
||||
// Variance should be positive
|
||||
@ -146,8 +145,8 @@ void TestMeanProperties()
|
||||
std::transform(
|
||||
x.begin(), x.end(), axpb.begin(), [](vtkm::Float32 value) { return 4.0f * value + 1000.f; });
|
||||
|
||||
auto x_array = vtkm::cont::make_ArrayHandle(x);
|
||||
auto axpb_array = vtkm::cont::make_ArrayHandle(axpb);
|
||||
auto x_array = vtkm::cont::make_ArrayHandle(x, vtkm::CopyFlag::Off);
|
||||
auto axpb_array = vtkm::cont::make_ArrayHandle(axpb, vtkm::CopyFlag::Off);
|
||||
|
||||
auto mean_x = vtkm::worklet::DescriptiveStatistics::Run(x_array).Mean();
|
||||
auto mean_axpb = vtkm::worklet::DescriptiveStatistics::Run(axpb_array).Mean();
|
||||
@ -158,7 +157,7 @@ void TestMeanProperties()
|
||||
std::vector<vtkm::Float32> px = x;
|
||||
std::shuffle(px.begin(), px.end(), gen);
|
||||
|
||||
auto px_array = vtkm::cont::make_ArrayHandle(px);
|
||||
auto px_array = vtkm::cont::make_ArrayHandle(px, vtkm::CopyFlag::Off);
|
||||
auto mean_px = vtkm::worklet::DescriptiveStatistics::Run(px_array).Mean();
|
||||
|
||||
VTKM_TEST_ASSERT(test_equal(mean_x, mean_px, 0.01f));
|
||||
@ -178,8 +177,8 @@ void TestVarianceProperty()
|
||||
std::transform(
|
||||
v.begin(), v.end(), kv.begin(), [](vtkm::Float32 value) { return 4.0f * value + 5.0f; });
|
||||
|
||||
auto array_v = vtkm::cont::make_ArrayHandle(v);
|
||||
auto array_kv = vtkm::cont::make_ArrayHandle(kv);
|
||||
auto array_v = vtkm::cont::make_ArrayHandle(v, vtkm::CopyFlag::Off);
|
||||
auto array_kv = vtkm::cont::make_ArrayHandle(kv, vtkm::CopyFlag::Off);
|
||||
auto result_v = vtkm::worklet::DescriptiveStatistics::Run(array_v);
|
||||
auto result_kv = vtkm::worklet::DescriptiveStatistics::Run(array_kv);
|
||||
auto mean_v = result_v.Mean();
|
||||
@ -202,7 +201,7 @@ void TestVarianceProperty()
|
||||
std::vector<vtkm::Float32> px = v;
|
||||
std::shuffle(px.begin(), px.end(), gen);
|
||||
|
||||
auto px_array = vtkm::cont::make_ArrayHandle(px);
|
||||
auto px_array = vtkm::cont::make_ArrayHandle(px, vtkm::CopyFlag::Off);
|
||||
auto var_px = vtkm::worklet::DescriptiveStatistics::Run(px_array).SampleVariance();
|
||||
|
||||
vtkm::Float32 condition_number_v = 0;
|
||||
@ -219,11 +218,8 @@ void TestVarianceProperty()
|
||||
|
||||
void TestMomentsByKey()
|
||||
{
|
||||
std::vector<vtkm::UInt32> keys{ 0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4 };
|
||||
|
||||
auto values_array =
|
||||
vtkm::cont::make_ArrayHandleConstant(1.0f, static_cast<vtkm::Id>(keys.size()));
|
||||
auto keys_array = vtkm::cont::make_ArrayHandle(keys);
|
||||
auto keys_array = vtkm::cont::make_ArrayHandle<vtkm::UInt32>({ 0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4 });
|
||||
auto values_array = vtkm::cont::make_ArrayHandleConstant(1.0f, keys_array.GetNumberOfValues());
|
||||
|
||||
auto results = vtkm::worklet::DescriptiveStatistics::Run(keys_array, values_array);
|
||||
VTKM_TEST_ASSERT(results.GetNumberOfValues() == 5);
|
||||
|
@ -70,8 +70,8 @@ void TestDotProduct()
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> inputArray1, inputArray2;
|
||||
vtkm::cont::ArrayHandle<T> outputArray;
|
||||
inputArray1 = vtkm::cont::make_ArrayHandle(inputVecs1);
|
||||
inputArray2 = vtkm::cont::make_ArrayHandle(inputVecs2);
|
||||
inputArray1 = vtkm::cont::make_ArrayHandle(inputVecs1, vtkm::CopyFlag::Off);
|
||||
inputArray2 = vtkm::cont::make_ArrayHandle(inputVecs2, vtkm::CopyFlag::Off);
|
||||
|
||||
vtkm::worklet::DotProduct dotProductWorklet;
|
||||
vtkm::worklet::DispatcherMapField<vtkm::worklet::DotProduct> dispatcherDotProduct(
|
||||
|
@ -32,9 +32,8 @@ public:
|
||||
dataset.GetCellSet().CopyTo(cellSet);
|
||||
|
||||
// Cells to extract
|
||||
const int nCells = 2;
|
||||
vtkm::Id cellids[nCells] = { 1, 2 };
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> cellIds = vtkm::cont::make_ArrayHandle(cellids, nCells);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> cellIds = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 2 });
|
||||
const vtkm::Id nCells = cellIds.GetNumberOfValues();
|
||||
|
||||
// Output data set with cell set containing extracted cells and all points
|
||||
vtkm::worklet::ExtractGeometry extractGeometry;
|
||||
@ -107,9 +106,9 @@ public:
|
||||
dataset.GetCellSet().CopyTo(cellSet);
|
||||
|
||||
// Cells to extract
|
||||
const int nCells = 5;
|
||||
vtkm::Id cellids[nCells] = { 0, 4, 5, 10, 15 };
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> cellIds = vtkm::cont::make_ArrayHandle(cellids, nCells);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> cellIds =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 4, 5, 10, 15 });
|
||||
const vtkm::Id nCells = cellIds.GetNumberOfValues();
|
||||
|
||||
// Output data set permutation of with only extracted cells
|
||||
vtkm::worklet::ExtractGeometry extractGeometry;
|
||||
@ -140,9 +139,9 @@ public:
|
||||
dataset.GetCellSet().CopyTo(cellSet);
|
||||
|
||||
// Cells to extract
|
||||
const int nCells = 5;
|
||||
vtkm::Id cellids[nCells] = { 0, 4, 5, 10, 15 };
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> cellIds = vtkm::cont::make_ArrayHandle(cellids, nCells);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> cellIds =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 4, 5, 10, 15 });
|
||||
const vtkm::Id nCells = cellIds.GetNumberOfValues();
|
||||
|
||||
// Output data set with cell set containing extracted cells and all points
|
||||
vtkm::worklet::ExtractGeometry extractGeometry;
|
||||
|
@ -28,9 +28,8 @@ public:
|
||||
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
|
||||
|
||||
// Points to extract
|
||||
const int nPoints = 13;
|
||||
vtkm::Id pointids[nPoints] = { 0, 1, 2, 3, 4, 5, 10, 15, 20, 25, 50, 75, 100 };
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> pointIds = vtkm::cont::make_ArrayHandle(pointids, nPoints);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> pointIds =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 2, 3, 4, 5, 10, 15, 20, 25, 50, 75, 100 });
|
||||
|
||||
// Output dataset contains input coordinate system and point data
|
||||
vtkm::cont::DataSet outDataSet;
|
||||
@ -41,7 +40,7 @@ public:
|
||||
OutCellSetType outCellSet = extractPoints.Run(dataset.GetCellSet(), pointIds);
|
||||
outDataSet.SetCellSet(outCellSet);
|
||||
|
||||
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), nPoints),
|
||||
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), pointIds.GetNumberOfValues()),
|
||||
"Wrong result for ExtractPoints");
|
||||
}
|
||||
|
||||
@ -210,9 +209,8 @@ public:
|
||||
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet5();
|
||||
|
||||
// Points to extract
|
||||
const int nPoints = 6;
|
||||
vtkm::Id pointids[nPoints] = { 0, 4, 5, 7, 9, 10 };
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> pointIds = vtkm::cont::make_ArrayHandle(pointids, nPoints);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> pointIds =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 4, 5, 7, 9, 10 });
|
||||
|
||||
// Output dataset contains input coordinate system and point data
|
||||
vtkm::cont::DataSet outDataSet;
|
||||
@ -223,7 +221,7 @@ public:
|
||||
OutCellSetType outCellSet = extractPoints.Run(dataset.GetCellSet(), pointIds);
|
||||
outDataSet.SetCellSet(outCellSet);
|
||||
|
||||
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), nPoints),
|
||||
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), pointIds.GetNumberOfValues()),
|
||||
"Wrong result for ExtractPoints");
|
||||
}
|
||||
|
||||
|
@ -17,13 +17,12 @@ class TestGraphConnectivity
|
||||
public:
|
||||
void operator()() const
|
||||
{
|
||||
std::vector<vtkm::Id> counts{ 1, 1, 2, 2, 2 };
|
||||
std::vector<vtkm::Id> offsets{ 0, 1, 2, 4, 6 };
|
||||
std::vector<vtkm::Id> conn{ 2, 4, 0, 3, 2, 4, 1, 3 };
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> counts_h = vtkm::cont::make_ArrayHandle(counts);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> offsets_h = vtkm::cont::make_ArrayHandle(offsets);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> conn_h = vtkm::cont::make_ArrayHandle(conn);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> counts_h =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 2, 2, 2 });
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> offsets_h =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 2, 4, 6 });
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> conn_h =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 2, 4, 0, 3, 2, 4, 1, 3 });
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> comps;
|
||||
|
||||
vtkm::worklet::connectivity::GraphConnectivity().Run(counts_h, offsets_h, conn_h, comps);
|
||||
|
@ -37,7 +37,8 @@ public:
|
||||
vtkm::cont::DataSetBuilderUniform builder;
|
||||
vtkm::cont::DataSet data = builder.Create(vtkm::Id3(8, 4, 1));
|
||||
|
||||
auto colorField = vtkm::cont::make_FieldPoint("color", vtkm::cont::make_ArrayHandle(pixels));
|
||||
auto colorField = vtkm::cont::make_FieldPoint(
|
||||
"color", vtkm::cont::make_ArrayHandle(pixels, vtkm::CopyFlag::On));
|
||||
data.AddField(colorField);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> component;
|
||||
@ -60,17 +61,16 @@ public:
|
||||
{
|
||||
// example from Figure 35.7 of Connected Component Labeling in CUDA by OndˇrejˇŚtava,
|
||||
// Bedˇrich Beneˇ
|
||||
std::vector<vtkm::UInt8> pixels{
|
||||
auto pixels = vtkm::cont::make_ArrayHandle<vtkm::UInt8>({
|
||||
0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
|
||||
1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,
|
||||
1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
|
||||
};
|
||||
});
|
||||
|
||||
vtkm::cont::DataSetBuilderUniform builder;
|
||||
vtkm::cont::DataSet data = builder.Create(vtkm::Id3(8, 8, 1));
|
||||
|
||||
auto colorField =
|
||||
vtkm::cont::make_Field("color", vtkm::cont::Field::Association::POINTS, pixels);
|
||||
auto colorField = vtkm::cont::make_FieldPoint("color", pixels);
|
||||
data.AddField(colorField);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> component;
|
||||
|
@ -40,11 +40,10 @@ public:
|
||||
{
|
||||
using Algorithm = vtkm::cont::Algorithm;
|
||||
|
||||
std::vector<vtkm::Id> A = { 8, 3, 6, 8, 9, 5, 12, 10, 14 };
|
||||
std::vector<vtkm::Id> B = { 7, 11, 9, 8, 5, 1, 0, 5 };
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> A_arr = vtkm::cont::make_ArrayHandle(A);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> B_arr = vtkm::cont::make_ArrayHandle(B);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> A_arr =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 8, 3, 6, 8, 9, 5, 12, 10, 14 });
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> B_arr =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 7, 11, 9, 8, 5, 1, 0, 5 });
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> idxA;
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> idxB;
|
||||
|
||||
|
@ -82,7 +82,7 @@ void TestKdTreeBuildNNS(vtkm::cont::DeviceAdapterId deviceId)
|
||||
}
|
||||
|
||||
///// preprare data to build 3D kd tree /////
|
||||
auto coordi_Handle = vtkm::cont::make_ArrayHandle(coordi);
|
||||
auto coordi_Handle = vtkm::cont::make_ArrayHandle(coordi, vtkm::CopyFlag::On);
|
||||
|
||||
// Run data
|
||||
vtkm::worklet::KdTree3D kdtree3d;
|
||||
@ -97,7 +97,7 @@ void TestKdTreeBuildNNS(vtkm::cont::DeviceAdapterId deviceId)
|
||||
}
|
||||
|
||||
///// preprare testing data /////
|
||||
auto qc_Handle = vtkm::cont::make_ArrayHandle(qcVec);
|
||||
auto qc_Handle = vtkm::cont::make_ArrayHandle(qcVec, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> nnId_Handle;
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32> nnDis_Handle;
|
||||
@ -109,8 +109,10 @@ void TestKdTreeBuildNNS(vtkm::cont::DeviceAdapterId deviceId)
|
||||
NearestNeighborSearchBruteForce3DWorklet nnsbf3dWorklet;
|
||||
vtkm::worklet::DispatcherMapField<NearestNeighborSearchBruteForce3DWorklet> nnsbf3DDispatcher(
|
||||
nnsbf3dWorklet);
|
||||
nnsbf3DDispatcher.Invoke(
|
||||
qc_Handle, vtkm::cont::make_ArrayHandle(coordi), bfnnId_Handle, bfnnDis_Handle);
|
||||
nnsbf3DDispatcher.Invoke(qc_Handle,
|
||||
vtkm::cont::make_ArrayHandle(coordi, vtkm::CopyFlag::On),
|
||||
bfnnId_Handle,
|
||||
bfnnDis_Handle);
|
||||
|
||||
///// verfity search result /////
|
||||
bool passTest = true;
|
||||
|
@ -57,7 +57,8 @@ void TryKeyType(KeyType)
|
||||
keyBuffer[index] = TestValue(index % NUM_UNIQUE, KeyType());
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<KeyType> keyArray = vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<KeyType> keyArray =
|
||||
vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::cont::ArrayHandle<KeyType> sortedKeys;
|
||||
vtkm::cont::ArrayCopy(keyArray, sortedKeys);
|
||||
|
@ -34,55 +34,33 @@ struct TestMaskArrays
|
||||
|
||||
TestMaskArrays MakeMaskArraysShort()
|
||||
{
|
||||
const vtkm::Id selectArraySize = 18;
|
||||
const vtkm::IdComponent selectArray[selectArraySize] = { 1, 1, 0, 0, 0, 0, 1, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 1 };
|
||||
const vtkm::Id threadRange = 4;
|
||||
const vtkm::Id threadToOutputMap[threadRange] = { 0, 1, 6, 17 };
|
||||
|
||||
TestMaskArrays arrays;
|
||||
|
||||
// Need to copy arrays so that the data does not go out of scope.
|
||||
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(selectArray, selectArraySize),
|
||||
arrays.SelectArray);
|
||||
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(threadToOutputMap, threadRange),
|
||||
arrays.ThreadToOutputMap);
|
||||
arrays.SelectArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>(
|
||||
{ 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 });
|
||||
arrays.ThreadToOutputMap = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 6, 17 });
|
||||
|
||||
return arrays;
|
||||
}
|
||||
|
||||
TestMaskArrays MakeMaskArraysLong()
|
||||
{
|
||||
const vtkm::Id selectArraySize = 16;
|
||||
const vtkm::IdComponent selectArray[selectArraySize] = {
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
|
||||
};
|
||||
const vtkm::Id threadRange = 15;
|
||||
const vtkm::Id threadToOutputMap[threadRange] = {
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15
|
||||
};
|
||||
|
||||
TestMaskArrays arrays;
|
||||
|
||||
// Need to copy arrays so that the data does not go out of scope.
|
||||
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(selectArray, selectArraySize),
|
||||
arrays.SelectArray);
|
||||
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(threadToOutputMap, threadRange),
|
||||
arrays.ThreadToOutputMap);
|
||||
arrays.SelectArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
|
||||
});
|
||||
arrays.ThreadToOutputMap =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15 });
|
||||
|
||||
return arrays;
|
||||
}
|
||||
|
||||
TestMaskArrays MakeMaskArraysZero()
|
||||
{
|
||||
const vtkm::Id selectArraySize = 6;
|
||||
const vtkm::IdComponent selectArray[selectArraySize] = { 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
TestMaskArrays arrays;
|
||||
|
||||
// Need to copy arrays so that the data does not go out of scope.
|
||||
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(selectArray, selectArraySize),
|
||||
arrays.SelectArray);
|
||||
arrays.SelectArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 0, 0, 0 });
|
||||
arrays.ThreadToOutputMap.Allocate(0);
|
||||
|
||||
return arrays;
|
||||
|
@ -245,12 +245,11 @@ void TestNDimsHistMarginalization()
|
||||
// setup for histogram marginalization
|
||||
// use a bool array to indicate the marginal variable (true -> marginal variable)
|
||||
// the length of this array has to be equal to number of input variables
|
||||
bool marginalVariableAry[3] = { true, false, true };
|
||||
vtkm::cont::ArrayHandle<bool> marginalVariable =
|
||||
vtkm::cont::make_ArrayHandle(marginalVariableAry, 3);
|
||||
vtkm::cont::make_ArrayHandle({ true, false, true });
|
||||
|
||||
std::vector<vtkm::Id> numberOfBinsVec(3, 10);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> numberOfBins = vtkm::cont::make_ArrayHandle(numberOfBinsVec);
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> numberOfBins =
|
||||
vtkm::cont::make_ArrayHandleMove(std::vector<vtkm::Id>(3, 10));
|
||||
|
||||
// calculate marginal histogram by the setup (return sparse represetnation)
|
||||
std::vector<vtkm::cont::ArrayHandle<vtkm::Id>> marginalBinIds;
|
||||
|
@ -56,7 +56,7 @@ void TestNormal()
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<T, N>> inputArray;
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<T, N>> outputArray;
|
||||
inputArray = vtkm::cont::make_ArrayHandle(inputVecs);
|
||||
inputArray = vtkm::cont::make_ArrayHandle(inputVecs, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::worklet::Normal normalWorklet;
|
||||
vtkm::worklet::DispatcherMapField<vtkm::worklet::Normal> dispatcherNormal(normalWorklet);
|
||||
@ -91,7 +91,7 @@ void TestNormalize()
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<T, N>> inputArray;
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec<T, N>> outputArray;
|
||||
inputArray = vtkm::cont::make_ArrayHandle(inputVecs);
|
||||
inputArray = vtkm::cont::make_ArrayHandle(inputVecs, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::worklet::Normalize normalizeWorklet;
|
||||
vtkm::worklet::DispatcherMapField<vtkm::worklet::Normalize> dispatcherNormalize(normalizeWorklet);
|
||||
|
@ -315,7 +315,8 @@ void ValidateEvaluator(const EvalType& eval,
|
||||
using Status = vtkm::worklet::particleadvection::GridEvaluatorStatus;
|
||||
EvalTester evalTester;
|
||||
EvalTesterDispatcher evalTesterDispatcher(evalTester);
|
||||
vtkm::cont::ArrayHandle<vtkm::Massless> pointsHandle = vtkm::cont::make_ArrayHandle(pointIns);
|
||||
vtkm::cont::ArrayHandle<vtkm::Massless> pointsHandle =
|
||||
vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off);
|
||||
vtkm::Id numPoints = pointsHandle.GetNumberOfValues();
|
||||
vtkm::cont::ArrayHandle<Status> evalStatus;
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> evalResults;
|
||||
@ -365,7 +366,7 @@ void ValidateIntegrator(const IntegratorType& integrator,
|
||||
using IntegratorTesterDispatcher = vtkm::worklet::DispatcherMapField<IntegratorTester>;
|
||||
using Status = vtkm::worklet::particleadvection::IntegratorStatus;
|
||||
IntegratorTesterDispatcher integratorTesterDispatcher;
|
||||
auto pointsHandle = vtkm::cont::make_ArrayHandle(pointIns);
|
||||
auto pointsHandle = vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off);
|
||||
vtkm::Id numPoints = pointsHandle.GetNumberOfValues();
|
||||
vtkm::cont::ArrayHandle<Status> stepStatus;
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> stepResults;
|
||||
@ -398,7 +399,7 @@ void ValidateIntegratorForBoundary(const vtkm::Bounds& bounds,
|
||||
using Status = vtkm::worklet::particleadvection::IntegratorStatus;
|
||||
|
||||
IntegratorTesterDispatcher integratorTesterDispatcher;
|
||||
auto pointsHandle = vtkm::cont::make_ArrayHandle(pointIns);
|
||||
auto pointsHandle = vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off);
|
||||
vtkm::Id numPoints = pointsHandle.GetNumberOfValues();
|
||||
vtkm::cont::ArrayHandle<Status> stepStatus;
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> stepResults;
|
||||
@ -568,7 +569,7 @@ void TestIntegrators()
|
||||
std::vector<vtkm::Vec3f> fieldData;
|
||||
for (vtkm::Id i = 0; i < nElements; i++)
|
||||
fieldData.push_back(vtkm::Vec3f(0., 0., 1.));
|
||||
FieldHandle fieldValues = vtkm::cont::make_ArrayHandle(fieldData);
|
||||
FieldHandle fieldValues = vtkm::cont::make_ArrayHandle(fieldData, vtkm::CopyFlag::Off);
|
||||
FieldType velocities(fieldValues);
|
||||
|
||||
GridEvalType eval(dataset.GetCoordinateSystem(), dataset.GetCellSet(), velocities);
|
||||
@ -616,7 +617,7 @@ void TestParticleWorkletsWithDataSetTypes()
|
||||
field.push_back(vtkm::Normal(vec));
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldArray;
|
||||
fieldArray = vtkm::cont::make_ArrayHandle(field);
|
||||
fieldArray = vtkm::cont::make_ArrayHandle(field, vtkm::CopyFlag::Off);
|
||||
FieldType velocities(fieldArray);
|
||||
|
||||
std::vector<vtkm::Bounds> bounds;
|
||||
@ -713,7 +714,7 @@ void TestParticleStatus()
|
||||
vtkm::FloatDefault stepSize = 0.01f;
|
||||
|
||||
FieldHandle fieldArray;
|
||||
fieldArray = vtkm::cont::make_ArrayHandle(field);
|
||||
fieldArray = vtkm::cont::make_ArrayHandle(field, vtkm::CopyFlag::Off);
|
||||
FieldType velocities(fieldArray);
|
||||
|
||||
GridEvalType eval(ds.GetCoordinateSystem(), ds.GetCellSet(), velocities);
|
||||
@ -749,8 +750,8 @@ void TestWorkletsBasic()
|
||||
for (vtkm::Id i = 0; i < nElements; i++)
|
||||
field.push_back(vtkm::Normal(vecDir));
|
||||
|
||||
FieldHandle fieldArray;
|
||||
fieldArray = vtkm::cont::make_ArrayHandle(field);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldArray;
|
||||
fieldArray = vtkm::cont::make_ArrayHandle(field, vtkm::CopyFlag::Off);
|
||||
FieldType velocities(fieldArray);
|
||||
|
||||
vtkm::Bounds bounds(0, 1, 0, 1, 0, 1);
|
||||
@ -940,7 +941,7 @@ void TestParticleAdvectionFile(const std::string& fname,
|
||||
std::vector<vtkm::Massless> seeds;
|
||||
for (size_t j = 0; j < pts.size(); j++)
|
||||
seeds.push_back(vtkm::Massless(pts[j], static_cast<vtkm::Id>(j)));
|
||||
auto seedArray = vtkm::cont::make_ArrayHandle(seeds);
|
||||
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off);
|
||||
|
||||
if (i == 0)
|
||||
{
|
||||
|
@ -90,7 +90,8 @@ void TestPointGradientUniform3DWithVectorField()
|
||||
{
|
||||
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
|
||||
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::worklet::PointGradient gradient;
|
||||
auto result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), input);
|
||||
@ -134,7 +135,8 @@ void TestPointGradientUniform3DWithVectorField2()
|
||||
{
|
||||
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
|
||||
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::worklet::GradientOutputFields<vtkm::Vec3f_64> extraOutput;
|
||||
extraOutput.SetComputeGradient(false);
|
||||
|
@ -145,16 +145,13 @@ struct DoTestWorklet<TestWorkletMapTopoSelect>
|
||||
template <typename T>
|
||||
VTKM_CONT void operator()(T) const
|
||||
{
|
||||
// 18 are the number of vertices at the DataSet created by Make3DUniformDataSet0
|
||||
const vtkm::Id selectArraySize = 18;
|
||||
const vtkm::IdComponent selectArray[selectArraySize] = { 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
auto selectArrayHandle = vtkm::cont::make_ArrayHandle(selectArray, selectArraySize);
|
||||
|
||||
vtkm::cont::testing::MakeTestDataSet testDataSet;
|
||||
vtkm::cont::DataSet dataSet3D = testDataSet.Make3DUniformDataSet0();
|
||||
|
||||
// Start select array with an array of zeros
|
||||
auto selectArrayHandle = vtkm::cont::make_ArrayHandleMove(
|
||||
std::vector<vtkm::IdComponent>(static_cast<std::size_t>(dataSet3D.GetNumberOfPoints()), 0));
|
||||
|
||||
vtkm::cont::CellSetStructured<3> cellSet =
|
||||
dataSet3D.GetCellSet().Cast<vtkm::cont::CellSetStructured<3>>();
|
||||
|
||||
|
@ -33,65 +33,35 @@ struct TestScatterArrays
|
||||
|
||||
TestScatterArrays MakeScatterArraysShort()
|
||||
{
|
||||
const vtkm::Id countArraySize = 18;
|
||||
const vtkm::IdComponent countArray[countArraySize] = { 1, 2, 0, 0, 1, 0, 1, 0, 0,
|
||||
0, 0, 0, 0, 0, 1, 0, 0, 0 };
|
||||
const vtkm::Id inputToOutputMap[countArraySize] = { 0, 1, 3, 3, 3, 4, 4, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 6, 6, 6 };
|
||||
const vtkm::Id outputSize = 6;
|
||||
const vtkm::Id outputToInputMap[outputSize] = { 0, 1, 1, 4, 6, 14 };
|
||||
const vtkm::IdComponent visitArray[outputSize] = { 0, 0, 1, 0, 0, 0 };
|
||||
|
||||
TestScatterArrays arrays;
|
||||
using Algorithm = vtkm::cont::Algorithm;
|
||||
|
||||
// Need to copy arrays so that the data does not go out of scope.
|
||||
Algorithm::Copy(vtkm::cont::make_ArrayHandle(countArray, countArraySize), arrays.CountArray);
|
||||
Algorithm::Copy(vtkm::cont::make_ArrayHandle(inputToOutputMap, countArraySize),
|
||||
arrays.InputToOutputMap);
|
||||
Algorithm::Copy(vtkm::cont::make_ArrayHandle(outputToInputMap, outputSize),
|
||||
arrays.OutputToInputMap);
|
||||
Algorithm::Copy(vtkm::cont::make_ArrayHandle(visitArray, outputSize), arrays.VisitArray);
|
||||
arrays.CountArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>(
|
||||
{ 1, 2, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 });
|
||||
arrays.InputToOutputMap = vtkm::cont::make_ArrayHandle<vtkm::Id>(
|
||||
{ 0, 1, 3, 3, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6 });
|
||||
arrays.OutputToInputMap = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 1, 4, 6, 14 });
|
||||
arrays.VisitArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 1, 0, 0, 0 });
|
||||
|
||||
return arrays;
|
||||
}
|
||||
|
||||
TestScatterArrays MakeScatterArraysLong()
|
||||
{
|
||||
const vtkm::Id countArraySize = 6;
|
||||
const vtkm::IdComponent countArray[countArraySize] = { 0, 1, 2, 3, 4, 5 };
|
||||
const vtkm::Id inputToOutputMap[countArraySize] = { 0, 0, 1, 3, 6, 10 };
|
||||
const vtkm::Id outputSize = 15;
|
||||
const vtkm::Id outputToInputMap[outputSize] = { 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5 };
|
||||
const vtkm::IdComponent visitArray[outputSize] = { 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4 };
|
||||
|
||||
TestScatterArrays arrays;
|
||||
using Algorithm = vtkm::cont::Algorithm;
|
||||
|
||||
// Need to copy arrays so that the data does not go out of scope.
|
||||
Algorithm::Copy(vtkm::cont::make_ArrayHandle(countArray, countArraySize), arrays.CountArray);
|
||||
Algorithm::Copy(vtkm::cont::make_ArrayHandle(inputToOutputMap, countArraySize),
|
||||
arrays.InputToOutputMap);
|
||||
Algorithm::Copy(vtkm::cont::make_ArrayHandle(outputToInputMap, outputSize),
|
||||
arrays.OutputToInputMap);
|
||||
Algorithm::Copy(vtkm::cont::make_ArrayHandle(visitArray, outputSize), arrays.VisitArray);
|
||||
arrays.CountArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 1, 2, 3, 4, 5 });
|
||||
arrays.InputToOutputMap = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 0, 1, 3, 6, 10 });
|
||||
arrays.OutputToInputMap =
|
||||
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5 });
|
||||
arrays.VisitArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>(
|
||||
{ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4 });
|
||||
|
||||
return arrays;
|
||||
}
|
||||
|
||||
TestScatterArrays MakeScatterArraysZero()
|
||||
{
|
||||
const vtkm::Id countArraySize = 6;
|
||||
const vtkm::IdComponent countArray[countArraySize] = { 0, 0, 0, 0, 0, 0 };
|
||||
const vtkm::Id inputToOutputMap[countArraySize] = { 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
TestScatterArrays arrays;
|
||||
using Algorithm = vtkm::cont::Algorithm;
|
||||
|
||||
// Need to copy arrays so that the data does not go out of scope.
|
||||
Algorithm::Copy(vtkm::cont::make_ArrayHandle(countArray, countArraySize), arrays.CountArray);
|
||||
Algorithm::Copy(vtkm::cont::make_ArrayHandle(inputToOutputMap, countArraySize),
|
||||
arrays.InputToOutputMap);
|
||||
arrays.CountArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 0, 0, 0 });
|
||||
arrays.InputToOutputMap = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 0, 0, 0, 0, 0 });
|
||||
arrays.OutputToInputMap.Allocate(0);
|
||||
arrays.VisitArray.Allocate(0);
|
||||
|
||||
|
@ -124,7 +124,7 @@ void TestStreamLineUniformGrid()
|
||||
field.push_back(Normalize(vecData));
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f_32> fieldArray;
|
||||
fieldArray = vtkm::cont::make_ArrayHandle(&field[0], nElements);
|
||||
fieldArray = vtkm::cont::make_ArrayHandle(&field[0], nElements, vtkm::CopyFlag::On);
|
||||
|
||||
// Construct the input dataset (uniform) to hold the input and set vector data
|
||||
vtkm::cont::DataSet inDataSet;
|
||||
|
@ -319,7 +319,8 @@ void TestDecomposeReconstruct1D(vtkm::Float64 cratio)
|
||||
{
|
||||
tmpVector.push_back(100.0 * vtkm::Sin(static_cast<vtkm::Float64>(i) / 100.0));
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64> inputArray = vtkm::cont::make_ArrayHandle(tmpVector);
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64> inputArray =
|
||||
vtkm::cont::make_ArrayHandle(tmpVector, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64> outputArray;
|
||||
|
||||
|
@ -200,10 +200,11 @@ void TryExplicitGrid()
|
||||
vtkm::Id expectedCellIndexSum[] = { 28, 22, 29, 41 };
|
||||
|
||||
vtkm::Id numCells = cellSet.GetNumberOfCells();
|
||||
TryCellConnectivity(cellSet,
|
||||
vtkm::cont::make_ArrayHandle(expectedCellShapes, numCells),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellNumIndices, numCells),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells));
|
||||
TryCellConnectivity(
|
||||
cellSet,
|
||||
vtkm::cont::make_ArrayHandle(expectedCellShapes, numCells, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellNumIndices, numCells, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells, vtkm::CopyFlag::Off));
|
||||
|
||||
vtkm::IdComponent expectedPointNumIndices[] = { 1, 2, 2, 1, 2, 4, 4, 2, 2, 1, 2 };
|
||||
|
||||
@ -213,8 +214,8 @@ void TryExplicitGrid()
|
||||
TryPointConnectivity(
|
||||
cellSet,
|
||||
vtkm::cont::make_ArrayHandleConstant(vtkm::CellShapeTagVertex::Id, numPoints),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints));
|
||||
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints, vtkm::CopyFlag::Off));
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
@ -228,7 +229,8 @@ void TryCellSetPermutation()
|
||||
vtkm::Id permutationArray[] = { 2, 0, 1 };
|
||||
|
||||
vtkm::cont::CellSetPermutation<vtkm::cont::CellSetExplicit<>, vtkm::cont::ArrayHandle<vtkm::Id>>
|
||||
cellSet(vtkm::cont::make_ArrayHandle(permutationArray, 3), originalCellSet);
|
||||
cellSet(vtkm::cont::make_ArrayHandle(permutationArray, 3, vtkm::CopyFlag::Off),
|
||||
originalCellSet);
|
||||
|
||||
vtkm::UInt8 expectedCellShapes[] = { vtkm::CELL_SHAPE_TETRA,
|
||||
vtkm::CELL_SHAPE_HEXAHEDRON,
|
||||
@ -239,10 +241,11 @@ void TryCellSetPermutation()
|
||||
vtkm::Id expectedCellIndexSum[] = { 29, 28, 22 };
|
||||
|
||||
vtkm::Id numCells = cellSet.GetNumberOfCells();
|
||||
TryCellConnectivity(cellSet,
|
||||
vtkm::cont::make_ArrayHandle(expectedCellShapes, numCells),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellNumIndices, numCells),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells));
|
||||
TryCellConnectivity(
|
||||
cellSet,
|
||||
vtkm::cont::make_ArrayHandle(expectedCellShapes, numCells, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellNumIndices, numCells, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells, vtkm::CopyFlag::Off));
|
||||
|
||||
// Permutation cell set does not support cell to point connectivity.
|
||||
}
|
||||
@ -262,7 +265,7 @@ void TryStructuredGrid3D()
|
||||
cellSet,
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_HEXAHEDRON, numCells),
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>(8, numCells),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells));
|
||||
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells, vtkm::CopyFlag::Off));
|
||||
|
||||
vtkm::IdComponent expectedPointNumIndices[18] = { 1, 2, 1, 1, 2, 1, 2, 4, 2,
|
||||
2, 4, 2, 1, 2, 1, 1, 2, 1 };
|
||||
@ -273,8 +276,8 @@ void TryStructuredGrid3D()
|
||||
TryPointConnectivity(
|
||||
cellSet,
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_VERTEX, numPoints),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints));
|
||||
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints, vtkm::CopyFlag::Off));
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
@ -288,10 +291,11 @@ void TryStructuredGrid2D()
|
||||
vtkm::Id expectedCellIndexSum[2] = { 8, 12 };
|
||||
|
||||
vtkm::Id numCells = cellSet.GetNumberOfCells();
|
||||
TryCellConnectivity(cellSet,
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_QUAD, numCells),
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>(4, numCells),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells));
|
||||
TryCellConnectivity(
|
||||
cellSet,
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_QUAD, numCells),
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>(4, numCells),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells, vtkm::CopyFlag::Off));
|
||||
|
||||
vtkm::IdComponent expectedPointNumIndices[6] = { 1, 2, 1, 1, 2, 1 };
|
||||
|
||||
@ -301,8 +305,8 @@ void TryStructuredGrid2D()
|
||||
TryPointConnectivity(
|
||||
cellSet,
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_VERTEX, numPoints),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints));
|
||||
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints, vtkm::CopyFlag::Off));
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
@ -316,10 +320,11 @@ void TryStructuredGrid1D()
|
||||
vtkm::Id expectedCellIndexSum[5] = { 1, 3, 5, 7, 9 };
|
||||
|
||||
vtkm::Id numCells = cellSet.GetNumberOfCells();
|
||||
TryCellConnectivity(cellSet,
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_LINE, numCells),
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>(2, numCells),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells));
|
||||
TryCellConnectivity(
|
||||
cellSet,
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_LINE, numCells),
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>(2, numCells),
|
||||
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells, vtkm::CopyFlag::Off));
|
||||
|
||||
vtkm::IdComponent expectedPointNumIndices[6] = { 1, 2, 2, 2, 2, 1 };
|
||||
|
||||
@ -329,8 +334,8 @@ void TryStructuredGrid1D()
|
||||
TryPointConnectivity(
|
||||
cellSet,
|
||||
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_VERTEX, numPoints),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints));
|
||||
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints, vtkm::CopyFlag::Off),
|
||||
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints, vtkm::CopyFlag::Off));
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
|
@ -67,7 +67,8 @@ struct DoStaticTestWorklet
|
||||
inputArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<T> inputHandle = vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<T> inputHandle =
|
||||
vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE, vtkm::CopyFlag::On);
|
||||
vtkm::cont::ArrayHandle<T> outputHandle, outputHandleAsPtr;
|
||||
vtkm::cont::ArrayHandle<T> inoutHandle, inoutHandleAsPtr;
|
||||
|
||||
@ -115,7 +116,8 @@ struct DoVariantTestWorklet
|
||||
inputArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<T> inputHandle = vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<T> inputHandle =
|
||||
vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE, vtkm::CopyFlag::On);
|
||||
vtkm::cont::ArrayHandle<T> outputHandle;
|
||||
vtkm::cont::ArrayHandle<T> inoutHandle;
|
||||
|
||||
|
@ -142,7 +142,8 @@ struct DoTestWorklet
|
||||
inputArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<T> inputHandle = vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<T> inputHandle =
|
||||
vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
vtkm::cont::ArrayHandle<T> outputHandleAsPtr;
|
||||
vtkm::cont::ArrayHandle<T> inoutHandleAsPtr;
|
||||
|
||||
|
@ -75,7 +75,8 @@ struct DoTestWorklet
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandleIndex counting(ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<T> inputHandle = vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<T> inputHandle =
|
||||
vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE, vtkm::CopyFlag::Off);
|
||||
vtkm::cont::ArrayHandle<T> outputHandle;
|
||||
vtkm::cont::ArrayHandle<T> outputFieldArray;
|
||||
outputHandle.Allocate(ARRAY_SIZE);
|
||||
|
@ -68,8 +68,10 @@ struct DoTestWholeArrayWorklet
|
||||
inOutArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<T> inHandle = vtkm::cont::make_ArrayHandle(inArray, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<T> inOutHandle = vtkm::cont::make_ArrayHandle(inOutArray, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<T> inHandle =
|
||||
vtkm::cont::make_ArrayHandle(inArray, ARRAY_SIZE, vtkm::CopyFlag::On);
|
||||
vtkm::cont::ArrayHandle<T> inOutHandle =
|
||||
vtkm::cont::make_ArrayHandle(inOutArray, ARRAY_SIZE, vtkm::CopyFlag::On);
|
||||
vtkm::cont::ArrayHandle<T> outHandle;
|
||||
// Output arrays must be preallocated.
|
||||
outHandle.Allocate(ARRAY_SIZE);
|
||||
|
@ -54,9 +54,7 @@ struct DoTestAtomicArrayWorklet
|
||||
VTKM_CONT void operator()(T) const
|
||||
{
|
||||
std::cout << "Set up data." << std::endl;
|
||||
T inOutValue = 0;
|
||||
|
||||
vtkm::cont::ArrayHandle<T> inOutHandle = vtkm::cont::make_ArrayHandle(&inOutValue, 1);
|
||||
vtkm::cont::ArrayHandle<T> inOutHandle = vtkm::cont::make_ArrayHandle<T>({ 0 });
|
||||
|
||||
this->CallWorklet(vtkm::cont::VariantArrayHandle(inOutHandle));
|
||||
|
||||
|
@ -122,7 +122,8 @@ void TryKeyType(KeyType)
|
||||
keyBuffer[index] = TestValue(index % NUM_UNIQUE, KeyType());
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<KeyType> keyArray = vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE);
|
||||
vtkm::cont::ArrayHandle<KeyType> keyArray =
|
||||
vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE, vtkm::CopyFlag::On);
|
||||
|
||||
vtkm::cont::ArrayHandle<KeyType> sortedKeys;
|
||||
vtkm::cont::ArrayCopy(keyArray, sortedKeys);
|
||||
|
@ -93,6 +93,10 @@ public:
|
||||
// destructor
|
||||
~WaveletFilter()
|
||||
{
|
||||
this->LowDecomType.ReleaseResources();
|
||||
this->HighDecomType.ReleaseResources();
|
||||
this->LowReconType.ReleaseResources();
|
||||
this->HighReconType.ReleaseResources();
|
||||
if (LowDecomposeFilter)
|
||||
{
|
||||
delete[] LowDecomposeFilter;
|
||||
@ -134,10 +138,14 @@ private:
|
||||
|
||||
void MakeArrayHandles()
|
||||
{
|
||||
LowDecomType = vtkm::cont::make_ArrayHandle(LowDecomposeFilter, FilterLength);
|
||||
HighDecomType = vtkm::cont::make_ArrayHandle(HighDecomposeFilter, FilterLength);
|
||||
LowReconType = vtkm::cont::make_ArrayHandle(LowReconstructFilter, FilterLength);
|
||||
HighReconType = vtkm::cont::make_ArrayHandle(HighReconstructFilter, FilterLength);
|
||||
LowDecomType =
|
||||
vtkm::cont::make_ArrayHandle(LowDecomposeFilter, FilterLength, vtkm::CopyFlag::Off);
|
||||
HighDecomType =
|
||||
vtkm::cont::make_ArrayHandle(HighDecomposeFilter, FilterLength, vtkm::CopyFlag::Off);
|
||||
LowReconType =
|
||||
vtkm::cont::make_ArrayHandle(LowReconstructFilter, FilterLength, vtkm::CopyFlag::Off);
|
||||
HighReconType =
|
||||
vtkm::cont::make_ArrayHandle(HighReconstructFilter, FilterLength, vtkm::CopyFlag::Off);
|
||||
}
|
||||
|
||||
// Flipping operation; helper function to initialize a filter.
|
||||
|
Loading…
Reference in New Issue
Block a user