Shuenhoy/vtk-m2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Deprecate VariantArrayHandle

Browse Source 
`VaraintArrayHandle` has been replaced by `UnknownArrayHandle` and
`UncertainArrayHandle`. Officially make it deprecated and point users to
the new implementations.
This commit is contained in:
Kenneth Moreland 2021-04-02 11:37:49 -06:00
parent 21b36a6429
commit 68f39b86a8
37 changed files with 180 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
benchmarking/BenchmarkFilters.cxx
View File

@ -604,7 +604,7 @@ public:
}
};
// Get the number of components in a VariantArrayHandle, ArrayHandle, or Field's
// Get the number of components in a UnknownArrayHandle, ArrayHandle, or Field's
// ValueType.
struct NumberOfComponents
{

10
benchmarking/BenchmarkTopologyAlgorithms.cxx
View File

@ -17,6 +17,7 @@
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/Invoker.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/cont/UncertainArrayHandle.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/WorkletMapTopology.h>
@ -34,7 +35,8 @@ namespace
using ValueTypes = vtkm::List<vtkm::UInt32, vtkm::Int32, vtkm::Int64, vtkm::Float32, vtkm::Float64>;
using ValueVariantHandle = vtkm::cont::VariantArrayHandleBase<ValueTypes>;
using ValueUncertainHandle =
vtkm::cont::UncertainArrayHandle<ValueTypes, vtkm::cont::StorageListBasic>;
// Hold configuration state (e.g. active device)
vtkm::cont::InitializeResult Config;
@ -232,7 +234,7 @@ template <typename ValueType>
void BenchCellToPointAvgDynamic(::benchmark::State& state)
{
BenchCellToPointAvgImpl<ValueType> impl{ state };
impl.Run(ValueVariantHandle{ impl.Input });
impl.Run(ValueUncertainHandle{ impl.Input });
};
VTKM_BENCHMARK_TEMPLATES(BenchCellToPointAvgDynamic, ValueTypes);
@ -300,7 +302,7 @@ template <typename ValueType>
void BenchPointToCellAvgDynamic(::benchmark::State& state)
{
BenchPointToCellAvgImpl<ValueType> impl{ state };
impl.Run(ValueVariantHandle{ impl.Input });
impl.Run(ValueUncertainHandle{ impl.Input });
};
VTKM_BENCHMARK_TEMPLATES(BenchPointToCellAvgDynamic, ValueTypes);
@ -371,7 +373,7 @@ template <typename ValueType>
void BenchClassificationDynamic(::benchmark::State& state)
{
BenchClassificationImpl<ValueType> impl{ state };
impl.Run(ValueVariantHandle{ impl.Input });
impl.Run(ValueUncertainHandle{ impl.Input });
};
VTKM_BENCHMARK_TEMPLATES(BenchClassificationDynamic, ValueTypes);

6
vtkm/cont/ArrayHandleCast.h
View File

@ -193,7 +193,7 @@ private:
if (RangeLoss && PrecLoss)
{
VTKM_LOG_F(vtkm::cont::LogLevel::Warn,
"VariantArrayHandle::AsVirtual: Casting ComponentType of "
"ArrayHandleCast: Casting ComponentType of "
"%s to %s reduces range and precision.",
vtkm::cont::TypeToString<SrcValueType>().c_str(),
vtkm::cont::TypeToString<DstValueType>().c_str());
@ -201,7 +201,7 @@ private:
else if (RangeLoss)
{
VTKM_LOG_F(vtkm::cont::LogLevel::Warn,
"VariantArrayHandle::AsVirtual: Casting ComponentType of "
"ArrayHandleCast: Casting ComponentType of "
"%s to %s reduces range.",
vtkm::cont::TypeToString<SrcValueType>().c_str(),
vtkm::cont::TypeToString<DstValueType>().c_str());
@ -209,7 +209,7 @@ private:
else if (PrecLoss)
{
VTKM_LOG_F(vtkm::cont::LogLevel::Warn,
"VariantArrayHandle::AsVirtual: Casting ComponentType of "
"ArrayHandleCast: Casting ComponentType of "
"%s to %s reduces precision.",
vtkm::cont::TypeToString<SrcValueType>().c_str(),
vtkm::cont::TypeToString<DstValueType>().c_str());

6
vtkm/cont/DataSet.h
View File

@ -18,7 +18,7 @@
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Field.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/UnknownArrayHandle.h>
namespace vtkm
{
@ -133,7 +133,7 @@ public:
//@}
VTKM_CONT
void AddPointField(const std::string& fieldName, const vtkm::cont::VariantArrayHandle& field)
void AddPointField(const std::string& fieldName, const vtkm::cont::UnknownArrayHandle& field)
{
this->AddField(make_FieldPoint(fieldName, field));
}
@ -161,7 +161,7 @@ public:
//Cell centered field
VTKM_CONT
void AddCellField(const std::string& fieldName, const vtkm::cont::VariantArrayHandle& field)
void AddCellField(const std::string& fieldName, const vtkm::cont::UnknownArrayHandle& field)
{
this->AddField(make_FieldCell(fieldName, field));
}

4
vtkm/cont/DataSetFieldAdd.h
View File

@ -31,7 +31,7 @@ public:
VTKM_CONT
static void AddPointField(vtkm::cont::DataSet& dataSet,
const std::string& fieldName,
const vtkm::cont::VariantArrayHandle& field)
const vtkm::cont::UnknownArrayHandle& field)
{
dataSet.AddField(make_FieldPoint(fieldName, field));
}
@ -67,7 +67,7 @@ public:
VTKM_CONT
static void AddCellField(vtkm::cont::DataSet& dataSet,
const std::string& fieldName,
const vtkm::cont::VariantArrayHandle& field)
const vtkm::cont::UnknownArrayHandle& field)
{
dataSet.AddField(make_FieldCell(fieldName, field));
}

4
vtkm/cont/ErrorBadType.h
View File

@ -35,8 +35,8 @@ VTKM_SILENCE_WEAK_VTABLE_WARNING_END
/// Throws an ErrorBadType exception with the following message:
/// Cast failed: \c baseType --> \c derivedType".
/// This is generally caused by asking for a casting of a VariantArrayHandle
/// with an insufficient type list.
/// This is generally caused by asking for a casting of a UnknownArrayHandle
/// or UncertainArrayhandle with an insufficient type list.
//
VTKM_CONT_EXPORT void throwFailedDynamicCast(const std::string& baseType,
const std::string& derivedType);

4
vtkm/cont/Field.h
View File

@ -194,7 +194,7 @@ vtkm::cont::Field make_FieldPoint(std::string name, const vtkm::cont::ArrayHandl
return vtkm::cont::Field(name, vtkm::cont::Field::Association::POINTS, data);
}
/// Convenience function to build point fields from vtkm::cont::VariantArrayHandle
/// Convenience function to build point fields from vtkm::cont::UnknownArrayHandle
inline vtkm::cont::Field make_FieldPoint(std::string name,
const vtkm::cont::UnknownArrayHandle& data)
{
@ -209,7 +209,7 @@ vtkm::cont::Field make_FieldCell(std::string name, const vtkm::cont::ArrayHandle
}
/// Convenience function to build cell fields from vtkm::cont::VariantArrayHandle
/// Convenience function to build cell fields from vtkm::cont::UnknownArrayHandle
inline vtkm::cont::Field make_FieldCell(std::string name,
const vtkm::cont::UnknownArrayHandle& data)
{

20
vtkm/cont/VariantArrayHandle.h
View File

@ -106,7 +106,10 @@ VTKM_DEPRECATED_SUPPRESS_END
///
/// See the documentation of `VariantArrayHandleBase` for more information.
///
class VTKM_ALWAYS_EXPORT VariantArrayHandleCommon : public vtkm::cont::UnknownArrayHandle
class VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(
1.7,
"VariantArrayHandle classes replaced with UnknownArrayHandle and UncertainArrayHandle.")
VariantArrayHandleCommon : public vtkm::cont::UnknownArrayHandle
{
using Superclass = vtkm::cont::UnknownArrayHandle;
@ -263,8 +266,12 @@ public:
/// named `VariantArrayHandleBase`, which is templated on the list of
/// component types.
///
VTKM_DEPRECATED_SUPPRESS_BEGIN
template <typename TypeList>
class VTKM_ALWAYS_EXPORT VariantArrayHandleBase : public VariantArrayHandleCommon
class VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(
1.7,
"VariantArrayHandle classes replaced with UnknownArrayHandle and UncertainArrayHandle.")
VariantArrayHandleBase : public VariantArrayHandleCommon
{
VTKM_STATIC_ASSERT_MSG((!std::is_same<TypeList, vtkm::ListUniversal>::value),
"Cannot use vtkm::ListUniversal with VariantArrayHandle.");
@ -319,14 +326,12 @@ public:
/// be specified in the second template parameter, which will be passed to
/// the CastAndCall.
///
VTKM_DEPRECATED_SUPPRESS_BEGIN
template <typename T, typename StorageList = VTKM_DEFAULT_STORAGE_LIST>
VTKM_CONT VTKM_DEPRECATED(1.6, "ArrayHandleVirtual is no longer suported.")
vtkm::cont::ArrayHandleVirtual<T> AsVirtual() const
{
return this->Superclass::AsVirtual<T, StorageList, TypeList>();
}
VTKM_DEPRECATED_SUPPRESS_END
#endif //VTKM_NO_DEPRECATED_VIRTUAL
/// Changes the types to try casting to when resolving this variant array,
@ -406,7 +411,10 @@ private:
}
};
using VariantArrayHandle = vtkm::cont::VariantArrayHandleBase<VTKM_DEFAULT_TYPE_LIST>;
using VariantArrayHandle VTKM_DEPRECATED(
1.7,
"VariantArrayHandle classes replaced with UnknownArrayHandle and UncertainArrayHandle.") =
vtkm::cont::VariantArrayHandleBase<VTKM_DEFAULT_TYPE_LIST>;
//=============================================================================
@ -473,5 +481,7 @@ public:
} // diy
/// @endcond SERIALIZATION
VTKM_DEPRECATED_SUPPRESS_END
#endif //vtk_m_virts_VariantArrayHandle_h

1
vtkm/cont/testing/Testing.h
View File

@ -23,7 +23,6 @@
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/UnknownArrayHandle.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/testing/vtkm_cont_testing_export.h>

1
vtkm/cont/testing/TestingSerialization.h
View File

@ -11,7 +11,6 @@
#define vtk_m_cont_testing_TestingSerialization_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/thirdparty/diy/serialization.h>

71
vtkm/cont/testing/UnitTestSerializationArrayHandle.cxx
View File

@ -30,7 +30,6 @@
#include <vtkm/cont/UncertainArrayHandle.h>
#include <vtkm/cont/UnknownArrayHandle.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/testing/TestingSerialization.h>
@ -87,18 +86,6 @@ inline void RunTest(const T& obj)
TestSerialization(obj, TestEqualArrayHandle{});
}
template <typename T>
inline void RunTest(const T& obj, std::true_type)
{
TestSerialization(obj, TestEqualArrayHandle{});
}
template <typename T>
inline void RunTest(const T&, std::false_type)
{
// Suppress running the test
}
//-----------------------------------------------------------------------------
constexpr vtkm::Id ArraySize = 10;
@ -107,14 +94,14 @@ using TestTypesListVec = vtkm::List<vtkm::Vec3f_32, vtkm::Vec3f_64>;
using TestTypesList = vtkm::ListAppend<TestTypesListScalar, TestTypesListVec>;
template <typename T, typename S>
inline vtkm::cont::VariantArrayHandleBase<vtkm::ListAppend<TestTypesList, vtkm::List<T>>>
MakeTestVariantArrayHandle(const vtkm::cont::ArrayHandle<T, S>& array)
inline vtkm::cont::UnknownArrayHandle MakeTestUnknownArrayHandle(
const vtkm::cont::ArrayHandle<T, S>& array)
{
return array;
}
template <typename T, typename S>
inline vtkm::cont::UnknownArrayHandle MakeTestUnknownArrayHandle(
inline vtkm::cont::UncertainArrayHandle<vtkm::List<T>, vtkm::List<S>> MakeTestUncertainArrayHandle(
const vtkm::cont::ArrayHandle<T, S>& array)
{
return array;
@ -128,7 +115,7 @@ struct TestArrayHandleBasic
auto array = RandomArrayHandle<T>::Make(ArraySize);
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array));
RunTest(MakeTestUncertainArrayHandle(array));
}
};
@ -141,8 +128,7 @@ struct TestArrayHandleSOA
vtkm::cont::ArrayCopy(RandomArrayHandle<T>::Make(ArraySize), array);
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST, vtkm::cont::StorageTagSOA>{});
RunTest(MakeTestUncertainArrayHandle(array));
}
};
@ -157,11 +143,7 @@ struct TestArrayHandleCartesianProduct
RandomArrayHandle<T>::Make(ArraySize));
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST,
vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic>>{});
RunTest(MakeTestUncertainArrayHandle(array));
}
};
@ -174,9 +156,7 @@ struct TestArrayHandleCast
vtkm::cont::make_ArrayHandleCast<T>(RandomArrayHandle<vtkm::Int8>::Make(ArraySize));
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST,
vtkm::cont::StorageTagCast<vtkm::Int8, vtkm::cont::StorageTagBasic>>{});
RunTest(MakeTestUncertainArrayHandle(array));
}
template <typename T, vtkm::IdComponent N>
@ -186,9 +166,7 @@ struct TestArrayHandleCast
RandomArrayHandle<vtkm::Vec<vtkm::Int8, N>>::Make(ArraySize));
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST,
vtkm::cont::StorageTagCast<vtkm::Int8, vtkm::cont::StorageTagBasic>>{});
RunTest(MakeTestUncertainArrayHandle(array));
}
};
@ -201,8 +179,7 @@ struct TestArrayHandleConstant
auto array = vtkm::cont::make_ArrayHandleConstant(cval, ArraySize);
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST, vtkm::cont::StorageTagConstant>{});
RunTest(MakeTestUncertainArrayHandle(array));
}
};
@ -216,8 +193,7 @@ struct TestArrayHandleCounting
auto array = vtkm::cont::make_ArrayHandleCounting(start, step, ArraySize);
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST, vtkm::cont::StorageTagCounting>{});
RunTest(MakeTestUncertainArrayHandle(array));
}
};
@ -235,9 +211,7 @@ struct TestArrayHandleGroupVec
auto array = vtkm::cont::make_ArrayHandleGroupVec<3>(flat);
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST,
vtkm::cont::StorageTagGroupVec<vtkm::cont::StorageTagBasic, 3>>{});
RunTest(MakeTestUncertainArrayHandle(array));
break;
}
case 4:
@ -245,9 +219,7 @@ struct TestArrayHandleGroupVec
auto array = vtkm::cont::make_ArrayHandleGroupVec<4>(flat);
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST,
vtkm::cont::StorageTagGroupVec<vtkm::cont::StorageTagBasic, 4>>{});
RunTest(MakeTestUncertainArrayHandle(array));
break;
}
default:
@ -255,9 +227,7 @@ struct TestArrayHandleGroupVec
auto array = vtkm::cont::make_ArrayHandleGroupVec<2>(flat);
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST,
vtkm::cont::StorageTagGroupVec<vtkm::cont::StorageTagBasic, 2>>{});
RunTest(MakeTestUncertainArrayHandle(array));
break;
}
}
@ -295,8 +265,7 @@ void TestArrayHandleIndex()
auto array = vtkm::cont::ArrayHandleIndex(size);
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST, vtkm::cont::StorageTagIndex>{});
RunTest(MakeTestUncertainArrayHandle(array));
}
struct TestArrayHandlePermutation
@ -314,10 +283,7 @@ struct TestArrayHandlePermutation
RandomArrayHandle<T>::Make(ArraySize));
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST,
vtkm::cont::StorageTagPermutation<vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic>>{});
RunTest(MakeTestUncertainArrayHandle(array));
}
};
@ -329,9 +295,7 @@ struct TestArrayHandleReverse
auto array = vtkm::cont::make_ArrayHandleReverse(RandomArrayHandle<T>::Make(ArraySize));
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST,
vtkm::cont::StorageTagReverse<vtkm::cont::StorageTagBasic>>{});
RunTest(MakeTestUncertainArrayHandle(array));
}
};
@ -365,8 +329,7 @@ void TestArrayHandleUniformPointCoordinates()
auto array = MakeRandomArrayHandleUniformPointCoordinates();
RunTest(array);
RunTest(MakeTestUnknownArrayHandle(array));
RunTest(MakeTestVariantArrayHandle(array),
vtkm::ListHas<VTKM_DEFAULT_STORAGE_LIST, vtkm::cont::StorageTagUniformPoints>{});
RunTest(MakeTestUncertainArrayHandle(array));
}

12
vtkm/cont/testing/UnitTestVariantArrayHandle.cxx
View File

@ -8,6 +8,12 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/Deprecated.h>
// This is testing a deprecated functionality. Remove this test once VariantArrayHandle
// is completely removed from VTK-m.
VTKM_DEPRECATED_SUPPRESS_BEGIN
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/TypeTraits.h>
@ -120,7 +126,6 @@ struct CheckFunctor
}
#ifndef VTKM_NO_DEPRECATED_VIRTUAL
VTKM_DEPRECATED_SUPPRESS_BEGIN
template <typename T>
void operator()(const vtkm::cont::ArrayHandleVirtual<T>& array,
bool& vtkmNotUsed(calledBasic),
@ -131,7 +136,6 @@ struct CheckFunctor
CheckArray(array);
}
VTKM_DEPRECATED_SUPPRESS_END
#endif //VTKM_NO_DEPRECATED_VIRTUAL
template <typename T, typename S>
@ -273,7 +277,6 @@ void CheckCastToVirtualArrayHandle(const ArrayType& array)
VariantArrayType arrayVariant = array;
VTKM_DEPRECATED_SUPPRESS_BEGIN
{
auto testArray = arrayVariant.template AsVirtual<ValueType, StorageList>();
VTKM_TEST_ASSERT(testArray.GetNumberOfValues() == array.GetNumberOfValues(),
@ -329,7 +332,6 @@ void CheckCastToVirtualArrayHandle(const ArrayType& array)
VTKM_TEST_ASSERT(threw,
"Casting to different vector width did not throw expected "
"ErrorBadType exception.");
VTKM_DEPRECATED_SUPPRESS_END
}
#endif //VTKM_NO_DEPRECATED_VIRTUAL
@ -544,3 +546,5 @@ int UnitTestVariantArrayHandle(int argc, char* argv[])
{
return vtkm::cont::testing::Testing::Run(TestVariantArrayHandle, argc, argv);
}
VTKM_DEPRECATED_SUPPRESS_END

12
vtkm/filter/CreateResult.h
View File

@ -59,10 +59,10 @@ inline VTKM_CONT vtkm::cont::DataSet CreateResult(
return clone;
}
/// Use this function if you have a VariantArrayHandle that holds the data
/// Use this function if you have a UnknownArrayHandle that holds the data
/// for the field.
inline VTKM_CONT vtkm::cont::DataSet CreateResult(const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::VariantArrayHandle& fieldArray,
const vtkm::cont::UnknownArrayHandle& fieldArray,
const std::string& fieldName,
const vtkm::filter::FieldMetadata& metaData)
{
@ -96,11 +96,11 @@ inline VTKM_CONT vtkm::cont::DataSet CreateResultFieldCell(
return clone;
}
/// Use this function if you want to explicit construct a Cell field and have a VariantArrayHandle
/// Use this function if you want to explicit construct a Cell field and have a UnknownArrayHandle
/// that holds the data for the field.
inline VTKM_CONT vtkm::cont::DataSet CreateResultFieldCell(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::VariantArrayHandle& fieldArray,
const vtkm::cont::UnknownArrayHandle& fieldArray,
const std::string& fieldName)
{
VTKM_ASSERT(!fieldName.empty());
@ -133,11 +133,11 @@ inline VTKM_CONT vtkm::cont::DataSet CreateResultFieldPoint(
return clone;
}
/// Use this function if you want to explicit construct a Point field and have a VariantArrayHandle
/// Use this function if you want to explicit construct a Point field and have a UnknownArrayHandle
/// that holds the data for the field.
inline VTKM_CONT vtkm::cont::DataSet CreateResultFieldPoint(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::VariantArrayHandle& fieldArray,
const vtkm::cont::UnknownArrayHandle& fieldArray,
const std::string& fieldName)
{
VTKM_ASSERT(!fieldName.empty());

4
vtkm/filter/FieldMetadata.h
View File

@ -67,7 +67,7 @@ public:
/// but with a new name
VTKM_CONT
vtkm::cont::Field AsField(const std::string& name,
const vtkm::cont::VariantArrayHandle& handle) const
const vtkm::cont::UnknownArrayHandle& handle) const
{
return vtkm::cont::Field(name, this->Association, handle);
}
@ -79,7 +79,7 @@ public:
return this->AsField(this->Name, handle);
}
/// Construct a new field with the same association and name as stored in this FieldMetaData
VTKM_CONT vtkm::cont::Field AsField(const vtkm::cont::VariantArrayHandle& handle) const
VTKM_CONT vtkm::cont::Field AsField(const vtkm::cont::UnknownArrayHandle& handle) const
{
return this->AsField(this->Name, handle);
}

24
vtkm/filter/PolicyBase.h
View File

@ -260,9 +260,13 @@ ApplyPolicyFieldOfType(const vtkm::cont::Field& field,
/// the active field of this filter.
///
template <typename DerivedPolicy, typename FilterType>
VTKM_CONT vtkm::cont::VariantArrayHandleBase<typename vtkm::filter::DeduceFilterFieldTypes<
DerivedPolicy,
typename vtkm::filter::FilterTraits<FilterType>::InputFieldTypeList>::TypeList>
VTKM_CONT vtkm::cont::UncertainArrayHandle<
typename vtkm::filter::DeduceFilterFieldTypes<
DerivedPolicy,
typename vtkm::filter::FilterTraits<FilterType>::InputFieldTypeList>::TypeList,
typename vtkm::filter::DeduceFilterFieldStorage<
DerivedPolicy,
typename vtkm::filter::FilterTraits<FilterType>::AdditionalFieldStorage>::StorageList>
ApplyPolicyFieldActive(const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy>,
vtkm::filter::FilterTraits<FilterType>)
@ -276,20 +280,6 @@ ApplyPolicyFieldActive(const vtkm::cont::Field& field,
return field.GetData().ResetTypes(TypeList{}, StorageList{});
}
////-----------------------------------------------------------------------------
///// \brief Get an array from a `Field` limited to a given set of types.
/////
//template <typename DerivedPolicy, typename ListOfTypes>
//VTKM_CONT vtkm::cont::VariantArrayHandleBase<
// typename vtkm::filter::DeduceFilterFieldTypes<DerivedPolicy, ListOfTypes>::TypeList>
//ApplyPolicyFieldOfTypes(
// const vtkm::cont::Field& field, vtkm::filter::PolicyBase<DerivedPolicy>, ListOfTypes)
//{
// using TypeList =
// typename vtkm::filter::DeduceFilterFieldTypes<DerivedPolicy, ListOfTypes>::TypeList;
// return field.GetData().ResetTypes(TypeList());
//}
//-----------------------------------------------------------------------------
/// \brief Ge a cell set from a `DynamicCellSet` object.
///

8
vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx
View File

@ -62,9 +62,9 @@ void TestClipStructured()
VTKM_TEST_ASSERT(outputData.GetNumberOfCells() == 8,
"Wrong number of cells in the output dataset");
vtkm::cont::VariantArrayHandle temp = outputData.GetField("scalars").GetData();
vtkm::cont::UnknownArrayHandle temp = outputData.GetField("scalars").GetData();
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
temp.CopyTo(resultArrayHandle);
temp.AsArrayHandle(resultArrayHandle);
VTKM_TEST_ASSERT(resultArrayHandle.GetNumberOfValues() == 13,
"Wrong number of points in the output dataset");
@ -98,9 +98,9 @@ void TestClipStructuredInverted()
VTKM_TEST_ASSERT(outputData.GetNumberOfCells() == 4,
"Wrong number of cells in the output dataset");
vtkm::cont::VariantArrayHandle temp = outputData.GetField("scalars").GetData();
vtkm::cont::UnknownArrayHandle temp = outputData.GetField("scalars").GetData();
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
temp.CopyTo(resultArrayHandle);
temp.AsArrayHandle(resultArrayHandle);
VTKM_TEST_ASSERT(resultArrayHandle.GetNumberOfValues() == 13,
"Wrong number of points in the output dataset");

42
vtkm/io/VTKDataSetReaderBase.cxx
View File

@ -14,7 +14,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/Logging.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/UnknownArrayHandle.h>
#include <algorithm>
#include <string>
@ -33,9 +33,9 @@ inline void PrintVTKDataFileSummary(const vtkm::io::internal::VTKDataSetFile& df
<< std::endl;
}
// Since Fields and DataSets store data in the default VariantArrayHandle, convert
// Since Fields and DataSets store data in the default UnknownArrayHandle, convert
// the data to the closest type supported by default. The following will
// need to be updated if VariantArrayHandle or TypeListCommon changes.
// need to be updated if UnknownArrayHandle or TypeListCommon changes.
template <typename T>
struct ClosestCommonType
{
@ -119,7 +119,7 @@ struct ClosestFloat<vtkm::UInt64>
};
template <typename T>
vtkm::cont::VariantArrayHandle CreateVariantArrayHandle(const std::vector<T>& vec)
vtkm::cont::UnknownArrayHandle CreateUnknownArrayHandle(const std::vector<T>& vec)
{
switch (vtkm::VecTraits<T>::NUM_COMPONENTS)
{
@ -143,7 +143,7 @@ vtkm::cont::VariantArrayHandle CreateVariantArrayHandle(const std::vector<T>& ve
portal.Set(i, static_cast<CommonType>(vec[static_cast<std::size_t>(i)]));
}
return vtkm::cont::VariantArrayHandle(output);
return vtkm::cont::UnknownArrayHandle(output);
}
case 2:
case 3:
@ -179,12 +179,12 @@ vtkm::cont::VariantArrayHandle CreateVariantArrayHandle(const std::vector<T>& ve
portal.Set(i, outval);
}
return vtkm::cont::VariantArrayHandle(output);
return vtkm::cont::UnknownArrayHandle(output);
}
default:
{
VTKM_LOG_S(vtkm::cont::LogLevel::Warn, "Only 1, 2, 3, or 9 components supported. Skipping.");
return vtkm::cont::VariantArrayHandle(vtkm::cont::ArrayHandle<vtkm::Float32>());
return vtkm::cont::UnknownArrayHandle(vtkm::cont::ArrayHandle<vtkm::Float32>());
}
}
}
@ -249,7 +249,7 @@ void VTKDataSetReaderBase::ReadPoints()
std::size_t numPoints;
this->DataFile->Stream >> numPoints >> dataType >> std::ws;
vtkm::cont::VariantArrayHandle points =
vtkm::cont::UnknownArrayHandle points =
this->DoReadArrayVariant(vtkm::cont::Field::Association::POINTS, dataType, numPoints, 3);
this->DataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", points));
@ -446,7 +446,7 @@ void VTKDataSetReaderBase::ReadHeader()
void VTKDataSetReaderBase::AddField(const std::string& name,
vtkm::cont::Field::Association association,
vtkm::cont::VariantArrayHandle& data)
vtkm::cont::UnknownArrayHandle& data)
{
if (data.GetNumberOfValues() > 0)
{
@ -491,7 +491,7 @@ void VTKDataSetReaderBase::ReadScalars(vtkm::cont::Field::Association associatio
internal::parseAssert(tag == "LOOKUP_TABLE");
this->DataFile->Stream >> lookupTableName >> std::ws;
vtkm::cont::VariantArrayHandle data =
vtkm::cont::UnknownArrayHandle data =
this->DoReadArrayVariant(association, dataType, numElements, numComponents);
this->AddField(dataName, association, data);
}
@ -505,7 +505,7 @@ void VTKDataSetReaderBase::ReadColorScalars(vtkm::cont::Field::Association assoc
vtkm::IdComponent numComponents;
this->DataFile->Stream >> dataName >> numComponents >> std::ws;
std::string dataType = this->DataFile->IsBinary ? "unsigned_char" : "float";
vtkm::cont::VariantArrayHandle data =
vtkm::cont::UnknownArrayHandle data =
this->DoReadArrayVariant(association, dataType, numElements, numComponents);
this->AddField(dataName, association, data);
}
@ -528,7 +528,7 @@ void VTKDataSetReaderBase::ReadTextureCoordinates(vtkm::cont::Field::Association
std::string dataType;
this->DataFile->Stream >> dataName >> numComponents >> dataType >> std::ws;
vtkm::cont::VariantArrayHandle data =
vtkm::cont::UnknownArrayHandle data =
this->DoReadArrayVariant(association, dataType, numElements, numComponents);
this->AddField(dataName, association, data);
}
@ -540,7 +540,7 @@ void VTKDataSetReaderBase::ReadVectors(vtkm::cont::Field::Association associatio
std::string dataType;
this->DataFile->Stream >> dataName >> dataType >> std::ws;
vtkm::cont::VariantArrayHandle data =
vtkm::cont::UnknownArrayHandle data =
this->DoReadArrayVariant(association, dataType, numElements, 3);
this->AddField(dataName, association, data);
}
@ -552,7 +552,7 @@ void VTKDataSetReaderBase::ReadTensors(vtkm::cont::Field::Association associatio
std::string dataType;
this->DataFile->Stream >> dataName >> dataType >> std::ws;
vtkm::cont::VariantArrayHandle data =
vtkm::cont::UnknownArrayHandle data =
this->DoReadArrayVariant(association, dataType, numElements, 9);
this->AddField(dataName, association, data);
}
@ -571,7 +571,7 @@ void VTKDataSetReaderBase::ReadFields(vtkm::cont::Field::Association association
this->DataFile->Stream >> arrayName >> numComponents >> numTuples >> dataType >> std::ws;
if (numTuples == expectedNumElements)
{
vtkm::cont::VariantArrayHandle data =
vtkm::cont::UnknownArrayHandle data =
this->DoReadArrayVariant(association, dataType, numTuples, numComponents);
this->AddField(arrayName, association, data);
}
@ -643,7 +643,7 @@ public:
ReadArrayVariant(VTKDataSetReaderBase* reader,
vtkm::cont::Field::Association association,
std::size_t numElements,
vtkm::cont::VariantArrayHandle& data)
vtkm::cont::UnknownArrayHandle& data)
: SkipArrayVariant(reader, numElements)
, Association(association)
, Data(&data)
@ -658,7 +658,7 @@ public:
if ((this->Association != vtkm::cont::Field::Association::CELL_SET) ||
(this->Reader->GetCellsPermutation().GetNumberOfValues() < 1))
{
*this->Data = CreateVariantArrayHandle(buffer);
*this->Data = CreateUnknownArrayHandle(buffer);
}
else
{
@ -672,7 +672,7 @@ public:
std::size_t inIndex = static_cast<std::size_t>(permutation.Get(outIndex));
permutedBuffer[static_cast<std::size_t>(outIndex)] = buffer[inIndex];
}
*this->Data = CreateVariantArrayHandle(permutedBuffer);
*this->Data = CreateUnknownArrayHandle(permutedBuffer);
}
}
@ -686,7 +686,7 @@ public:
private:
vtkm::cont::Field::Association Association;
vtkm::cont::VariantArrayHandle* Data;
vtkm::cont::UnknownArrayHandle* Data;
};
void VTKDataSetReaderBase::DoSkipArrayVariant(std::string dataType,
@ -712,7 +712,7 @@ void VTKDataSetReaderBase::DoSkipArrayVariant(std::string dataType,
}
}
vtkm::cont::VariantArrayHandle VTKDataSetReaderBase::DoReadArrayVariant(
vtkm::cont::UnknownArrayHandle VTKDataSetReaderBase::DoReadArrayVariant(
vtkm::cont::Field::Association association,
std::string dataType,
std::size_t numElements,
@ -720,7 +720,7 @@ vtkm::cont::VariantArrayHandle VTKDataSetReaderBase::DoReadArrayVariant(
{
// Create empty data to start so that the return can check if data were actually read
vtkm::cont::ArrayHandle<vtkm::Float32> empty;
vtkm::cont::VariantArrayHandle data(empty);
vtkm::cont::UnknownArrayHandle data(empty);
vtkm::io::internal::DataType typeId = vtkm::io::internal::DataTypeId(dataType);
vtkm::io::internal::SelectTypeAndCall(

4
vtkm/io/VTKDataSetReaderBase.h
View File

@ -157,7 +157,7 @@ private:
VTKM_CONT void ReadHeader();
VTKM_CONT void AddField(const std::string& name,
vtkm::cont::Field::Association association,
vtkm::cont::VariantArrayHandle& data);
vtkm::cont::UnknownArrayHandle& data);
VTKM_CONT void ReadScalars(vtkm::cont::Field::Association association, std::size_t numElements);
VTKM_CONT void ReadColorScalars(vtkm::cont::Field::Association association,
std::size_t numElements);
@ -182,7 +182,7 @@ protected:
VTKM_CONT void DoSkipArrayVariant(std::string dataType,
std::size_t numElements,
vtkm::IdComponent numComponents);
VTKM_CONT vtkm::cont::VariantArrayHandle DoReadArrayVariant(
VTKM_CONT vtkm::cont::UnknownArrayHandle DoReadArrayVariant(
vtkm::cont::Field::Association association,
std::string dataType,
std::size_t numElements,

22
vtkm/io/VTKRectilinearGridReader.cxx
View File

@ -50,7 +50,7 @@ void VTKRectilinearGridReader::Read()
//Read the points.
std::string fileStorageDataType;
std::size_t numPoints[3];
vtkm::cont::VariantArrayHandle X, Y, Z;
vtkm::cont::UnknownArrayHandle X, Y, Z;
this->DataFile->Stream >> tag >> numPoints[0] >> fileStorageDataType >> std::ws;
if (tag != "X_COORDINATES")
@ -90,13 +90,13 @@ void VTKRectilinearGridReader::Read()
// We need to store all coordinate arrays as FloatDefault.
vtkm::cont::ArrayHandle<vtkm::FloatDefault> Xc, Yc, Zc;
// But the VariantArrayHandle has type fileStorageDataType.
// But the UnknownArrayHandle has type fileStorageDataType.
// If the fileStorageDataType is the same as the storage type, no problem:
if (fileStorageDataType == vtkm::io::internal::DataTypeName<vtkm::FloatDefault>::Name())
{
X.CopyTo(Xc);
Y.CopyTo(Yc);
Z.CopyTo(Zc);
X.AsArrayHandle(Xc);
Y.AsArrayHandle(Yc);
Z.AsArrayHandle(Zc);
}
else
{
@ -104,9 +104,9 @@ void VTKRectilinearGridReader::Read()
if (fileStorageDataType == "float")
{
vtkm::cont::ArrayHandle<vtkm::Float32> Xcf, Ycf, Zcf;
X.CopyTo(Xcf);
Y.CopyTo(Ycf);
Z.CopyTo(Zcf);
X.AsArrayHandle(Xcf);
Y.AsArrayHandle(Ycf);
Z.AsArrayHandle(Zcf);
vtkm::cont::ArrayCopy(Xcf, Xc);
vtkm::cont::ArrayCopy(Ycf, Yc);
vtkm::cont::ArrayCopy(Zcf, Zc);
@ -114,9 +114,9 @@ void VTKRectilinearGridReader::Read()
else
{
vtkm::cont::ArrayHandle<vtkm::Float64> Xcd, Ycd, Zcd;
X.CopyTo(Xcd);
Y.CopyTo(Ycd);
Z.CopyTo(Zcd);
X.AsArrayHandle(Xcd);
Y.AsArrayHandle(Ycd);
Z.AsArrayHandle(Zcd);
vtkm::cont::ArrayCopy(Xcd, Xc);
vtkm::cont::ArrayCopy(Ycd, Yc);
vtkm::cont::ArrayCopy(Zcd, Zc);

2
vtkm/worklet/Clip.h
View File

@ -27,7 +27,7 @@
#include <vtkm/cont/CoordinateSystem.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/UnknownArrayHandle.h>
#include <vtkm/ImplicitFunction.h>

2
vtkm/worklet/DispatcherMapField.h
View File

@ -50,7 +50,7 @@ public:
const InputDomainType& inputDomain = invocation.GetInputDomain();
// For a DispatcherMapField, the inputDomain must be an ArrayHandle (or
// an VariantArrayHandle that gets cast to one). The size of the domain
// an UnknownArrayHandle that gets cast to one). The size of the domain
// (number of threads/worklet instances) is equal to the size of the
// array.
auto numInstances = SchedulingRange(inputDomain);

2
vtkm/worklet/MaskIndices.h
View File

@ -59,7 +59,7 @@ public:
}
//@}
// TODO? Create a version that accepts a VariantArrayHandle. Is this needed?
// TODO? Create a version that accepts an UnknownArrayHandle. Is this needed?
template <typename RangeType>
vtkm::Id GetThreadRange(RangeType vtkmNotUsed(outputRange)) const

5
vtkm/worklet/MaskSelect.cxx
View File

@ -127,12 +127,13 @@ struct MaskBuilder
} // anonymous namespace
vtkm::worklet::MaskSelect::ThreadToOutputMapType vtkm::worklet::MaskSelect::Build(
const VariantArrayHandleMask& maskArray,
const vtkm::cont::UnknownArrayHandle& maskArray,
vtkm::cont::DeviceAdapterId device)
{
VTKM_LOG_SCOPE(vtkm::cont::LogLevel::Perf, "MaskSelect::Build");
vtkm::worklet::MaskSelect::ThreadToOutputMapType threadToOutputMap;
maskArray.CastAndCall(MaskBuilder(), threadToOutputMap, device);
maskArray.CastAndCallForTypes<MaskTypes, vtkm::List<vtkm::cont::StorageTagBasic>>(
MaskBuilder(), threadToOutputMap, device);
return threadToOutputMap;
}

14
vtkm/worklet/MaskSelect.h
View File

@ -13,7 +13,7 @@
#include <vtkm/worklet/internal/MaskBase.h>
#include <vtkm/worklet/vtkm_worklet_export.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/UnknownArrayHandle.h>
namespace vtkm
{
@ -34,24 +34,16 @@ class VTKM_WORKLET_EXPORT MaskSelect : public internal::MaskBase
{
using MaskTypes =
vtkm::List<vtkm::Int32, vtkm::Int64, vtkm::UInt32, vtkm::UInt64, vtkm::Int8, vtkm::UInt8, char>;
using VariantArrayHandleMask = vtkm::cont::VariantArrayHandleBase<MaskTypes>;
public:
using ThreadToOutputMapType = vtkm::cont::ArrayHandle<vtkm::Id>;
MaskSelect(const VariantArrayHandleMask& maskArray,
MaskSelect(const vtkm::cont::UnknownArrayHandle& maskArray,
vtkm::cont::DeviceAdapterId device = vtkm::cont::DeviceAdapterTagAny())
{
this->ThreadToOutputMap = this->Build(maskArray, device);
}
template <typename TypeList>
MaskSelect(const vtkm::cont::VariantArrayHandleBase<TypeList>& indexArray,
vtkm::cont::DeviceAdapterId device = vtkm::cont::DeviceAdapterTagAny())
{
this->ThreadToOutputMap = this->Build(VariantArrayHandleMask(indexArray), device);
}
template <typename RangeType>
vtkm::Id GetThreadRange(RangeType vtkmNotUsed(outputRange)) const
{
@ -67,7 +59,7 @@ public:
private:
ThreadToOutputMapType ThreadToOutputMap;
VTKM_CONT ThreadToOutputMapType Build(const VariantArrayHandleMask& maskArray,
VTKM_CONT ThreadToOutputMapType Build(const vtkm::cont::UnknownArrayHandle& maskArray,
vtkm::cont::DeviceAdapterId device);
};
}

14
vtkm/worklet/PointMerge.h
View File

@ -24,7 +24,7 @@
#include <vtkm/cont/CellSetExplicit.h>
#include <vtkm/cont/ExecutionAndControlObjectBase.h>
#include <vtkm/cont/Invoker.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/UnknownArrayHandle.h>
#include <vtkm/Bounds.h>
#include <vtkm/Hash.h>
@ -443,18 +443,16 @@ public:
points = concretePoints;
}
template <typename TL>
VTKM_CONT void Run(
vtkm::Float64 delta, // Distance to consider two points coincident
bool fastCheck, // If true, approximate distances are used
const vtkm::Bounds& bounds, // Bounds of points
vtkm::cont::VariantArrayHandleBase<TL>& points) // coordinates, modified to merge close
VTKM_CONT void Run(vtkm::Float64 delta, // Distance to consider two points coincident
bool fastCheck, // If true, approximate distances are used
const vtkm::Bounds& bounds, // Bounds of points
vtkm::cont::UnknownArrayHandle& points) // coordinates, modified to merge close
{
// Get a cast to a concrete set of point coordiantes so that it can be modified in place
vtkm::cont::ArrayHandle<vtkm::Vec3f> concretePoints;
if (points.template IsType<decltype(concretePoints)>())
{
concretePoints = points.template Cast<decltype(concretePoints)>();
points.AsArrayHandle(concretePoints);
}
else
{

6
vtkm/worklet/RemoveUnusedPoints.h
View File

@ -15,6 +15,8 @@
#include <vtkm/cont/ArrayHandleConstant.h>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/CellSetExplicit.h>
#include <vtkm/cont/UnknownArrayHandle.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/ScatterCounting.h>
@ -222,6 +224,7 @@ private:
outHolder = vtkm::cont::UnknownArrayHandle{ outArray };
}
VTKM_DEPRECATED_SUPPRESS_BEGIN
template <typename InT, typename InS>
VTKM_CONT void operator()(const vtkm::cont::ArrayHandle<InT, InS>& inArray,
vtkm::cont::VariantArrayHandleCommon& outHolder,
@ -231,6 +234,7 @@ private:
(*this)(inArray, outArray, self);
outHolder = vtkm::cont::VariantArrayHandleCommon{ outArray };
}
VTKM_DEPRECATED_SUPPRESS_END
};
public:
@ -278,6 +282,7 @@ public:
return outArray;
}
VTKM_DEPRECATED_SUPPRESS_BEGIN
template <typename InArrayTypes, typename OutArrayHandle>
VTKM_CONT void MapPointFieldDeep(const vtkm::cont::VariantArrayHandleBase<InArrayTypes>& inArray,
OutArrayHandle& outArray) const
@ -294,6 +299,7 @@ public:
return outArray;
}
VTKM_DEPRECATED_SUPPRESS_END
///@}
const vtkm::worklet::ScatterCounting& GetPointScatter() const

4
vtkm/worklet/ScatterCounting.cxx
View File

@ -199,12 +199,12 @@ struct ScatterCountingBuilder
}
} // namespace vtkm::worklet::detail
void vtkm::worklet::ScatterCounting::BuildArrays(const VariantArrayHandleCount& countArray,
void vtkm::worklet::ScatterCounting::BuildArrays(const vtkm::cont::UnknownArrayHandle& countArray,
vtkm::cont::DeviceAdapterId device,
bool saveInputToOutputMap)
{
VTKM_LOG_SCOPE(vtkm::cont::LogLevel::Perf, "ScatterCounting::BuildArrays");
countArray.CastAndCall(
countArray.CastAndCallForTypes<CountTypes, vtkm::List<vtkm::cont::StorageTagBasic>>(
vtkm::worklet::detail::ScatterCountingBuilder(), device, saveInputToOutputMap, this);
}

22
vtkm/worklet/ScatterCounting.h
View File

@ -13,7 +13,7 @@
#include <vtkm/worklet/internal/ScatterBase.h>
#include <vtkm/worklet/vtkm_worklet_export.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/UnknownArrayHandle.h>
#include <sstream>
@ -51,7 +51,6 @@ struct VTKM_WORKLET_EXPORT ScatterCounting : internal::ScatterBase
vtkm::UInt32,
vtkm::UInt16,
vtkm::UInt8>;
using VariantArrayHandleCount = vtkm::cont::VariantArrayHandleBase<CountTypes>;
/// Construct a \c ScatterCounting object using an array of counts for the
/// number of outputs for each input. Part of the construction requires
@ -60,27 +59,14 @@ struct VTKM_WORKLET_EXPORT ScatterCounting : internal::ScatterBase
/// other users might make use of it, so you can instruct the constructor
/// to save the input to output map.
///
template <typename TypeList>
VTKM_CONT ScatterCounting(const vtkm::cont::VariantArrayHandleBase<TypeList>& countArray,
vtkm::cont::DeviceAdapterId device = vtkm::cont::DeviceAdapterTagAny(),
bool saveInputToOutputMap = false)
{
this->BuildArrays(VariantArrayHandleCount(countArray), device, saveInputToOutputMap);
}
VTKM_CONT ScatterCounting(const VariantArrayHandleCount& countArray,
VTKM_CONT ScatterCounting(const vtkm::cont::UnknownArrayHandle& countArray,
vtkm::cont::DeviceAdapterId device = vtkm::cont::DeviceAdapterTagAny(),
bool saveInputToOutputMap = false)
{
this->BuildArrays(countArray, device, saveInputToOutputMap);
}
template <typename TypeList>
VTKM_CONT ScatterCounting(const vtkm::cont::VariantArrayHandleBase<TypeList>& countArray,
VTKM_CONT ScatterCounting(const vtkm::cont::UnknownArrayHandle& countArray,
bool saveInputToOutputMap)
{
this->BuildArrays(
VariantArrayHandleCount(countArray), vtkm::cont::DeviceAdapterTagAny(), saveInputToOutputMap);
}
VTKM_CONT ScatterCounting(const VariantArrayHandleCount& countArray, bool saveInputToOutputMap)
{
this->BuildArrays(countArray, vtkm::cont::DeviceAdapterTagAny(), saveInputToOutputMap);
}
@ -135,7 +121,7 @@ private:
friend struct detail::ScatterCountingBuilder;
VTKM_CONT void BuildArrays(const VariantArrayHandleCount& countArray,
VTKM_CONT void BuildArrays(const vtkm::cont::UnknownArrayHandle& countArray,
vtkm::cont::DeviceAdapterId device,
bool saveInputToOutputMap);
};

14
vtkm/worklet/SurfaceNormals.h
View File

@ -17,7 +17,7 @@
#include <vtkm/CellTraits.h>
#include <vtkm/TypeTraits.h>
#include <vtkm/VectorAnalysis.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/UncertainArrayHandle.h>
namespace vtkm
{
@ -194,10 +194,14 @@ public:
vtkm::worklet::DispatcherMapTopology<Worklet>().Invoke(cellset, faceNormals, pointNormals);
}
template <typename CellSetType, typename FaceNormalTypeList, typename NormalCompType>
void Run(const CellSetType& cellset,
const vtkm::cont::VariantArrayHandleBase<FaceNormalTypeList>& faceNormals,
vtkm::cont::ArrayHandle<vtkm::Vec<NormalCompType, 3>>& pointNormals)
template <typename CellSetType,
typename FaceNormalTypeList,
typename FaceNormalStorageList,
typename NormalCompType>
void Run(
const CellSetType& cellset,
const vtkm::cont::UncertainArrayHandle<FaceNormalTypeList, FaceNormalStorageList>& faceNormals,
vtkm::cont::ArrayHandle<vtkm::Vec<NormalCompType, 3>>& pointNormals)
{
vtkm::worklet::DispatcherMapTopology<Worklet>().Invoke(cellset, faceNormals, pointNormals);
}

9
vtkm/worklet/VertexClustering.h
View File

@ -23,6 +23,7 @@
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/Logging.h>
#include <vtkm/cont/UnknownArrayHandle.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/DispatcherMapTopology.h>
@ -73,7 +74,7 @@ struct SelectRepresentativePoint : public vtkm::worklet::WorkletReduceByKey
template <typename InputPointsArrayType, typename KeyType>
VTKM_CONT void operator()(const InputPointsArrayType& points,
const vtkm::worklet::Keys<KeyType>& keys,
vtkm::cont::VariantArrayHandle& output) const
vtkm::cont::UnknownArrayHandle& output) const
{
vtkm::cont::ArrayHandle<typename InputPointsArrayType::ValueType> out;
@ -85,11 +86,11 @@ struct SelectRepresentativePoint : public vtkm::worklet::WorkletReduceByKey
};
template <typename KeyType, typename InputDynamicPointsArrayType>
VTKM_CONT static vtkm::cont::VariantArrayHandle Run(
VTKM_CONT static vtkm::cont::UnknownArrayHandle Run(
const vtkm::worklet::Keys<KeyType>& keys,
const InputDynamicPointsArrayType& inputPoints)
{
vtkm::cont::VariantArrayHandle output;
vtkm::cont::UnknownArrayHandle output;
RunTrampoline trampoline;
vtkm::cont::CastAndCall(inputPoints, trampoline, keys, output);
return output;
@ -365,7 +366,7 @@ public:
#endif
/// pass 2 : Choose a representative point from each cluster for the output:
vtkm::cont::VariantArrayHandle repPointArray;
vtkm::cont::UnknownArrayHandle repPointArray;
{
vtkm::worklet::Keys<vtkm::Id> keys;
keys.BuildArrays(pointCidArray, vtkm::worklet::KeysSortType::Stable);

8
vtkm/worklet/connectivities/ImageConnectivity.h
View File

@ -12,6 +12,7 @@
#define vtk_m_worklet_connectivity_ImageConnectivity_h
#include <vtkm/cont/Invoker.h>
#include <vtkm/cont/UncertainArrayHandle.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/WorkletPointNeighborhood.h>
@ -124,13 +125,14 @@ public:
}
};
template <int Dimension, typename T, typename OutputPortalType>
template <int Dimension, typename OutputPortalType>
void Run(const vtkm::cont::CellSetStructured<Dimension>& input,
const vtkm::cont::VariantArrayHandleBase<T>& pixels,
const vtkm::cont::UnknownArrayHandle& pixels,
OutputPortalType& componentsOut) const
{
using Types = vtkm::TypeListScalarAll;
vtkm::cont::CastAndCall(pixels.ResetTypes(Types{}), RunImpl(), input, componentsOut);
using Storages = VTKM_DEFAULT_STORAGE_LIST;
vtkm::cont::CastAndCall(pixels.ResetTypes<Types, Storages>(), RunImpl(), input, componentsOut);
}
template <int Dimension, typename T, typename S, typename OutputPortalType>

6
vtkm/worklet/internal/testing/UnitTestDispatcherBase.cxx
View File

@ -324,9 +324,9 @@ public:
const InputDomainType& inputDomain = invocation.GetInputDomain();
// For a DispatcherMapField, the inputDomain must be an ArrayHandle (or
// an VariantArrayHandle that gets cast to one). The size of the domain
// (number of threads/worklet instances) is equal to the size of the
// array.
// an UncertainArrayHandle or an UnknownArrayHandle that gets cast to one).
// The size of the domain (number of threads/worklet instances) is equal
// to the size of the array.
//verify the overloads for SchedulingRange work
auto numInstances = SchedulingRange(inputDomain);

5
vtkm/worklet/testing/UnitTestContour.cxx
View File

@ -163,9 +163,8 @@ inline vtkm::cont::DataSet MakeRadiantDataSet::Make3DRadiantDataSet(vtkm::IdComp
//Set point scalar
dataSet.AddField(vtkm::cont::Field(
"distanceToOrigin", vtkm::cont::Field::Association::POINTS, distanceToOrigin));
dataSet.AddField(vtkm::cont::Field("distanceToOther",
vtkm::cont::Field::Association::POINTS,
vtkm::cont::VariantArrayHandle(distanceToOther)));
dataSet.AddField(
vtkm::cont::Field("distanceToOther", vtkm::cont::Field::Association::POINTS, distanceToOther));
CellSet cellSet;
cellSet.Fill((dim + 1) * (dim + 1) * (dim + 1), HexTag::Id, HexTraits::NUM_POINTS, connectivity);

2
vtkm/worklet/testing/UnitTestWorkletMapField3d.cxx
View File

@ -10,8 +10,6 @@
#include <vtkm/cont/ArrayCopy.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/WorkletMapField.h>

5
vtkm/worklet/testing/UnitTestWorkletMapFieldExecArg.cxx
View File

@ -10,7 +10,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleIndex.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/UncertainArrayHandle.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/WorkletMapField.h>
@ -95,7 +95,8 @@ struct DoTestWorklet
outputHandle = vtkm::cont::ArrayHandle<T>();
outputHandle.Allocate(ARRAY_SIZE);
vtkm::cont::VariantArrayHandleBase<vtkm::List<T>> outputFieldDynamic(outputFieldArray);
vtkm::cont::UncertainArrayHandle<vtkm::List<T>, vtkm::List<vtkm::cont::StorageTagBasic>>
outputFieldDynamic(outputFieldArray);
dispatcher.Invoke(counting, inputHandle, outputHandle, outputFieldDynamic, SimpleExecObject());
std::cout << "Check dynamic array result." << std::endl;

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

@ -9,7 +9,7 @@
//============================================================================
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleIndex.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/UncertainArrayHandle.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/WorkletMapField.h>
@ -77,9 +77,12 @@ struct DoTestWholeArrayWorklet
outHandle.Allocate(ARRAY_SIZE);
vtkm::worklet::DispatcherMapField<WorkletType> dispatcher;
dispatcher.Invoke(vtkm::cont::VariantArrayHandle(inHandle).ResetTypes(vtkm::List<T>{}),
vtkm::cont::VariantArrayHandle(inOutHandle).ResetTypes(vtkm::List<T>{}),
vtkm::cont::VariantArrayHandle(outHandle).ResetTypes(vtkm::List<T>{}));
dispatcher.Invoke(vtkm::cont::UnknownArrayHandle(inHandle)
.ResetTypes<vtkm::List<T>, vtkm::List<VTKM_DEFAULT_STORAGE_TAG>>(),
vtkm::cont::UnknownArrayHandle(inOutHandle)
.ResetTypes<vtkm::List<T>, vtkm::List<VTKM_DEFAULT_STORAGE_TAG>>(),
vtkm::cont::UnknownArrayHandle(outHandle)
.ResetTypes<vtkm::List<T>, vtkm::List<VTKM_DEFAULT_STORAGE_TAG>>());
std::cout << "Check result." << std::endl;
CheckPortal(inOutHandle.ReadPortal());

12
vtkm/worklet/testing/UnitTestWorkletMapFieldWholeArrayAtomic.cxx
View File

@ -9,7 +9,7 @@
//============================================================================
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleIndex.h>
#include <vtkm/cont/VariantArrayHandle.h>
#include <vtkm/cont/UncertainArrayHandle.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/WorkletMapField.h>
@ -42,12 +42,14 @@ struct DoTestAtomicArrayWorklet
// This just demonstrates that the WholeArray tags support dynamic arrays.
VTKM_CONT
void CallWorklet(const vtkm::cont::VariantArrayHandle& inOutArray) const
void CallWorklet(const vtkm::cont::UnknownArrayHandle& inOutArray) const
{
std::cout << "Create and run dispatcher." << std::endl;
vtkm::worklet::DispatcherMapField<WorkletType> dispatcher;
dispatcher.Invoke(vtkm::cont::ArrayHandleIndex(ARRAY_SIZE),
inOutArray.ResetTypes<vtkm::cont::AtomicArrayTypeList>());
dispatcher.Invoke(
vtkm::cont::ArrayHandleIndex(ARRAY_SIZE),
inOutArray
.ResetTypes<vtkm::cont::AtomicArrayTypeList, vtkm::List<vtkm::cont::StorageTagBasic>>());
}
template <typename T>
@ -56,7 +58,7 @@ struct DoTestAtomicArrayWorklet
std::cout << "Set up data." << std::endl;
vtkm::cont::ArrayHandle<T> inOutHandle = vtkm::cont::make_ArrayHandle<T>({ 0 });
this->CallWorklet(vtkm::cont::VariantArrayHandle(inOutHandle));
this->CallWorklet(inOutHandle);
std::cout << "Check result." << std::endl;
T result = inOutHandle.ReadPortal().Get(0);