Fix deprecation warnings

There was an error that caused deprecation warnings in VTK-m to be
suppressed, which meant that many uses of deprecated features went
unnoticed. This fixes those deprecation warnings.

The majority of the warnings were caused by the use of the deprecated
`Cast`, `CopyTo`, and `ResetTypes` methods of `UnknownArrayHandle` (or
`VariantArrayHandle`). Both `Cast` and `CopyTo` have been subsumed by
`AsArrayHandle` (to make the functionality more clear). `ResetTypes` now
requires a second template argument to define the storage types to try.

Also fixed some issues with `SerializableField` being deprecated.
This class is no longer necessary because `Field` can now be directly
serialized.

examples/contour_tree/ContourTreeMesh2D.cxx

@@ -112,7 +112,7 @@ int main(int argc, char* argv[])
   vtkm::cont::Field resultField = output.GetField("saddlePeak");
   ;
   vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
-  resultField.GetData().CopyTo(saddlePeak);
+  resultField.GetData().AsArrayHandle(saddlePeak);
 
   return 0;
 }

examples/contour_tree/ContourTreeMesh3D.cxx

@@ -113,7 +113,7 @@ int main(int argc, char* argv[])
 
   vtkm::cont::Field resultField = output.GetField("saddlePeak");
   vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
-  resultField.GetData().CopyTo(saddlePeak);
+  resultField.GetData().AsArrayHandle(saddlePeak);
 
   return 0;
 }

examples/contour_tree_augmented/ContourTreeApp.cxx

@@ -762,14 +762,13 @@ int main(int argc, char* argv[])
     if (numLevels > 0) // if compute isovalues
     {
 // Get the data values for computing the explicit branch decomposition
-// TODO Can we cast the handle we get from GetData() instead of doing a CopyTo?
 #ifdef WITH_MPI
       vtkm::cont::ArrayHandle<ValueType> dataField;
-      result.GetPartitions()[0].GetField(0).GetData().CopyTo(dataField);
+      result.GetPartitions()[0].GetField(0).GetData().AsArrayHandle(dataField);
       bool dataFieldIsSorted = true;
 #else
       vtkm::cont::ArrayHandle<ValueType> dataField;
-      useDataSet.GetField(0).GetData().CopyTo(dataField);
+      useDataSet.GetField(0).GetData().AsArrayHandle(dataField);
       bool dataFieldIsSorted = false;
 #endif
 
@@ -844,7 +843,7 @@ int main(int argc, char* argv[])
 
   //vtkm::cont::Field resultField =  result.GetField();
   //vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id> > saddlePeak;
-  //resultField.GetData().CopyTo(saddlePeak);
+  //resultField.GetData().AsArrayHandle(saddlePeak);
 
   // Dump out contour tree for comparison
   if (rank == 0 && printContourTree)

examples/ising/Ising.cxx

@@ -96,7 +96,7 @@ int main(int argc, char** argv)
 
   auto dataSet = SpinField({ 5, 5 });
   vtkm::cont::ArrayHandle<vtkm::Float32> spins;
-  dataSet.GetCellField("spins").GetData().CopyTo(spins);
+  dataSet.GetCellField("spins").GetData().AsArrayHandle(spins);
 
   vtkm::rendering::Scene scene;
   vtkm::rendering::Actor actor(dataSet.GetCellSet(),

examples/polyline_archimedean_helix/PolyLineArchimedeanHelix.cxx

@@ -66,10 +66,11 @@ void TubeThatSpiral(vtkm::FloatDefault radius, vtkm::Id numLineSegments, vtkm::I
   // This generates a new pointset, and new cell set.
   vtkm::cont::ArrayHandle<vtkm::Vec3f> tubePoints;
   vtkm::cont::CellSetSingleType<> tubeCells;
-  tubeWorklet.Run(ds.GetCoordinateSystem().GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Vec3f>>(),
+  tubeWorklet.Run(
-                  ds.GetCellSet(),
+    ds.GetCoordinateSystem().GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Vec3f>>(),
-                  tubePoints,
+    ds.GetCellSet(),
-                  tubeCells);
+    tubePoints,
+    tubeCells);
 
   vtkm::cont::DataSet tubeDataset;
   tubeDataset.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coords", tubePoints));

examples/redistribute_points/RedistributePoints.h

@@ -100,7 +100,7 @@ class Redistributor
                       vtkm::Id currentIdx) const
       {
         vtkm::cont::ArrayHandle<T> farray =
-          field.GetData().template Cast<vtkm::cont::ArrayHandle<T>>();
+          field.GetData().template AsArrayHandle<vtkm::cont::ArrayHandle<T>>();
         vtkm::cont::Algorithm::CopySubRange(data, 0, data.GetNumberOfValues(), farray, currentIdx);
       }
     };

vtkm/cont/CellLocatorRectilinearGrid.cxx

@@ -95,7 +95,7 @@ const vtkm::exec::CellLocator* CellLocatorRectilinearGrid::PrepareForExecution(
       this->PlaneSize,
       this->RowSize,
       this->GetCellSet().template Cast<Structured3DType>(),
-      this->GetCoordinates().GetData().template Cast<RectilinearType>());
+      this->GetCoordinates().GetData().template AsArrayHandle<RectilinearType>());
   }
   else
   {
@@ -107,7 +107,7 @@ const vtkm::exec::CellLocator* CellLocatorRectilinearGrid::PrepareForExecution(
       this->PlaneSize,
       this->RowSize,
       this->GetCellSet().template Cast<Structured2DType>(),
-      this->GetCoordinates().GetData().template Cast<RectilinearType>());
+      this->GetCoordinates().GetData().template AsArrayHandle<RectilinearType>());
   }
   if (!success)
   {

vtkm/cont/CellLocatorUniformGrid.cxx

@@ -53,7 +53,7 @@ void CellLocatorUniformGrid::Build()
     throw vtkm::cont::ErrorBadType("Cells are not 2D or 3D structured type.");
   }
 
-  UniformType uniformCoords = coords.GetData().Cast<UniformType>();
+  UniformType uniformCoords = coords.GetData().AsArrayHandle<UniformType>();
   auto coordsPortal = uniformCoords.ReadPortal();
   this->Origin = coordsPortal.GetOrigin();
 

vtkm/cont/CoordinateSystem.cxx

@@ -72,7 +72,7 @@ CoordinateSystem::GetData() const
 VTKM_CONT vtkm::cont::CoordinateSystem::MultiplexerArrayType
 CoordinateSystem::GetDataAsMultiplexer() const
 {
-  return this->GetData().AsMultiplexer<MultiplexerArrayType>();
+  return this->GetData().AsArrayHandle<MultiplexerArrayType>();
 }
 
 VTKM_CONT

vtkm/cont/DataSet.h

@@ -338,7 +338,7 @@ public:
     vtkmdiy::save(bb, numberOfFields);
     for (vtkm::IdComponent i = 0; i < numberOfFields; ++i)
     {
-      vtkmdiy::save(bb, vtkm::cont::SerializableField<FieldTypeList>(dataset.GetField(i)));
+      vtkmdiy::save(bb, dataset.GetField(i));
     }
   }
 
@@ -364,9 +364,9 @@ public:
     vtkmdiy::load(bb, numberOfFields);
     for (vtkm::IdComponent i = 0; i < numberOfFields; ++i)
     {
-      vtkm::cont::SerializableField<FieldTypeList> field;
+      vtkm::cont::Field field;
       vtkmdiy::load(bb, field);
-      dataset.AddField(field.Field);
+      dataset.AddField(field);
     }
   }
 };

vtkm/cont/testing/Testing.h

@@ -468,10 +468,8 @@ inline VTKM_CONT TestEqualResult test_equal_CellSets(const CellSet1& cellset1,
   return result;
 }
 
-template <typename FieldTypeList = VTKM_DEFAULT_TYPE_LIST>
 inline VTKM_CONT TestEqualResult test_equal_Fields(const vtkm::cont::Field& f1,
-                                                   const vtkm::cont::Field& f2,
+                                                   const vtkm::cont::Field& f2)
-                                                   FieldTypeList fTtypes = FieldTypeList())
 {
   TestEqualResult result;
 
@@ -487,8 +485,7 @@ inline VTKM_CONT TestEqualResult test_equal_Fields(const vtkm::cont::Field& f1,
     return result;
   }
 
-  result =
+  result = test_equal_ArrayHandles(f1.GetData(), f2.GetData());
-    test_equal_ArrayHandles(f1.GetData().ResetTypes(fTtypes), f2.GetData().ResetTypes(fTtypes));
   if (!result)
   {
     result.PushMessage("data doesn't match");
@@ -497,12 +494,10 @@ inline VTKM_CONT TestEqualResult test_equal_Fields(const vtkm::cont::Field& f1,
   return result;
 }
 
-template <typename CellSetTypes = VTKM_DEFAULT_CELL_SET_LIST,
+template <typename CellSetTypes = VTKM_DEFAULT_CELL_SET_LIST>
-          typename FieldTypeList = VTKM_DEFAULT_TYPE_LIST>
 inline VTKM_CONT TestEqualResult test_equal_DataSets(const vtkm::cont::DataSet& ds1,
                                                      const vtkm::cont::DataSet& ds2,
-                                                     CellSetTypes ctypes = CellSetTypes(),
+                                                     CellSetTypes ctypes = CellSetTypes())
-                                                     FieldTypeList fTtypes = FieldTypeList())
 {
   TestEqualResult result;
   if (ds1.GetNumberOfCoordinateSystems() != ds2.GetNumberOfCoordinateSystems())
@@ -537,7 +532,7 @@ inline VTKM_CONT TestEqualResult test_equal_DataSets(const vtkm::cont::DataSet&
   }
   for (vtkm::IdComponent i = 0; i < ds1.GetNumberOfFields(); ++i)
   {
-    result = test_equal_Fields(ds1.GetField(i), ds2.GetField(i), fTtypes);
+    result = test_equal_Fields(ds1.GetField(i), ds2.GetField(i));
     if (!result)
     {
       result.PushMessage(std::string("fields don't match at index ") + std::to_string(i));

vtkm/cont/testing/TestingCellLocatorRectilinearGrid.h

@@ -185,7 +185,7 @@ public:
     vtkm::cont::ArrayHandle<bool> match;
     vtkm::cont::Token token;
     LocatorWorklet<DeviceAdapter> worklet(
-      bounds, dims, coords.GetData().template Cast<RectilinearType>(), token);
+      bounds, dims, coords.GetData().template AsArrayHandle<RectilinearType>(), token);
 
     vtkm::worklet::DispatcherMapField<LocatorWorklet<DeviceAdapter>> dispatcher(worklet);
     dispatcher.SetDevice(DeviceAdapter());

vtkm/cont/testing/TestingCellLocatorTwoLevel.h

@@ -97,7 +97,7 @@ vtkm::cont::DataSet MakeTestDataSet(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dims)
   std::uniform_real_distribution<vtkm::FloatDefault> warpFactor(-0.10f, 0.10f);
   auto inPointsPortal = uniformDs.GetCoordinateSystem()
                           .GetData()
-                          .template Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>()
+                          .template AsArrayHandle<vtkm::cont::ArrayHandleUniformPointCoordinates>()
                           .ReadPortal();
   vtkm::cont::ArrayHandle<PointType> points;
   points.Allocate(inPointsPortal.GetNumberOfValues());

vtkm/cont/testing/UnitTestPartitionedDataSet.cxx

@@ -124,9 +124,9 @@ void DataSet_Compare(vtkm::cont::DataSet& leftDataSet, vtkm::cont::DataSet& righ
   for (vtkm::Id j = 0; j < leftDataSet.GetNumberOfFields(); j++)
   {
     vtkm::cont::ArrayHandle<vtkm::Float32> lDataArray;
-    leftDataSet.GetField(j).GetData().CopyTo(lDataArray);
+    leftDataSet.GetField(j).GetData().AsArrayHandle(lDataArray);
     vtkm::cont::ArrayHandle<vtkm::Float32> rDataArray;
-    rightDataSet.GetField(j).GetData().CopyTo(rDataArray);
+    rightDataSet.GetField(j).GetData().AsArrayHandle(rDataArray);
     VTKM_TEST_ASSERT(lDataArray == rDataArray, "field value info incorrect");
   }
   return;

vtkm/cont/testing/UnitTestSerializationDataSet.cxx

@@ -26,7 +26,7 @@ using DataSetWrapper = vtkm::cont::SerializableDataSet<FieldTypeList, CellSetTyp
 
 VTKM_CONT void TestEqualDataSet(const DataSetWrapper& ds1, const DataSetWrapper& ds2)
 {
-  VTKM_TEST_ASSERT(test_equal_DataSets(ds1.DataSet, ds2.DataSet, CellSetTypes{}, FieldTypeList{}));
+  VTKM_TEST_ASSERT(test_equal_DataSets(ds1.DataSet, ds2.DataSet, CellSetTypes{}));
 }
 
 void RunTest(const vtkm::cont::DataSet& ds)

vtkm/filter/ContourTreeUniformAugmented.hxx

@@ -299,7 +299,9 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(
       currBlock.GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
     //const vtkm::cont::ArrayHandle<T,StorageType> &fieldData = currField.GetData().Cast<vtkm::cont::ArrayHandle<T,StorageType> >();
     vtkm::cont::ArrayHandle<T> fieldData;
-    vtkm::cont::ArrayCopy(currField.GetData().template ResetTypes<vtkm::List<T>>(), fieldData);
+    vtkm::cont::ArrayCopy(
+      currField.GetData().template ResetTypes<vtkm::List<T>, VTKM_DEFAULT_STORAGE_LIST>(),
+      fieldData);
     auto currContourTreeMesh = vtkm::worklet::contourtree_distributed::MultiBlockContourTreeHelper::
       ComputeLocalContourTreeMesh<T>(
         this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal()

vtkm/filter/ContourTreeUniformDistributed.hxx

@@ -680,7 +680,9 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
     auto currField =
       currBlock.GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
     vtkm::cont::ArrayHandle<FieldType> fieldData;
-    vtkm::cont::ArrayCopy(currField.GetData().ResetTypes(vtkm::List<FieldType>{}), fieldData);
+    vtkm::cont::ArrayCopy(
+      currField.GetData().ResetTypes(vtkm::List<FieldType>{}, VTKM_DEFAULT_STORAGE_LIST{}),
+      fieldData);
 
     // ... compute and store the actual mesh
     localDataBlocks[bi]->ContourTreeMeshes.emplace_back(this->LocalBoundaryTrees[bi].VertexIndex,
@@ -914,7 +916,9 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
       auto currField =
         currBlock.GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
       vtkm::cont::ArrayHandle<FieldType> fieldData;
-      vtkm::cont::ArrayCopy(currField.GetData().ResetTypes(vtkm::List<FieldType>{}), fieldData);
+      vtkm::cont::ArrayCopy(
+        currField.GetData().ResetTypes(vtkm::List<FieldType>{}, VTKM_DEFAULT_STORAGE_LIST{}),
+        fieldData);
       auto localToGlobalIdRelabeler = vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler(
         this->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal().Get(
           blockData->BlockIndex),

vtkm/filter/FilterTraits.h

@@ -35,6 +35,14 @@ struct DeduceFilterFieldTypes
   using PList = typename DerivedPolicy::FieldTypeList;
   using TypeList = vtkm::ListIntersect<ListOfTypes, PList>;
 };
+
+template <typename DerivedPolicy, typename ListOfStorage>
+struct DeduceFilterFieldStorage
+{
+  using PList = typename DerivedPolicy::StorageList;
+  using StorageList = vtkm::ListAppend<ListOfStorage, PList>;
+};
+
 }
 }
 

vtkm/filter/Histogram.hxx

@@ -86,7 +86,8 @@ public:
 
   void SetLocalHistogram(vtkm::Id index, const vtkm::cont::Field& field)
   {
-    this->SetLocalHistogram(index, field.GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Id>>());
+    this->SetLocalHistogram(index,
+                            field.GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>());
   }
 
   vtkm::cont::ArrayHandle<vtkm::Id> ReduceAll() const

vtkm/filter/ImageDifference.hxx

@@ -89,8 +89,7 @@ inline VTKM_CONT vtkm::cont::DataSet ImageDifference::DoExecute(
   {
     VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Not performing average");
     primaryOutput = primary;
-    secondaryOutput =
+    secondaryField.GetData().AsArrayHandle(secondaryOutput);
-      secondaryField.GetData().template Cast<vtkm::cont::ArrayHandle<T, StorageType>>();
   }
 
   if (this->PixelShiftRadius > 0)

vtkm/filter/PolicyBase.h

@@ -201,10 +201,12 @@ using ArrayHandleMultiplexerForStorageList = vtkm::cont::ArrayHandleMultiplexerF
 /// passed to the `DoMapField` method of filters.
 ///
 template <typename DerivedPolicy>
-VTKM_CONT vtkm::cont::VariantArrayHandleBase<typename std::conditional<
+VTKM_CONT vtkm::cont::UncertainArrayHandle<
-  std::is_same<typename DerivedPolicy::FieldTypeList, vtkm::ListUniversal>::value,
+  typename std::conditional<
-  VTKM_DEFAULT_TYPE_LIST,
+    std::is_same<typename DerivedPolicy::FieldTypeList, vtkm::ListUniversal>::value,
-  typename DerivedPolicy::FieldTypeList>::type>
+    VTKM_DEFAULT_TYPE_LIST,
+    typename DerivedPolicy::FieldTypeList>::type,
+  typename DerivedPolicy::StorageList>
 ApplyPolicyFieldNotActive(const vtkm::cont::Field& field, vtkm::filter::PolicyBase<DerivedPolicy>)
 {
   // Policies are on their way out, but until they are we want to respect them. In the mean
@@ -213,7 +215,7 @@ ApplyPolicyFieldNotActive(const vtkm::cont::Field& field, vtkm::filter::PolicyBa
     std::is_same<typename DerivedPolicy::FieldTypeList, vtkm::ListUniversal>::value,
     VTKM_DEFAULT_TYPE_LIST,
     typename DerivedPolicy::FieldTypeList>::type;
-  return field.GetData().ResetTypes(TypeList());
+  return field.GetData().ResetTypes(TypeList{}, typename DerivedPolicy::StorageList{});
 }
 
 //-----------------------------------------------------------------------------
@@ -235,7 +237,7 @@ ApplyPolicyFieldOfType(const vtkm::cont::Field& field,
     T,
     vtkm::ListAppend<typename FilterType::AdditionalFieldStorage,
                      typename DerivedPolicy::StorageList>>;
-  return field.GetData().AsMultiplexer<ArrayHandleMultiplexerType>();
+  return field.GetData().AsArrayHandle<ArrayHandleMultiplexerType>();
 }
 
 //-----------------------------------------------------------------------------
@@ -255,7 +257,10 @@ ApplyPolicyFieldActive(const vtkm::cont::Field& field,
   using FilterTypes = typename vtkm::filter::FilterTraits<FilterType>::InputFieldTypeList;
   using TypeList =
     typename vtkm::filter::DeduceFilterFieldTypes<DerivedPolicy, FilterTypes>::TypeList;
-  return field.GetData().ResetTypes(TypeList());
+  using FilterStorage = typename vtkm::filter::FilterTraits<FilterType>::AdditionalFieldStorage;
+  using StorageList =
+    typename vtkm::filter::DeduceFilterFieldStorage<DerivedPolicy, FilterStorage>::StorageList;
+  return field.GetData().ResetTypes(TypeList{}, StorageList{});
 }
 
 ////-----------------------------------------------------------------------------
@@ -361,19 +366,26 @@ VTKM_CONT vtkm::cont::DynamicCellSetBase<
 }
 
 //-----------------------------------------------------------------------------
+VTKM_DEPRECATED_SUPPRESS_BEGIN
 template <typename DerivedPolicy>
-VTKM_CONT vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList>
+VTKM_DEPRECATED(1.6, "MakeSerializableField is no longer needed.")
-  MakeSerializableField(vtkm::filter::PolicyBase<DerivedPolicy>)
+VTKM_CONT
+  vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList> MakeSerializableField(
+    vtkm::filter::PolicyBase<DerivedPolicy>)
 {
   return {};
 }
 
 template <typename DerivedPolicy>
-VTKM_CONT vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList>
+VTKM_DEPRECATED(1.6, "MakeSerializableField is no longer needed.")
-MakeSerializableField(const vtkm::cont::Field& field, vtkm::filter::PolicyBase<DerivedPolicy>)
+VTKM_CONT
+  vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList> MakeSerializableField(
+    const vtkm::cont::Field& field,
+    vtkm::filter::PolicyBase<DerivedPolicy>)
 {
   return vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList>{ field };
 }
+VTKM_DEPRECATED_SUPPRESS_END
 
 template <typename DerivedPolicy>
 VTKM_DEPRECATED(1.6, "MakeSerializableDataSet now takes the filter as an argument.")

vtkm/filter/particleadvection/DataSetIntegrator.h

@@ -44,9 +44,10 @@ public:
     FieldHandle fieldArray;
 
     if (fieldData.IsType<FieldHandle>())
-      fieldArray = fieldData.Cast<FieldHandle>();
+      fieldArray = fieldData.AsArrayHandle<FieldHandle>();
     else
-      vtkm::cont::ArrayCopy(fieldData.ResetTypes<vtkm::TypeListFieldVec3>(), fieldArray);
+      vtkm::cont::ArrayCopy(
+        fieldData.ResetTypes<vtkm::TypeListFieldVec3, VTKM_DEFAULT_STORAGE_LIST>(), fieldArray);
 
     this->Eval = std::shared_ptr<GridEvalType>(new GridEvalType(ds, fieldArray));
   }

vtkm/filter/testing/UnitTestCellAverageFilter.cxx

@@ -30,7 +30,7 @@ void TestCellAverageRegular3D()
   VTKM_TEST_ASSERT(result.HasCellField("avgvals") == true, "Result field not present.");
 
   vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
-  result.GetCellField("avgvals").GetData().CopyTo(resultArrayHandle);
+  result.GetCellField("avgvals").GetData().AsArrayHandle(resultArrayHandle);
   {
     vtkm::Float32 expected[4] = { 60.1875f, 70.2125f, 120.3375f, 130.3625f };
     for (vtkm::Id i = 0; i < 4; ++i)
@@ -49,7 +49,7 @@ void TestCellAverageRegular3D()
 
   vtkm::cont::ArrayHandle<vtkm::Vec3f> resultPointArray;
   vtkm::cont::Field resultPointField = result.GetCellField("avgpos");
-  resultPointField.GetData().CopyTo(resultPointArray);
+  resultPointField.GetData().AsArrayHandle(resultPointArray);
   {
     vtkm::FloatDefault expected[4][3] = {
       { 0.5f, 0.5f, 0.5f }, { 1.5f, 0.5f, 0.5f }, { 0.5f, 0.5f, 1.5f }, { 1.5f, 0.5f, 1.5f }
@@ -81,7 +81,7 @@ void TestCellAverageRegular2D()
 
   vtkm::cont::Field resultField = result.GetCellField("pointvar");
   vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
-  resultField.GetData().CopyTo(resultArrayHandle);
+  resultField.GetData().AsArrayHandle(resultArrayHandle);
   vtkm::Float32 expected[2] = { 30.1f, 40.1f };
   for (int i = 0; i < 2; ++i)
   {
@@ -107,7 +107,7 @@ void TestCellAverageExplicit()
 
   vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
   vtkm::cont::Field resultField = result.GetCellField("pointvar");
-  resultField.GetData().CopyTo(resultArrayHandle);
+  resultField.GetData().AsArrayHandle(resultArrayHandle);
   vtkm::Float32 expected[2] = { 20.1333f, 35.2f };
   for (int i = 0; i < 2; ++i)
   {

vtkm/filter/testing/UnitTestCellMeasuresFilter.cxx

@@ -60,7 +60,9 @@ void TestCellMeasuresFilter(vtkm::cont::DataSet& dataset,
                    "Output field could not be found or was improper.");
 
   vtkm::cont::CastAndCall(
-    result.ResetTypes(vtkm::TypeListFieldScalar{}), CheckCellMeasuresFunctor{}, expected);
+    result.ResetTypes(vtkm::TypeListFieldScalar{}, VTKM_DEFAULT_STORAGE_LIST{}),
+    CheckCellMeasuresFunctor{},
+    expected);
 }
 
 void TestCellMeasures()

vtkm/filter/testing/UnitTestCellSetConnectivityFilter.cxx

@@ -39,7 +39,7 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Id> componentArray;
     auto temp = output.GetField("component").GetData();
-    temp.CopyTo(componentArray);
+    temp.AsArrayHandle(componentArray);
 
     using Algorithm = vtkm::cont::Algorithm;
     Algorithm::Sort(componentArray);
@@ -57,7 +57,7 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Id> componentArray;
     auto temp = output.GetField("component").GetData();
-    temp.CopyTo(componentArray);
+    temp.AsArrayHandle(componentArray);
 
     using Algorithm = vtkm::cont::Algorithm;
     Algorithm::Sort(componentArray);
@@ -74,7 +74,7 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Id> componentArray;
     auto temp = output.GetField("component").GetData();
-    temp.CopyTo(componentArray);
+    temp.AsArrayHandle(componentArray);
 
     using Algorithm = vtkm::cont::Algorithm;
     Algorithm::Sort(componentArray);

vtkm/filter/testing/UnitTestCleanGrid.cxx

@@ -45,7 +45,7 @@ void TestUniformGrid(vtkm::filter::CleanGrid clean)
   VTKM_TEST_ASSERT((cellIds == vtkm::Id4(1, 2, 5, 4)), "Bad cell ids: ", cellIds);
 
   vtkm::cont::ArrayHandle<vtkm::Float32> outPointField;
-  outData.GetField("pointvar").GetData().CopyTo(outPointField);
+  outData.GetField("pointvar").GetData().AsArrayHandle(outPointField);
   VTKM_TEST_ASSERT(outPointField.GetNumberOfValues() == 6,
                    "Wrong point field size: ",
                    outPointField.GetNumberOfValues());
@@ -57,7 +57,7 @@ void TestUniformGrid(vtkm::filter::CleanGrid clean)
                    outPointField.ReadPortal().Get(1));
 
   vtkm::cont::ArrayHandle<vtkm::Float32> outCellField;
-  outData.GetField("cellvar").GetData().CopyTo(outCellField);
+  outData.GetField("cellvar").GetData().AsArrayHandle(outCellField);
   VTKM_TEST_ASSERT(outCellField.GetNumberOfValues() == 2, "Wrong cell field size.");
   VTKM_TEST_ASSERT(test_equal(outCellField.ReadPortal().Get(0), 100.1),
                    "Bad cell field value",

vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx

@@ -68,7 +68,7 @@ void TestClipExplicit()
 
   auto temp = outputData.GetField("scalars").GetData();
   vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
-  temp.CopyTo(resultArrayHandle);
+  temp.AsArrayHandle(resultArrayHandle);
 
   vtkm::Float32 expected[7] = { 1, 2, 1, 0, 0.5, 0.5, 0.5 };
   for (int i = 0; i < 7; ++i)

vtkm/filter/testing/UnitTestContourFilter.cxx

@@ -61,7 +61,7 @@ public:
 
       //verify the cellvar result
       vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellFieldArrayOut;
-      result.GetField("cellvar").GetData().CopyTo(cellFieldArrayOut);
+      result.GetField("cellvar").GetData().AsArrayHandle(cellFieldArrayOut);
 
       vtkm::cont::Algorithm::Sort(cellFieldArrayOut);
       {
@@ -151,7 +151,7 @@ public:
     dataSet.GetCellSet().CopyTo(cellSet);
 
     vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
-    dataSet.GetPointField("gyroid").GetData().CopyTo(fieldArray);
+    dataSet.GetPointField("gyroid").GetData().AsArrayHandle(fieldArray);
 
     vtkm::worklet::Contour isosurfaceFilter;
     isosurfaceFilter.SetMergeDuplicatePoints(false);

vtkm/filter/testing/UnitTestContourFilterNormals.cxx

@@ -111,7 +111,7 @@ void TestNormals(const vtkm::cont::DataSet& dataset, bool structured)
 
   mc.SetActiveField("pointvar");
   auto result = mc.Execute(dataset);
-  result.GetField("normals").GetData().CopyTo(normals);
+  result.GetField("normals").GetData().AsArrayHandle(normals);
   VTKM_TEST_ASSERT(normals.GetNumberOfValues() == numVerts,
                    "Wrong number of values in normals field");
 
@@ -150,7 +150,7 @@ void TestNormals(const vtkm::cont::DataSet& dataset, bool structured)
   }
 
   result = mc.Execute(dataset);
-  result.GetField("normals").GetData().CopyTo(normals);
+  result.GetField("normals").GetData().AsArrayHandle(normals);
   VTKM_TEST_ASSERT(normals.GetNumberOfValues() == numVerts,
                    "Wrong number of values in normals field");
 

vtkm/filter/testing/UnitTestContourTreeUniformFilter.cxx

@@ -87,7 +87,7 @@ public:
 
     vtkm::cont::Field Result = result.GetField("saddlePeak");
     vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
-    Result.GetData().CopyTo(saddlePeak);
+    Result.GetData().AsArrayHandle(saddlePeak);
 
     VTKM_TEST_ASSERT(test_equal(saddlePeak.GetNumberOfValues(), 7),
                      "Wrong result for ContourTree filter");
@@ -126,7 +126,7 @@ public:
 
     vtkm::cont::Field Result = result.GetField("saddlePeak");
     vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
-    Result.GetData().CopyTo(saddlePeak);
+    Result.GetData().AsArrayHandle(saddlePeak);
 
     VTKM_TEST_ASSERT(test_equal(saddlePeak.GetNumberOfValues(), 9),
                      "Wrong result for ContourTree filter");

vtkm/filter/testing/UnitTestCrossProductFilter.cxx

@@ -79,7 +79,7 @@ void CheckResult(const vtkm::cont::ArrayHandle<vtkm::Vec3f>& field1,
   VTKM_TEST_ASSERT(result.HasPointField("crossproduct"), "Output field is missing.");
 
   vtkm::cont::ArrayHandle<vtkm::Vec3f> outputArray;
-  result.GetPointField("crossproduct").GetData().CopyTo(outputArray);
+  result.GetPointField("crossproduct").GetData().AsArrayHandle(outputArray);
 
   auto v1Portal = field1.ReadPortal();
   auto v2Portal = field2.ReadPortal();

vtkm/filter/testing/UnitTestDotProductFilter.cxx

@@ -79,7 +79,7 @@ void CheckResult(const vtkm::cont::ArrayHandle<vtkm::Vec3f>& field1,
   VTKM_TEST_ASSERT(result.HasPointField("dotproduct"), "Output field is missing.");
 
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> outputArray;
-  result.GetPointField("dotproduct").GetData().CopyTo(outputArray);
+  result.GetPointField("dotproduct").GetData().AsArrayHandle(outputArray);
 
   auto v1Portal = field1.ReadPortal();
   auto v2Portal = field2.ReadPortal();

vtkm/filter/testing/UnitTestEntropyFilter.cxx

@@ -33,7 +33,7 @@ void TestEntropy()
 
   ///// get entropy from resultEntropy /////
   vtkm::cont::ArrayHandle<vtkm::Float64> entropy;
-  resultEntropy.GetField("entropy").GetData().CopyTo(entropy);
+  resultEntropy.GetField("entropy").GetData().AsArrayHandle(entropy);
   vtkm::cont::ArrayHandle<vtkm::Float64>::ReadPortalType portal = entropy.ReadPortal();
   vtkm::Float64 entropyFromFilter = portal.Get(0);
 

vtkm/filter/testing/UnitTestExtractGeometryFilter.cxx

@@ -42,7 +42,7 @@ public:
     VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 8), "Wrong result for ExtractGeometry");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(0) == 21.f, "Wrong cell field data");
     VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(7) == 42.f, "Wrong cell field data");
@@ -69,7 +69,7 @@ public:
     VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 56), "Wrong result for ExtractGeometry");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(0) == 0.f, "Wrong cell field data");
     VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(55) == 63.f, "Wrong cell field data");
@@ -96,7 +96,7 @@ public:
     VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 64), "Wrong result for ExtractGeometry");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(0) == 0.f, "Wrong cell field data");
     VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(63) == 63.f, "Wrong cell field data");
@@ -122,7 +122,7 @@ public:
     VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 56), "Wrong result for ExtractGeometry");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(0) == 0.f, "Wrong cell field data");
     VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(55) == 63.f, "Wrong cell field data");

vtkm/filter/testing/UnitTestExtractPointsFilter.cxx

@@ -41,7 +41,7 @@ public:
     VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 27), "Wrong result for ExtractPoints");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -71,7 +71,7 @@ public:
     VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 98), "Wrong result for ExtractPoints");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),

vtkm/filter/testing/UnitTestExtractStructuredFilter.cxx

@@ -41,9 +41,9 @@ public:
                      "Wrong result for ExtractStructured worklet");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -78,8 +78,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -116,8 +116,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -153,8 +153,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -190,8 +190,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -228,8 +228,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -266,8 +266,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -304,8 +304,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -342,8 +342,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -379,8 +379,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -418,8 +418,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@@ -455,8 +455,8 @@ public:
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
     vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
-    output.GetField("pointvar").GetData().CopyTo(outPointData);
+    output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
-    output.GetField("cellvar").GetData().CopyTo(outCellData);
+    output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
 
     VTKM_TEST_ASSERT(
       test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),

vtkm/filter/testing/UnitTestFieldToColors.cxx

@@ -40,7 +40,7 @@ void TestFieldToColors()
   VTKM_TEST_ASSERT(rgbaResult.HasPointField("colors"), "Field missing.");
   vtkm::cont::Field Result = rgbaResult.GetPointField("colors");
   vtkm::cont::ArrayHandle<vtkm::Vec4ui_8> resultRGBAHandle;
-  Result.GetData().CopyTo(resultRGBAHandle);
+  Result.GetData().AsArrayHandle(resultRGBAHandle);
 
   //values confirmed with ParaView 5.4
   const vtkm::Vec4ui_8 correct_diverging_rgba_values[nvals] = {
@@ -61,7 +61,7 @@ void TestFieldToColors()
   VTKM_TEST_ASSERT(rgbResult.HasPointField("colors"), "Field missing.");
   Result = rgbResult.GetPointField("colors");
   vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> resultRGBHandle;
-  Result.GetData().CopyTo(resultRGBHandle);
+  Result.GetData().AsArrayHandle(resultRGBHandle);
 
   //values confirmed with ParaView 5.4
   const vtkm::Vec3ui_8 correct_diverging_rgb_values[nvals] = { { 0, 0, 255 },     { 59, 76, 192 },

vtkm/filter/testing/UnitTestGhostCellClassify.cxx

@@ -114,7 +114,7 @@ void TestStructured()
 
         //Check the number of normal cells.
         vtkm::cont::ArrayHandle<vtkm::UInt8> ghostArray;
-        fieldArray.CopyTo(ghostArray);
+        fieldArray.AsArrayHandle(ghostArray);
 
         vtkm::Id numNormalCells = 0;
         auto portal = ghostArray.ReadPortal();

vtkm/filter/testing/UnitTestGradientExplicit.cxx

@@ -32,7 +32,7 @@ void TestCellGradientExplicit()
   VTKM_TEST_ASSERT(result.HasCellField("gradient"), "Result field missing.");
 
   vtkm::cont::ArrayHandle<vtkm::Vec3f_32> resultArrayHandle;
-  result.GetCellField("gradient").GetData().CopyTo(resultArrayHandle);
+  result.GetCellField("gradient").GetData().AsArrayHandle(resultArrayHandle);
   vtkm::Vec3f_32 expected[2] = { { 10.f, 10.1f, 0.0f }, { 10.f, 10.1f, -0.0f } };
   for (int i = 0; i < 2; ++i)
   {
@@ -58,7 +58,7 @@ void TestPointGradientExplicit()
   VTKM_TEST_ASSERT(result.HasPointField("gradient"), "Result field missing.");
 
   vtkm::cont::ArrayHandle<vtkm::Vec3f_32> resultArrayHandle;
-  result.GetPointField("gradient").GetData().CopyTo(resultArrayHandle);
+  result.GetPointField("gradient").GetData().AsArrayHandle(resultArrayHandle);
 
   vtkm::Vec3f_32 expected[2] = { { 10.f, 10.1f, 0.0f }, { 10.f, 10.1f, 0.0f } };
   for (int i = 0; i < 2; ++i)

vtkm/filter/testing/UnitTestGradientUniform.cxx

@@ -81,7 +81,7 @@ void TestCellGradientUniform3DWithVectorField()
                    "vec gradients should generate qcriterion");
 
   vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_64, 3>> resultArrayHandle;
-  result.GetCellField("vec_gradient").GetData().CopyTo(resultArrayHandle);
+  result.GetCellField("vec_gradient").GetData().AsArrayHandle(resultArrayHandle);
   vtkm::Vec<vtkm::Vec3f_64, 3> expected[4] = {
     { { 10.025, 10.025, 10.025 }, { 30.075, 30.075, 30.075 }, { 60.125, 60.125, 60.125 } },
     { { 10.025, 10.025, 10.025 }, { 30.075, 30.075, 30.075 }, { 60.125, 60.125, 60.125 } },
@@ -133,7 +133,7 @@ void TestPointGradientUniform3DWithVectorField()
   VTKM_TEST_ASSERT(result.HasPointField("vec_gradient"), "Result field missing.");
 
   vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_64, 3>> resultArrayHandle;
-  result.GetPointField("vec_gradient").GetData().CopyTo(resultArrayHandle);
+  result.GetPointField("vec_gradient").GetData().AsArrayHandle(resultArrayHandle);
   vtkm::Vec<vtkm::Vec3f_64, 3> expected[4] = {
     { { 10.0, 10.0, 10.0 }, { 30.0, 30.0, 30.0 }, { 60.1, 60.1, 60.1 } },
     { { 10.0, 10.0, 10.0 }, { 30.1, 30.1, 30.1 }, { 60.1, 60.1, 60.1 } },

vtkm/filter/testing/UnitTestHistogramFilter.cxx

@@ -262,7 +262,7 @@ void VerifyHistogram(const vtkm::cont::DataSet& result,
   VTKM_TEST_ASSERT(result.HasField("histogram"), "Output field missing");
 
   vtkm::cont::ArrayHandle<vtkm::Id> bins;
-  result.GetField("histogram").GetData().CopyTo(bins);
+  result.GetField("histogram").GetData().AsArrayHandle(bins);
 
   vtkm::cont::ArrayHandle<vtkm::Id>::ReadPortalType binPortal = bins.ReadPortal();
 

vtkm/filter/testing/UnitTestImageConnectivityFilter.cxx

@@ -46,7 +46,7 @@ void TestImageConnectivity()
 
   auto temp = outputData.GetField("component").GetData();
   vtkm::cont::ArrayHandle<vtkm::Id> resultArrayHandle;
-  temp.CopyTo(resultArrayHandle);
+  temp.AsArrayHandle(resultArrayHandle);
 
   std::vector<vtkm::Id> componentExpected = { 0, 1, 1, 1, 0, 1, 1, 2, 0, 0, 0, 1, 0, 1, 1, 2,
                                               0, 1, 1, 0, 0, 1, 1, 2, 0, 1, 0, 0, 0, 1, 1, 2,

vtkm/filter/testing/UnitTestImageDifferenceFilter.cxx

@@ -45,8 +45,8 @@ void CheckResult(const std::vector<vtkm::Vec4f>& expectedDiff,
 
   vtkm::cont::ArrayHandle<vtkm::Vec4f> outputArray;
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> thresholdArray;
-  output.GetPointField("image-diff").GetData().CopyTo(outputArray);
+  output.GetPointField("image-diff").GetData().AsArrayHandle(outputArray);
-  output.GetPointField("threshold-output").GetData().CopyTo(thresholdArray);
+  output.GetPointField("threshold-output").GetData().AsArrayHandle(thresholdArray);
 
   VTKM_TEST_ASSERT(outputArray.GetNumberOfValues() == static_cast<vtkm::Id>(expectedDiff.size()),
                    "Field sizes wrong");

vtkm/filter/testing/UnitTestImageMedianFilter.cxx

@@ -29,7 +29,7 @@ void TestImageMedian()
 
   VTKM_TEST_ASSERT(result.HasPointField("median"), "Field missing.");
   vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
-  result.GetPointField("median").GetData().CopyTo(resultArrayHandle);
+  result.GetPointField("median").GetData().AsArrayHandle(resultArrayHandle);
 
   auto cells = result.GetCellSet().Cast<vtkm::cont::CellSetStructured<3>>();
   auto pdims = cells.GetPointDimensions();

vtkm/filter/testing/UnitTestLagrangianStructuresFilter.cxx

@@ -343,7 +343,7 @@ void Test2DLCS()
   vtkm::cont::DataSet outputData = lagrangianStructures.Execute(inputData);
 
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> FTLEField;
-  outputData.GetField("FTLE").GetData().CopyTo(FTLEField);
+  outputData.GetField("FTLE").GetData().AsArrayHandle(FTLEField);
   auxiliary::ValidateLCSFilterResult(FTLEField, visitHandle, diffHandle);
 }
 
@@ -387,7 +387,7 @@ void Test3DLCS()
     vtkm::cont::DataSet outputData = lagrangianStructures.Execute(input);
 
     vtkm::cont::ArrayHandle<vtkm::FloatDefault> FTLEField;
-    outputData.GetField("FTLE").GetData().CopyTo(FTLEField);
+    outputData.GetField("FTLE").GetData().AsArrayHandle(FTLEField);
     auxiliary::ValidateLCSFilterResult(FTLEField, visitHandle, diffHandle);
   }
 }

vtkm/filter/testing/UnitTestMapFieldMergeAverage.cxx

@@ -94,7 +94,7 @@ void TryArray(const vtkm::cont::ArrayHandle<T, S>& inputArray)
   VTKM_TEST_ASSERT(outputField.GetName() == "my-array");
 
   vtkm::cont::ArrayHandle<T> outputArray;
-  outputField.GetData().CopyTo(outputArray);
+  outputField.GetData().AsArrayHandle(outputArray);
   std::cout << "Actual output" << std::endl;
   vtkm::cont::printSummary_ArrayHandle(outputArray, std::cout);
 

vtkm/filter/testing/UnitTestMapFieldPermutation.cxx

@@ -57,7 +57,7 @@ void TryArray(const vtkm::cont::ArrayHandle<T, S>& inputArray)
   VTKM_TEST_ASSERT(outputField.GetName() == "my-array");
 
   vtkm::cont::ArrayHandle<T> outputArray;
-  outputField.GetData().CopyTo(outputArray);
+  outputField.GetData().AsArrayHandle(outputArray);
   std::cout << "Actual output" << std::endl;
   vtkm::cont::printSummary_ArrayHandle(outputArray, std::cout);
 

vtkm/filter/testing/UnitTestMaskFilter.cxx

@@ -37,7 +37,7 @@ public:
 
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
-    output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
+    output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
 
     VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 8 &&
                        cellFieldArray.ReadPortal().Get(7) == 14.f,
@@ -58,7 +58,7 @@ public:
     VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 7), "Wrong result for Mask");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
-    output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
+    output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
 
     VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 7 &&
                        cellFieldArray.ReadPortal().Get(2) == 18.f,
@@ -79,7 +79,7 @@ public:
     VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 2), "Wrong result for Mask");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
-    output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
+    output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
 
     VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 2 &&
                        cellFieldArray.ReadPortal().Get(1) == 120.2f,

vtkm/filter/testing/UnitTestMeshQualityFilter.cxx

@@ -123,7 +123,7 @@ bool TestMeshQualityFilter(const vtkm::cont::DataSet& input,
   //Test the computed metric values (for all cells) and expected metric
   //values for equality.
   vtkm::cont::ArrayHandle<vtkm::Float64> values;
-  output.GetField(outputname).GetData().CopyTo(values);
+  output.GetField(outputname).GetData().AsArrayHandle(values);
   auto portal1 = values.ReadPortal();
   if (portal1.GetNumberOfValues() != (vtkm::Id)expectedVals.size())
   {

vtkm/filter/testing/UnitTestNDEntropyFilter.cxx

@@ -189,7 +189,7 @@ void RunTest()
   vtkm::cont::DataSet outputData = ndEntropyFilter.Execute(ds);
 
   vtkm::cont::ArrayHandle<vtkm::Float64> entropyHandle;
-  outputData.GetField("Entropy").GetData().CopyTo(entropyHandle);
+  outputData.GetField("Entropy").GetData().AsArrayHandle(entropyHandle);
   vtkm::Float64 e = entropyHandle.WritePortal().Get(0);
 
   VTKM_TEST_ASSERT(fabs(e - 7.457857) < 0.001,

vtkm/filter/testing/UnitTestNDHistogramFilter.cxx

@@ -95,13 +95,13 @@ void RunTest()
   VTKM_TEST_ASSERT(nonSparseBins == gtNonSparseBins, "Incorrect ND-histogram Filter results");
 
   vtkm::cont::ArrayHandle<vtkm::Id> binId0;
-  outputData.GetField("fieldA").GetData().CopyTo(binId0);
+  outputData.GetField("fieldA").GetData().AsArrayHandle(binId0);
   vtkm::cont::ArrayHandle<vtkm::Id> binId1;
-  outputData.GetField("fieldB").GetData().CopyTo(binId1);
+  outputData.GetField("fieldB").GetData().AsArrayHandle(binId1);
   vtkm::cont::ArrayHandle<vtkm::Id> binId2;
-  outputData.GetField("fieldC").GetData().CopyTo(binId2);
+  outputData.GetField("fieldC").GetData().AsArrayHandle(binId2);
   vtkm::cont::ArrayHandle<vtkm::Id> freqs;
-  outputData.GetField("Frequency").GetData().CopyTo(freqs);
+  outputData.GetField("Frequency").GetData().AsArrayHandle(freqs);
   for (int i = 0; i < nonSparseBins; i++)
   {
     vtkm::Id idx0 = binId0.WritePortal().Get(i);

vtkm/filter/testing/UnitTestPartitionedDataSetFilters.cxx

@@ -89,9 +89,9 @@ void Result_Verify(const vtkm::cont::PartitionedDataSet& result,
                      "result vectors' size incorrect");
 
     vtkm::cont::ArrayHandle<T> partitionArray;
-    result.GetPartition(j).GetField(outputFieldName).GetData().CopyTo(partitionArray);
+    result.GetPartition(j).GetField(outputFieldName).GetData().AsArrayHandle(partitionArray);
     vtkm::cont::ArrayHandle<T> sDataSetArray;
-    partitionResult.GetField(outputFieldName).GetData().CopyTo(sDataSetArray);
+    partitionResult.GetField(outputFieldName).GetData().AsArrayHandle(sDataSetArray);
 
     const vtkm::Id numValues = result.GetPartition(j).GetField(outputFieldName).GetNumberOfValues();
     for (vtkm::Id i = 0; i < numValues; i++)

vtkm/filter/testing/UnitTestPartitionedDataSetHistogramFilter.cxx

@@ -110,7 +110,7 @@ static void TestPartitionedDataSetHistogram()
   auto bins = result.GetPartition(0)
                 .GetField("histogram")
                 .GetData()
-                .Cast<vtkm::cont::ArrayHandle<vtkm::Id>>();
+                .AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
   VTKM_TEST_ASSERT(bins.GetNumberOfValues() == 10, "Expecting 10 bins.");
   auto binsPortal = bins.ReadPortal();
   auto count = std::accumulate(vtkm::cont::ArrayPortalToIteratorBegin(binsPortal),

vtkm/filter/testing/UnitTestPointAverageFilter.cxx

@@ -29,7 +29,7 @@ void TestPointAverageUniform3D()
 
   VTKM_TEST_ASSERT(result.HasPointField("avgvals"), "Field missing.");
   vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
-  result.GetPointField("avgvals").GetData().CopyTo(resultArrayHandle);
+  result.GetPointField("avgvals").GetData().AsArrayHandle(resultArrayHandle);
   vtkm::Float32 expected[18] = { 100.1f, 100.15f, 100.2f, 100.1f, 100.15f, 100.2f,
                                  100.2f, 100.25f, 100.3f, 100.2f, 100.25f, 100.3f,
                                  100.3f, 100.35f, 100.4f, 100.3f, 100.35f, 100.4f };
@@ -55,7 +55,7 @@ void TestPointAverageRegular3D()
   VTKM_TEST_ASSERT(result.HasPointField("cellvar"), "Field missing.");
   vtkm::cont::Field Result = result.GetPointField("cellvar");
   vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
-  Result.GetData().CopyTo(resultArrayHandle);
+  Result.GetData().AsArrayHandle(resultArrayHandle);
 
   vtkm::Float32 expected[18] = { 0.f, 0.5f, 1.f, 0.f, 0.5f, 1.f, 1.f, 1.5f, 2.f,
                                  1.f, 1.5f, 2.f, 2.f, 2.5f, 3.f, 2.f, 2.5f, 3.f };
@@ -80,7 +80,7 @@ void TestPointAverageExplicit1()
   // If no name is given, should have the same name as the input.
   VTKM_TEST_ASSERT(result.HasPointField("cellvar"), "Field missing.");
   vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
-  result.GetPointField("cellvar").GetData().CopyTo(resultArrayHandle);
+  result.GetPointField("cellvar").GetData().AsArrayHandle(resultArrayHandle);
   vtkm::Float32 expected[5] = { 100.1f, 100.15f, 100.15f, 100.2f, 100.2f };
   for (int i = 0; i < 5; ++i)
   {
@@ -103,7 +103,7 @@ void TestPointAverageExplicit2()
   // If no name is given, should have the same name as the input.
   VTKM_TEST_ASSERT(result.HasPointField("cellvar"), "Field missing.");
   vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
-  result.GetPointField("cellvar").GetData().CopyTo(resultArrayHandle);
+  result.GetPointField("cellvar").GetData().AsArrayHandle(resultArrayHandle);
   vtkm::Float32 expected[11] = { 100.1f, 105.05f, 105.05f, 100.1f, 115.3f, 115.2f,
                                  115.2f, 115.3f,  115.1f,  130.5f, 125.35f };
   for (int i = 0; i < 11; ++i)

vtkm/filter/testing/UnitTestPointElevationFilter.cxx

@@ -75,7 +75,7 @@ void TestPointElevationNoPolicy()
   VTKM_TEST_ASSERT(result.HasPointField("height"), "Output field missing.");
 
   vtkm::cont::ArrayHandle<vtkm::Float64> resultArrayHandle;
-  result.GetPointField("height").GetData().CopyTo(resultArrayHandle);
+  result.GetPointField("height").GetData().AsArrayHandle(resultArrayHandle);
   auto coordinates = inputData.GetCoordinateSystem().GetDataAsMultiplexer();
   auto coordsPortal = coordinates.ReadPortal();
   auto resultPortal = resultArrayHandle.ReadPortal();
@@ -106,7 +106,7 @@ void TestPointElevationWithPolicy()
   VTKM_TEST_ASSERT(result.HasPointField("elevation"), "Output field has wrong association");
 
   vtkm::cont::ArrayHandle<vtkm::Float64> resultArrayHandle;
-  result.GetPointField("elevation").GetData().CopyTo(resultArrayHandle);
+  result.GetPointField("elevation").GetData().AsArrayHandle(resultArrayHandle);
   auto coordinates = inputData.GetCoordinateSystem().GetDataAsMultiplexer();
   auto coordsPortal = coordinates.ReadPortal();
   auto resultPortal = resultArrayHandle.ReadPortal();

vtkm/filter/testing/UnitTestPointTransform.cxx

@@ -72,7 +72,7 @@ void ValidatePointTransform(const vtkm::cont::CoordinateSystem& coords,
   vtkm::cont::ArrayHandle<vtkm::Vec3f> resultArrayHandle;
   result.GetField(fieldName, vtkm::cont::Field::Association::POINTS)
     .GetData()
-    .CopyTo(resultArrayHandle);
+    .AsArrayHandle(resultArrayHandle);
 
   auto outPointsArrayHandle = result.GetCoordinateSystem().GetDataAsMultiplexer();
 

vtkm/filter/testing/UnitTestSplitSharpEdgesFilter.cxx

@@ -134,7 +134,7 @@ void TestSplitSharpEdgesFilterSplitEveryEdge(vtkm::cont::DataSet& simpleCubeWith
   auto newCoords = result.GetCoordinateSystem().GetDataAsMultiplexer();
   auto newCoordsP = newCoords.ReadPortal();
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> newPointvarField;
-  result.GetField("pointvar").GetData().CopyTo(newPointvarField);
+  result.GetField("pointvar").GetData().AsArrayHandle(newPointvarField);
 
   for (vtkm::IdComponent i = 0; i < newCoords.GetNumberOfValues(); i++)
   {
@@ -169,7 +169,7 @@ void TestSplitSharpEdgesFilterNoSplit(vtkm::cont::DataSet& simpleCubeWithSN,
     result.GetCellSet().Cast<vtkm::cont::CellSetExplicit<>>();
   auto newCoordsP = newCoords.ReadPortal();
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> newPointvarField;
-  result.GetField("pointvar").GetData().CopyTo(newPointvarField);
+  result.GetField("pointvar").GetData().AsArrayHandle(newPointvarField);
 
   for (vtkm::IdComponent i = 0; i < newCoords.GetNumberOfValues(); i++)
   {

vtkm/filter/testing/UnitTestSurfaceNormalsFilter.cxx

@@ -18,7 +18,7 @@ namespace
 void VerifyCellNormalValues(const vtkm::cont::DataSet& ds)
 {
   vtkm::cont::ArrayHandle<vtkm::Vec3f> normals;
-  ds.GetCellField("Normals").GetData().CopyTo(normals);
+  ds.GetCellField("Normals").GetData().AsArrayHandle(normals);
 
   vtkm::Vec3f expected[8] = { { -0.707f, -0.500f, 0.500f }, { -0.707f, -0.500f, 0.500f },
                               { 0.707f, 0.500f, -0.500f },  { 0.000f, -0.707f, -0.707f },
@@ -37,7 +37,7 @@ void VerifyCellNormalValues(const vtkm::cont::DataSet& ds)
 void VerifyPointNormalValues(const vtkm::cont::DataSet& ds)
 {
   vtkm::cont::ArrayHandle<vtkm::Vec3f> normals;
-  ds.GetPointField("Normals").GetData().CopyTo(normals);
+  ds.GetPointField("Normals").GetData().AsArrayHandle(normals);
 
   vtkm::Vec3f expected[8] = { { -0.8165f, -0.4082f, -0.4082f }, { -0.2357f, -0.9714f, 0.0286f },
                               { 0.0000f, -0.1691f, 0.9856f },   { -0.8660f, 0.0846f, 0.4928f },

vtkm/filter/testing/UnitTestTetrahedralizeFilter.cxx

@@ -35,7 +35,7 @@ public:
                      "Wrong number of points for Tetrahedralize");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outData =
-      output.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
+      output.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
 
     VTKM_TEST_ASSERT(outData.ReadPortal().Get(5) == 100.2f, "Wrong cell field data");
     VTKM_TEST_ASSERT(outData.ReadPortal().Get(6) == 100.2f, "Wrong cell field data");
@@ -58,7 +58,7 @@ public:
                      "Wrong number of points for Tetrahedralize");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outData =
-      output.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
+      output.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
 
     VTKM_TEST_ASSERT(outData.ReadPortal().Get(5) == 110.f, "Wrong cell field data");
     VTKM_TEST_ASSERT(outData.ReadPortal().Get(6) == 110.f, "Wrong cell field data");

vtkm/filter/testing/UnitTestThresholdFilter.cxx

@@ -39,7 +39,7 @@ public:
                      "Wrong number of fields in the output dataset");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
-    output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
+    output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
 
     VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 1 &&
                        cellFieldArray.ReadPortal().Get(0) == 200.1f,
@@ -68,7 +68,7 @@ public:
                      "Wrong number of fields in the output dataset");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
-    output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
+    output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
 
     VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 2 &&
                        cellFieldArray.ReadPortal().Get(0) == 100.1f &&
@@ -98,7 +98,7 @@ public:
                      "Wrong number of fields in the output dataset");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
-    output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
+    output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
 
     VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 2 &&
                        cellFieldArray.ReadPortal().Get(0) == 100.1f &&
@@ -128,7 +128,7 @@ public:
                      "Wrong number of fields in the output dataset");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
-    output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
+    output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
 
     VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 0, "field should be empty");
 

vtkm/filter/testing/UnitTestThresholdPointsFilter.cxx

@@ -38,7 +38,7 @@ public:
 
     vtkm::cont::Field pointField = output.GetField("pointvar");
     vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
-    pointField.GetData().CopyTo(pointFieldArray);
+    pointField.GetData().AsArrayHandle(pointFieldArray);
     VTKM_TEST_ASSERT(pointFieldArray.ReadPortal().Get(12) == 50.0f, "Wrong point field data");
   }
 
@@ -60,7 +60,7 @@ public:
 
     vtkm::cont::Field pointField = output.GetField("pointvar");
     vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
-    pointField.GetData().CopyTo(pointFieldArray);
+    pointField.GetData().AsArrayHandle(pointFieldArray);
     VTKM_TEST_ASSERT(pointFieldArray.ReadPortal().Get(0) == 99.0f, "Wrong point field data");
   }
 
@@ -82,7 +82,7 @@ public:
 
     vtkm::cont::Field pointField = output.GetField("pointvar");
     vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
-    pointField.GetData().CopyTo(pointFieldArray);
+    pointField.GetData().AsArrayHandle(pointFieldArray);
     VTKM_TEST_ASSERT(pointFieldArray.ReadPortal().Get(4) == 10.f, "Wrong point field data");
   }
 

vtkm/filter/testing/UnitTestTriangulateFilter.cxx

@@ -33,7 +33,7 @@ public:
                      "Wrong number of points for Triangulate");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outData =
-      output.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
+      output.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
 
     VTKM_TEST_ASSERT(outData.ReadPortal().Get(2) == 1.f, "Wrong cell field data");
     VTKM_TEST_ASSERT(outData.ReadPortal().Get(3) == 1.f, "Wrong cell field data");
@@ -53,7 +53,7 @@ public:
                      "Wrong number of points for Triangulate");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> outData =
-      output.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
+      output.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
 
     VTKM_TEST_ASSERT(outData.ReadPortal().Get(1) == 1.f, "Wrong cell field data");
     VTKM_TEST_ASSERT(outData.ReadPortal().Get(2) == 1.f, "Wrong cell field data");

vtkm/filter/testing/UnitTestTubeFilter.cxx

@@ -82,8 +82,8 @@ void TestTubeFilters()
   VTKM_TEST_ASSERT(dcells.GetNumberOfCells() == 36, "Wrong number of cells");
 
   //Validate the point field
-  auto ptArr =
+  vtkm::cont::ArrayHandle<vtkm::FloatDefault> ptArr;
-    output.GetField("pointVar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::FloatDefault>>();
+  output.GetField("pointVar").GetData().AsArrayHandle(ptArr);
   VTKM_TEST_ASSERT(ptArr.GetNumberOfValues() == 22, "Wrong number of values in point field");
 
   std::vector<vtkm::FloatDefault> ptVals = { 0,  0,  0,  0,  1,  1,  1,  2,  2,  2,  2,
@@ -95,8 +95,8 @@ void TestTubeFilters()
 
 
   //Validate the cell field
-  auto cellArr =
+  vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellArr;
-    output.GetField("cellVar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::FloatDefault>>();
+  output.GetField("cellVar").GetData().AsArrayHandle(cellArr);
   VTKM_TEST_ASSERT(cellArr.GetNumberOfValues() == 36, "Wrong number of values in cell field");
   std::vector<vtkm::FloatDefault> cellVals = { 100, 100, 100, 100, 100, 100, 101, 101, 101,
                                                101, 101, 101, 100, 100, 100, 101, 101, 101,

vtkm/filter/testing/UnitTestVectorMagnitudeFilter.cxx

@@ -45,7 +45,7 @@ void TestVectorMagnitude()
   VTKM_TEST_ASSERT(result.HasPointField("magnitude"), "Output field missing.");
 
   vtkm::cont::ArrayHandle<vtkm::Float64> resultArrayHandle;
-  result.GetPointField("magnitude").GetData().CopyTo(resultArrayHandle);
+  result.GetPointField("magnitude").GetData().AsArrayHandle(resultArrayHandle);
   for (vtkm::Id i = 0; i < resultArrayHandle.GetNumberOfValues(); ++i)
   {
     VTKM_TEST_ASSERT(

vtkm/filter/testing/UnitTestVertexClusteringFilter.cxx

@@ -33,8 +33,9 @@ void TestVertexClustering()
                    "Number of output coordinate systems mismatch");
 
   using FieldArrayType = vtkm::cont::ArrayHandle<vtkm::Float32>;
-  FieldArrayType pointvar = output.GetPointField("pointvar").GetData().Cast<FieldArrayType>();
+  FieldArrayType pointvar =
-  FieldArrayType cellvar = output.GetCellField("cellvar").GetData().Cast<FieldArrayType>();
+    output.GetPointField("pointvar").GetData().AsArrayHandle<FieldArrayType>();
+  FieldArrayType cellvar = output.GetCellField("cellvar").GetData().AsArrayHandle<FieldArrayType>();
 
   // test
   const vtkm::Id output_points = 7;

vtkm/filter/testing/UnitTestWarpScalarFilter.cxx

@@ -59,11 +59,11 @@ void CheckResult(const vtkm::filter::WarpScalar& filter, const vtkm::cont::DataS
   VTKM_TEST_ASSERT(result.HasPointField("warpscalar"), "Output filed warpscalar is missing");
   using vecType = vtkm::Vec3f;
   vtkm::cont::ArrayHandle<vecType> outputArray;
-  result.GetPointField("warpscalar").GetData().CopyTo(outputArray);
+  result.GetPointField("warpscalar").GetData().AsArrayHandle(outputArray);
   auto outPortal = outputArray.ReadPortal();
 
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> sfArray;
-  result.GetPointField("scalarfactor").GetData().CopyTo(sfArray);
+  result.GetPointField("scalarfactor").GetData().AsArrayHandle(sfArray);
   auto sfPortal = sfArray.ReadPortal();
 
   for (vtkm::Id j = 0; j < dim; ++j)

vtkm/filter/testing/UnitTestWarpVectorFilter.cxx

@@ -56,7 +56,7 @@ void CheckResult(const vtkm::filter::WarpVector& filter, const vtkm::cont::DataS
   VTKM_TEST_ASSERT(result.HasPointField("warpvector"), "Output filed WarpVector is missing");
   using vecType = vtkm::Vec3f;
   vtkm::cont::ArrayHandle<vecType> outputArray;
-  result.GetPointField("warpvector").GetData().CopyTo(outputArray);
+  result.GetPointField("warpvector").GetData().AsArrayHandle(outputArray);
   auto outPortal = outputArray.ReadPortal();
 
   for (vtkm::Id j = 0; j < dim; ++j)

vtkm/filter/testing/UnitTestZFP.cxx

@@ -30,8 +30,8 @@ void TestZFP1DFilter(vtkm::Float64 rate)
   vtkm::cont::testing::MakeTestDataSet testDataSet;
   vtkm::cont::DataSet dataset = testDataSet.Make1DUniformDataSet2();
   auto dynField = dataset.GetField("pointvar").GetData();
-  vtkm::cont::ArrayHandle<vtkm::Float64> field =
+  vtkm::cont::ArrayHandle<vtkm::Float64> field;
-    dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
+  dynField.AsArrayHandle(field);
   auto oport = field.ReadPortal();
 
   vtkm::filter::ZFPCompressor1D compressor;
@@ -46,7 +46,7 @@ void TestZFP1DFilter(vtkm::Float64 rate)
   auto decompress = decompressor.Execute(compressed);
   dynField = decompress.GetField("decompressed").GetData();
 
-  field = dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
+  dynField.AsArrayHandle(field);
   auto port = field.ReadPortal();
 
   for (int i = 0; i < field.GetNumberOfValues(); i++)
@@ -61,8 +61,8 @@ void TestZFP2DFilter(vtkm::Float64 rate)
   vtkm::cont::DataSet dataset = testDataSet.Make2DUniformDataSet2();
   auto dynField = dataset.GetField("pointvar").GetData();
 
-  vtkm::cont::ArrayHandle<vtkm::Float64> field =
+  vtkm::cont::ArrayHandle<vtkm::Float64> field;
-    dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
+  dynField.AsArrayHandle(field);
   auto oport = field.ReadPortal();
 
 
@@ -80,7 +80,7 @@ void TestZFP2DFilter(vtkm::Float64 rate)
   auto decompress = decompressor.Execute(compressed);
   dynField = decompress.GetField("decompressed").GetData();
 
-  field = dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
+  dynField.AsArrayHandle(field);
   auto port = field.ReadPortal();
 
   for (int i = 0; i < dynField.GetNumberOfValues(); i++)
@@ -95,8 +95,8 @@ void TestZFP3DFilter(vtkm::Float64 rate)
   vtkm::cont::testing::MakeTestDataSet testDataSet;
   vtkm::cont::DataSet dataset = testDataSet.Make3DUniformDataSet3(dims);
   auto dynField = dataset.GetField("pointvar").GetData();
-  vtkm::cont::ArrayHandle<vtkm::Float64> field =
+  vtkm::cont::ArrayHandle<vtkm::Float64> field;
-    dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
+  dynField.AsArrayHandle(field);
   auto oport = field.ReadPortal();
 
 
@@ -112,7 +112,7 @@ void TestZFP3DFilter(vtkm::Float64 rate)
   auto decompress = decompressor.Execute(compressed);
   dynField = decompress.GetField("decompressed").GetData();
 
-  field = dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
+  dynField.AsArrayHandle(field);
   auto port = field.ReadPortal();
 
   for (int i = 0; i < dynField.GetNumberOfValues(); i++)

vtkm/io/ImageWriterBase.cxx

@@ -75,7 +75,7 @@ void ImageWriterBase::WriteDataSet(const vtkm::cont::DataSet& dataSet,
     }
   }
 
-  this->Write(width, height, colorField.GetData().Cast<ColorArrayType>());
+  this->Write(width, height, colorField.GetData().AsArrayHandle<ColorArrayType>());
 }
 }
 } // namespace vtkm::io

vtkm/io/VTKDataSetWriter.cxx

@@ -337,17 +337,17 @@ void WriteDataSetAsStructured(std::ostream& out,
   {
     // uniform is written as "structured points"
     WriteDataSetAsStructuredPoints(
-      out, coordSystem.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>(), cellSet);
+      out, coordSystem.AsArrayHandle<vtkm::cont::ArrayHandleUniformPointCoordinates>(), cellSet);
   }
   else if (coordSystem.IsType<ArrayHandleRectilinearCoordinates<vtkm::Float32>>())
   {
     WriteDataSetAsRectilinearGrid(
-      out, coordSystem.Cast<ArrayHandleRectilinearCoordinates<vtkm::Float32>>(), cellSet);
+      out, coordSystem.AsArrayHandle<ArrayHandleRectilinearCoordinates<vtkm::Float32>>(), cellSet);
   }
   else if (coordSystem.IsType<ArrayHandleRectilinearCoordinates<vtkm::Float64>>())
   {
     WriteDataSetAsRectilinearGrid(
-      out, coordSystem.Cast<ArrayHandleRectilinearCoordinates<vtkm::Float64>>(), cellSet);
+      out, coordSystem.AsArrayHandle<ArrayHandleRectilinearCoordinates<vtkm::Float64>>(), cellSet);
   }
   else
   {

vtkm/io/testing/UnitTestHDF5Image.cxx

@@ -32,8 +32,9 @@ void TestFilledImage(vtkm::cont::DataSet& dataSet,
                    "wrong image dimensions");
   VTKM_TEST_ASSERT(pointField.GetData().template IsType<vtkm::cont::ArrayHandle<vtkm::Vec4f_32>>(),
                    "wrong ArrayHandle type");
-  auto pixelPortal =
+  vtkm::cont::ArrayHandle<vtkm::Vec4f_32> pixelArray;
-    pointField.GetData().template Cast<vtkm::cont::ArrayHandle<vtkm::Vec4f_32>>().ReadPortal();
+  pointField.GetData().AsArrayHandle(pixelArray);
+  auto pixelPortal = pixelArray.ReadPortal();
 
   auto colorPortal = canvas.GetColorBuffer().ReadPortal();
 

vtkm/io/testing/UnitTestImageWriter.cxx

@@ -36,8 +36,9 @@ void TestFilledImage(vtkm::cont::DataSet& dataSet,
                    "wrong image dimensions");
   VTKM_TEST_ASSERT(pointField.GetData().template IsType<vtkm::cont::ArrayHandle<vtkm::Vec4f_32>>(),
                    "wrong ArrayHandle type");
-  auto pixelPortal =
+  auto pixelPortal = pointField.GetData()
-    pointField.GetData().template Cast<vtkm::cont::ArrayHandle<vtkm::Vec4f_32>>().ReadPortal();
+                       .template AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Vec4f_32>>()
+                       .ReadPortal();
 
   auto colorPortal = canvas.GetColorBuffer().ReadPortal();
 

vtkm/io/testing/UnitTestVTKDataSetWriter.cxx

@@ -30,7 +30,7 @@ struct CheckSameField
                   const vtkm::cont::Field& fileField) const
   {
     vtkm::cont::ArrayHandle<T> fileArray;
-    fileField.GetData().CopyTo(fileArray);
+    fileField.GetData().AsArrayHandle(fileArray);
     VTKM_TEST_ASSERT(test_equal_portals(originalArray.ReadPortal(), fileArray.ReadPortal()));
   }
 };
@@ -67,7 +67,7 @@ struct CheckSameCoordinateSystem
   {
     VTKM_TEST_ASSERT(fileCoords.GetData().IsType<vtkm::cont::ArrayHandleUniformPointCoordinates>());
     vtkm::cont::ArrayHandleUniformPointCoordinates fileArray =
-      fileCoords.GetData().Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
+      fileCoords.GetData().AsArrayHandle<vtkm::cont::ArrayHandleUniformPointCoordinates>();
     auto originalPortal = originalArray.ReadPortal();
     auto filePortal = fileArray.ReadPortal();
     VTKM_TEST_ASSERT(test_equal(originalPortal.GetOrigin(), filePortal.GetOrigin()));
@@ -87,7 +87,7 @@ struct CheckSameCoordinateSystem
   {
     VTKM_TEST_ASSERT(fileCoords.GetData().IsType<ArrayHandleRectilinearCoords<T>>());
     ArrayHandleRectilinearCoords<T> fileArray =
-      fileCoords.GetData().Cast<ArrayHandleRectilinearCoords<T>>();
+      fileCoords.GetData().AsArrayHandle<ArrayHandleRectilinearCoords<T>>();
     auto originalPortal = originalArray.ReadPortal();
     auto filePortal = fileArray.ReadPortal();
     VTKM_TEST_ASSERT(

vtkm/source/testing/UnitTestTangleSource.cxx

@@ -44,7 +44,7 @@ void TangleSourceTest()
     auto field = ds.GetCellField("cellvar");
     auto dynData = field.GetData();
     VTKM_TEST_ASSERT(dynData.IsType<ScalarHandleType>(), "Invalid scalar handle type.");
-    ScalarHandleType handle = dynData.Cast<ScalarHandleType>();
+    ScalarHandleType handle = dynData.AsArrayHandle<ScalarHandleType>();
     auto data = handle.ReadPortal();
 
     VTKM_TEST_ASSERT(test_equal(data.GetNumberOfValues(), 8000), "Incorrect number of elements.");
@@ -62,7 +62,7 @@ void TangleSourceTest()
     auto field = ds.GetPointField("nodevar");
     auto dynData = field.GetData();
     VTKM_TEST_ASSERT(dynData.IsType<ScalarHandleType>(), "Invalid scalar handle type.");
-    ScalarHandleType handle = dynData.Cast<ScalarHandleType>();
+    ScalarHandleType handle = dynData.AsArrayHandle<ScalarHandleType>();
     auto data = handle.ReadPortal();
 
     VTKM_TEST_ASSERT(test_equal(data.GetNumberOfValues(), 9261), "Incorrect number of scalars.");

vtkm/source/testing/UnitTestWaveletSource.cxx

@@ -44,7 +44,7 @@ void WaveletSourceTest()
     auto field = ds.GetPointField("scalars");
     auto dynData = field.GetData();
     VTKM_TEST_ASSERT(dynData.IsType<ScalarHandleType>(), "Invalid scalar handle type.");
-    ScalarHandleType handle = dynData.Cast<ScalarHandleType>();
+    ScalarHandleType handle = dynData.AsArrayHandle<ScalarHandleType>();
     auto data = handle.ReadPortal();
 
     VTKM_TEST_ASSERT(test_equal(data.GetNumberOfValues(), 9261), "Incorrect number of scalars.");

vtkm/worklet/ExternalFaces.h

@@ -712,7 +712,7 @@ public:
     auto coordData = coord.GetData();
     if (coordData.IsType<CartesianArrayHandle>())
     {
-      const auto vertices = coordData.Cast<CartesianArrayHandle>();
+      const auto vertices = coordData.AsArrayHandle<CartesianArrayHandle>();
       const auto vertsSize = vertices.GetNumberOfValues();
       const auto tmp = vtkm::cont::ArrayGetValues({ 0, vertsSize - 1 }, vertices);
       MinPoint = tmp[0];
@@ -720,7 +720,7 @@ public:
     }
     else
     {
-      auto vertices = coordData.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
+      auto vertices = coordData.AsArrayHandle<vtkm::cont::ArrayHandleUniformPointCoordinates>();
       auto Coordinates = vertices.ReadPortal();
 
       MinPoint = Coordinates.GetOrigin();

vtkm/worklet/NDimsHistogram.h

@@ -58,8 +58,8 @@ public:
     }
     else
     {
-      CastAndCall(
+      vtkm::cont::CastAndCall(
-        fieldArray.ResetTypes(vtkm::TypeListScalarAll()),
+        fieldArray.ResetTypes(vtkm::TypeListScalarAll{}, VTKM_DEFAULT_STORAGE_LIST{}),
         vtkm::worklet::histogram::ComputeBins(Bin1DIndex, numberOfBins, rangeOfValues, binDelta));
     }
   }

vtkm/worklet/PointMerge.h

@@ -430,7 +430,7 @@ public:
     vtkm::cont::ArrayHandle<vtkm::Vec3f> concretePoints;
     if (points.template IsType<decltype(concretePoints)>())
     {
-      concretePoints = points.template Cast<decltype(concretePoints)>();
+      points.AsArrayHandle(concretePoints);
     }
     else
     {

vtkm/worklet/StreamLineUniformGrid.h

@@ -331,7 +331,7 @@ public:
     vtkm::Id3 vdims = inCellSet.GetSchedulingRange(vtkm::TopologyElementTagPoint());
 
     vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> fieldArray;
-    InDataSet.GetField("vecData").GetData().CopyTo(fieldArray);
+    InDataSet.GetField("vecData").GetData().AsArrayHandle(fieldArray);
 
     // Generate random seeds for starting streamlines
     vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> seedPosArray;

vtkm/worklet/StreamSurface.h

@@ -257,7 +257,7 @@ public:
     vtkm::cont::Algorithm::ScanExclusive(triangleConnCount, triangleConnOffset);
 
     //Surface points are same as input points.
-    newPoints = coords.GetData().Cast<ExplCoordsType>();
+    newPoints = coords.GetData().AsArrayHandle<ExplCoordsType>();
 
     //Create surface triangles
     vtkm::Id numConnIds = vtkm::cont::Algorithm::Reduce(triangleConnCount, vtkm::Id(0));

vtkm/worklet/contourtree_distributed/TreeCompiler.h

@@ -232,27 +232,32 @@ inline void TreeCompiler::AddHierarchicalTree(const vtkm::cont::DataSet& addedTr
   std::vector<vtkm::Id> regularNodeGlobalIds(regularNodeGlobalIds_array.GetNumberOfValues());
   auto regularNodeGlobalIds_handle =
     vtkm::cont::make_ArrayHandle(regularNodeGlobalIds, vtkm::CopyFlag::Off);
-  vtkm::cont::ArrayCopy(regularNodeGlobalIds_array.ResetTypes(vtkm::List<vtkm::Id>{}),
+  vtkm::cont::ArrayCopy(
-                        regularNodeGlobalIds_handle);
+    regularNodeGlobalIds_array.ResetTypes<vtkm::TypeListId, VTKM_DEFAULT_STORAGE_LIST>(),
+    regularNodeGlobalIds_handle);
   regularNodeGlobalIds_handle
     .SyncControlArray(); //Forces values to get updated if copy happened on GPU
 
   auto superarcs_array = addedTree.GetField("Superarcs").GetData();
   std::vector<vtkm::Id> added_tree_superarcs(superarcs_array.GetNumberOfValues());
   auto superarcs_handle = vtkm::cont::make_ArrayHandle(added_tree_superarcs, vtkm::CopyFlag::Off);
-  vtkm::cont::ArrayCopy(superarcs_array.ResetTypes(vtkm::List<vtkm::Id>{}), superarcs_handle);
+  vtkm::cont::ArrayCopy(superarcs_array.ResetTypes<vtkm::TypeListId, VTKM_DEFAULT_STORAGE_LIST>(),
+                        superarcs_handle);
   superarcs_handle.SyncControlArray(); //Forces values to get updated if copy happened on GPU
 
   auto supernodes_array = addedTree.GetField("Supernodes").GetData();
   std::vector<vtkm::Id> added_tree_supernodes(supernodes_array.GetNumberOfValues());
   auto supernodes_handle = vtkm::cont::make_ArrayHandle(added_tree_supernodes, vtkm::CopyFlag::Off);
-  vtkm::cont::ArrayCopy(supernodes_array.ResetTypes(vtkm::List<vtkm::Id>{}), supernodes_handle);
+  vtkm::cont::ArrayCopy(supernodes_array.ResetTypes<vtkm::TypeListId, VTKM_DEFAULT_STORAGE_LIST>(),
+                        supernodes_handle);
   supernodes_handle.SyncControlArray(); //Forces values to get updated if copy happened on GPU
 
   auto superparents_array = addedTree.GetField("Superparents").GetData();
   std::vector<vtkm::Id> superparents(superparents_array.GetNumberOfValues());
   auto superparents_handle = vtkm::cont::make_ArrayHandle(superparents, vtkm::CopyFlag::Off);
-  vtkm::cont::ArrayCopy(superparents_array.ResetTypes(vtkm::List<vtkm::Id>{}), superparents_handle);
+  vtkm::cont::ArrayCopy(
+    superparents_array.ResetTypes<vtkm::TypeListId, VTKM_DEFAULT_STORAGE_LIST>(),
+    superparents_handle);
   superparents_handle.SyncControlArray(); //Forces values to get updated if copy happened on GPU
 
   // loop through all of the supernodes in the hierarchical tree

vtkm/worklet/particleadvection/GridEvaluators.h

@@ -181,7 +181,7 @@ public:
     {
       auto arr = dataSet.GetCellField("vtkmGhostCells").GetData();
       if (arr.IsType<GhostCellArrayType>())
-        this->GhostCellArray = arr.Cast<GhostCellArrayType>();
+        this->GhostCellArray = arr.AsArrayHandle<GhostCellArrayType>();
       else
         throw vtkm::cont::ErrorInternal("vtkmGhostCells not of type vtkm::UInt8");
     }

vtkm/worklet/testing/UnitTestCellGradient.cxx

@@ -26,7 +26,7 @@ void TestCellGradientUniform2D()
   vtkm::cont::ArrayHandle<vtkm::Float32> input;
   vtkm::cont::ArrayHandle<vtkm::Vec3f_32> result;
 
-  dataSet.GetField("pointvar").GetData().CopyTo(input);
+  dataSet.GetField("pointvar").GetData().AsArrayHandle(input);
 
   vtkm::worklet::CellGradient gradient;
   result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), input);
@@ -49,7 +49,7 @@ void TestCellGradientUniform3D()
   vtkm::cont::ArrayHandle<vtkm::Float32> input;
   vtkm::cont::ArrayHandle<vtkm::Vec3f_32> result;
 
-  dataSet.GetField("pointvar").GetData().CopyTo(input);
+  dataSet.GetField("pointvar").GetData().AsArrayHandle(input);
 
   vtkm::worklet::CellGradient gradient;
   result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), input);
@@ -218,7 +218,7 @@ void TestCellGradientExplicit()
 
   vtkm::cont::ArrayHandle<vtkm::Float32> input;
   vtkm::cont::ArrayHandle<vtkm::Vec3f_32> result;
-  dataSet.GetField("pointvar").GetData().CopyTo(input);
+  dataSet.GetField("pointvar").GetData().AsArrayHandle(input);
 
   vtkm::worklet::CellGradient gradient;
   result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), input);

vtkm/worklet/testing/UnitTestClipping.cxx

@@ -116,7 +116,8 @@ void TestClippingExplicit()
   bool invertClip = false;
   vtkm::cont::CellSetExplicit<> outputCellSet =
     clip.Run(ds.GetCellSet(),
-             ds.GetField("scalars").GetData().ResetTypes(vtkm::TypeListFieldScalar()),
+             ds.GetField("scalars").GetData().ResetTypes(vtkm::TypeListFieldScalar{},
+                                                         VTKM_DEFAULT_STORAGE_LIST{}),
              clipValue,
              invertClip);
 
@@ -124,11 +125,11 @@ void TestClippingExplicit()
   vtkm::cont::ArrayHandle<Coord3D> coords = clip.ProcessPointField(coordsIn);
 
   vtkm::cont::ArrayHandle<vtkm::Float32> scalarsIn;
-  ds.GetField("scalars").GetData().CopyTo(scalarsIn);
+  ds.GetField("scalars").GetData().AsArrayHandle(scalarsIn);
   vtkm::cont::ArrayHandle<vtkm::Float32> scalars = clip.ProcessPointField(scalarsIn);
 
   vtkm::cont::ArrayHandle<vtkm::Float32> cellvarIn;
-  ds.GetField("cellvar").GetData().CopyTo(cellvarIn);
+  ds.GetField("cellvar").GetData().AsArrayHandle(cellvarIn);
   vtkm::cont::ArrayHandle<vtkm::Float32> cellvar = clip.ProcessCellField(cellvarIn);
 
   vtkm::Id connectivitySize = 8;
@@ -172,7 +173,8 @@ void TestClippingStructured()
   vtkm::worklet::Clip clip;
   vtkm::cont::CellSetExplicit<> outputCellSet =
     clip.Run(ds.GetCellSet(),
-             ds.GetField("scalars").GetData().ResetTypes(vtkm::TypeListFieldScalar()),
+             ds.GetField("scalars").GetData().ResetTypes(vtkm::TypeListFieldScalar{},
+                                                         VTKM_DEFAULT_STORAGE_LIST{}),
              clipValue,
              invertClip);
 
@@ -180,11 +182,11 @@ void TestClippingStructured()
   CoordsOutType coords = clip.ProcessPointField(coordsIn);
 
   vtkm::cont::ArrayHandle<vtkm::Float32> scalarsIn;
-  ds.GetField("scalars").GetData().CopyTo(scalarsIn);
+  ds.GetField("scalars").GetData().AsArrayHandle(scalarsIn);
   vtkm::cont::ArrayHandle<vtkm::Float32> scalars = clip.ProcessPointField(scalarsIn);
 
   vtkm::cont::ArrayHandle<vtkm::Float32> cellvarIn;
-  ds.GetField("cellvar").GetData().CopyTo(cellvarIn);
+  ds.GetField("cellvar").GetData().AsArrayHandle(cellvarIn);
   vtkm::cont::ArrayHandle<vtkm::Float32> cellvar = clip.ProcessCellField(cellvarIn);
 
 
@@ -242,11 +244,11 @@ void TestClippingWithImplicitFunction()
   vtkm::cont::ArrayHandle<Coord3D> coords = clip.ProcessPointField(coordsIn);
 
   vtkm::cont::ArrayHandle<vtkm::Float32> scalarsIn;
-  ds.GetField("scalars").GetData().CopyTo(scalarsIn);
+  ds.GetField("scalars").GetData().AsArrayHandle(scalarsIn);
   vtkm::cont::ArrayHandle<vtkm::Float32> scalars = clip.ProcessPointField(scalarsIn);
 
   vtkm::cont::ArrayHandle<vtkm::Float32> cellvarIn;
-  ds.GetField("cellvar").GetData().CopyTo(cellvarIn);
+  ds.GetField("cellvar").GetData().AsArrayHandle(cellvarIn);
   vtkm::cont::ArrayHandle<vtkm::Float32> cellvar = clip.ProcessCellField(cellvarIn);
 
   vtkm::Id connectivitySize = 28;
@@ -301,11 +303,11 @@ void TestClippingWithImplicitFunctionInverted()
   vtkm::cont::ArrayHandle<Coord3D> coords = clip.ProcessPointField(coordsIn);
 
   vtkm::cont::ArrayHandle<vtkm::Float32> scalarsIn;
-  ds.GetField("scalars").GetData().CopyTo(scalarsIn);
+  ds.GetField("scalars").GetData().AsArrayHandle(scalarsIn);
   vtkm::cont::ArrayHandle<vtkm::Float32> scalars = clip.ProcessPointField(scalarsIn);
 
   vtkm::cont::ArrayHandle<vtkm::Float32> cellvarIn;
-  ds.GetField("cellvar").GetData().CopyTo(cellvarIn);
+  ds.GetField("cellvar").GetData().AsArrayHandle(cellvarIn);
   vtkm::cont::ArrayHandle<vtkm::Float32> cellvar = clip.ProcessCellField(cellvarIn);
 
   vtkm::Id connectivitySize = 12;

vtkm/worklet/testing/UnitTestContour.cxx

@@ -192,9 +192,9 @@ void TestContourUniformGrid()
   vtkm::cont::CellSetStructured<3> cellSet;
   dataSet.GetCellSet().CopyTo(cellSet);
   vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
-  dataSet.GetField("nodevar").GetData().CopyTo(pointFieldArray);
+  dataSet.GetField("nodevar").GetData().AsArrayHandle(pointFieldArray);
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellFieldArray;
-  dataSet.GetField("cellvar").GetData().CopyTo(cellFieldArray);
+  dataSet.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
 
   vtkm::worklet::Contour contour;
   contour.SetMergeDuplicatePoints(false);
@@ -311,7 +311,7 @@ void TestContourExplicit()
 
   vtkm::cont::Field contourField = dataSet.GetField("distanceToOrigin");
   DataSetGenerator::DataArrayHandle contourArray;
-  contourField.GetData().CopyTo(contourArray);
+  contourField.GetData().AsArrayHandle(contourArray);
   Vec3Handle vertices;
   Vec3Handle normals;
 
@@ -326,12 +326,12 @@ void TestContourExplicit()
   vtkm::cont::Field projectedField = dataSet.GetField("distanceToOther");
 
   DataSetGenerator::DataArrayHandle projectedArray;
-  projectedField.GetData().CopyTo(projectedArray);
+  projectedField.GetData().AsArrayHandle(projectedArray);
 
   scalars = Contour.ProcessPointField(projectedArray);
 
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellFieldArray;
-  dataSet.GetField("cellvar").GetData().CopyTo(cellFieldArray);
+  dataSet.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
 
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellFieldArrayOut;
   cellFieldArrayOut = Contour.ProcessCellField(cellFieldArray);
@@ -372,9 +372,9 @@ void TestContourClipped()
   vtkm::cont::CellSetExplicit<> cellSet;
   clipped.GetCellSet().CopyTo(cellSet);
   vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
-  clipped.GetField("nodevar").GetData().CopyTo(pointFieldArray);
+  clipped.GetField("nodevar").GetData().AsArrayHandle(pointFieldArray);
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellFieldArray;
-  clipped.GetField("cellvar").GetData().CopyTo(cellFieldArray);
+  clipped.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
 
   std::vector<vtkm::Float32> contourValue{ 0.5f };
   vtkm::cont::ArrayHandle<vtkm::Vec3f_32> verticesArray;

vtkm/worklet/testing/UnitTestContourTreeUniform.cxx

@@ -85,7 +85,7 @@ public:
     vtkm::Id nCols = pointDimensions[1];
 
     vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
-    dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
+    dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
 
     // Output saddle peak pairs array
     vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
@@ -132,7 +132,7 @@ public:
     vtkm::Id nSlices = pointDimensions[2];
 
     vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
-    dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
+    dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
 
     // Output saddle peak pairs array
     vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;

vtkm/worklet/testing/UnitTestContourTreeUniformAugmented.cxx

@@ -376,7 +376,7 @@ private:
     vtkm::Id3 pointDimensions = cellSet.GetPointDimensions();
 
     vtkm::cont::ArrayHandle<vtkm::Float32> field;
-    dataSet.GetField("pointvar").GetData().CopyTo(field);
+    dataSet.GetField("pointvar").GetData().AsArrayHandle(field);
 
     // Run the specific test
     CallTestContourTreeAugmentedSteps(
@@ -725,7 +725,7 @@ public:
     vtkm::Id3 meshSize{ pointDimensions2D[0], pointDimensions2D[1], 1 };
 
     vtkm::cont::ArrayHandle<vtkm::Float32> field;
-    dataSet.GetField("pointvar").GetData().CopyTo(field);
+    dataSet.GetField("pointvar").GetData().AsArrayHandle(field);
 
     // Create the worklet and run it
     vtkm::worklet::ContourTreeAugmented contourTreeWorklet;
@@ -791,7 +791,7 @@ public:
     vtkm::Id3 pointDimensions = cellSet.GetPointDimensions();
 
     vtkm::cont::ArrayHandle<vtkm::Float32> field;
-    dataSet.GetField("pointvar").GetData().CopyTo(field);
+    dataSet.GetField("pointvar").GetData().AsArrayHandle(field);
 
     // Create the worklet and run it
     vtkm::worklet::ContourTreeAugmented contourTreeWorklet;
@@ -864,7 +864,7 @@ public:
     vtkm::Id3 pointDimensions = cellSet.GetPointDimensions();
 
     vtkm::cont::ArrayHandle<vtkm::Float32> field;
-    dataSet.GetField("pointvar").GetData().CopyTo(field);
+    dataSet.GetField("pointvar").GetData().AsArrayHandle(field);
 
     // Create the worklet and run it
     vtkm::worklet::ContourTreeAugmented contourTreeWorklet;

vtkm/worklet/testing/UnitTestCosmoTools.cxx

@@ -195,11 +195,11 @@ void TestCosmo_2DHaloFind()
   vtkm::cont::ArrayHandle<vtkm::Id> haloIdArray;
   vtkm::cont::ArrayHandle<vtkm::Id> mbpArray;
 
-  dataSet.GetField("xLocation").GetData().CopyTo(xLocArray);
+  dataSet.GetField("xLocation").GetData().AsArrayHandle(xLocArray);
-  dataSet.GetField("yLocation").GetData().CopyTo(yLocArray);
+  dataSet.GetField("yLocation").GetData().AsArrayHandle(yLocArray);
-  dataSet.GetField("zLocation").GetData().CopyTo(zLocArray);
+  dataSet.GetField("zLocation").GetData().AsArrayHandle(zLocArray);
-  dataSet.GetField("haloId").GetData().CopyTo(haloIdArray);
+  dataSet.GetField("haloId").GetData().AsArrayHandle(haloIdArray);
-  dataSet.GetField("mbp").GetData().CopyTo(mbpArray);
+  dataSet.GetField("mbp").GetData().AsArrayHandle(mbpArray);
 
   // Output haloId, MBP, potential per particle
   vtkm::cont::ArrayHandle<vtkm::Id> resultHaloId;
@@ -247,11 +247,11 @@ void TestCosmo_3DHaloFind()
   vtkm::cont::ArrayHandle<vtkm::Id> haloIdArray;
   vtkm::cont::ArrayHandle<vtkm::Id> mbpArray;
 
-  dataSet.GetField("xLocation").GetData().CopyTo(xLocArray);
+  dataSet.GetField("xLocation").GetData().AsArrayHandle(xLocArray);
-  dataSet.GetField("yLocation").GetData().CopyTo(yLocArray);
+  dataSet.GetField("yLocation").GetData().AsArrayHandle(yLocArray);
-  dataSet.GetField("zLocation").GetData().CopyTo(zLocArray);
+  dataSet.GetField("zLocation").GetData().AsArrayHandle(zLocArray);
-  dataSet.GetField("haloId").GetData().CopyTo(haloIdArray);
+  dataSet.GetField("haloId").GetData().AsArrayHandle(haloIdArray);
-  dataSet.GetField("mbp").GetData().CopyTo(mbpArray);
+  dataSet.GetField("mbp").GetData().AsArrayHandle(mbpArray);
 
   // Output haloId, MBP, potential per particle
   vtkm::cont::ArrayHandle<vtkm::Id> resultHaloId;
@@ -297,9 +297,9 @@ void TestCosmo_3DCenterFind()
   vtkm::cont::ArrayHandle<vtkm::Float32> yLocArray;
   vtkm::cont::ArrayHandle<vtkm::Float32> zLocArray;
   vtkm::cont::ArrayHandle<vtkm::Id> haloIdArray;
-  dataSet.GetField("xLocation").GetData().CopyTo(xLocArray);
+  dataSet.GetField("xLocation").GetData().AsArrayHandle(xLocArray);
-  dataSet.GetField("yLocation").GetData().CopyTo(yLocArray);
+  dataSet.GetField("yLocation").GetData().AsArrayHandle(yLocArray);
-  dataSet.GetField("zLocation").GetData().CopyTo(zLocArray);
+  dataSet.GetField("zLocation").GetData().AsArrayHandle(zLocArray);
 
   // Output haloId MBP particleId pairs array
   vtkm::Pair<vtkm::Id, vtkm::Float32> nxnResult;

vtkm/worklet/testing/UnitTestExtractGeometry.cxx

@@ -40,7 +40,7 @@ public:
     OutCellSetType outCellSet = extractGeometry.Run(cellSet, cellIds);
 
     auto cellvar =
-      dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
+      dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
     auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
 
     VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), nCells),
@@ -81,7 +81,7 @@ public:
                           extractOnlyBoundaryCells);
 
     auto cellvar =
-      dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
+      dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
     auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
 
 
@@ -115,7 +115,7 @@ public:
     OutCellSetType outCellSet = extractGeometry.Run(cellSet, cellIds);
 
     auto cellvar =
-      dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
+      dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
     auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
 
     VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), nCells),
@@ -148,7 +148,7 @@ public:
     OutCellSetType outCellSet = extractGeometry.Run(cellSet, cellIds);
 
     auto cellvar =
-      dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
+      dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
     auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
 
     VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), nCells),
@@ -189,7 +189,7 @@ public:
                           extractOnlyBoundaryCells);
 
     auto cellvar =
-      dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
+      dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
     auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
 
     VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), 8), "Wrong result for ExtractCells");
@@ -229,7 +229,7 @@ public:
                           extractOnlyBoundaryCells);
 
     auto cellvar =
-      dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
+      dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
     auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
 
     VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), 8), "Wrong result for ExtractCells");

vtkm/worklet/testing/UnitTestFieldHistogram.cxx

@@ -290,13 +290,13 @@ void TestFieldHistogram()
 
   // Get point data
   vtkm::cont::ArrayHandle<vtkm::Float32> p_poisson;
-  ds.GetField("p_poisson").GetData().CopyTo(p_poisson);
+  ds.GetField("p_poisson").GetData().AsArrayHandle(p_poisson);
   vtkm::cont::ArrayHandle<vtkm::Float32> p_normal;
-  ds.GetField("p_normal").GetData().CopyTo(p_normal);
+  ds.GetField("p_normal").GetData().AsArrayHandle(p_normal);
   vtkm::cont::ArrayHandle<vtkm::Float32> p_chiSquare;
-  ds.GetField("p_chiSquare").GetData().CopyTo(p_chiSquare);
+  ds.GetField("p_chiSquare").GetData().AsArrayHandle(p_chiSquare);
   vtkm::cont::ArrayHandle<vtkm::Float32> p_uniform;
-  ds.GetField("p_uniform").GetData().CopyTo(p_uniform);
+  ds.GetField("p_uniform").GetData().AsArrayHandle(p_uniform);
 
   vtkm::worklet::FieldHistogram histogram;
   // Run data

vtkm/worklet/testing/UnitTestFieldStatistics.cxx

@@ -319,7 +319,7 @@ void TestFieldSimple()
 
   // Cell data
   vtkm::cont::ArrayHandle<vtkm::Float32> data;
-  ds.GetField("data").GetData().CopyTo(data);
+  ds.GetField("data").GetData().AsArrayHandle(data);
 
   // Run
   vtkm::worklet::FieldStatistics<vtkm::Float32>().Run(data, statinfo);
@@ -350,13 +350,13 @@ void TestFieldStandardDistributions()
 
   // Point data
   vtkm::cont::ArrayHandle<vtkm::Float32> p_poisson;
-  ds.GetField("p_poisson").GetData().CopyTo(p_poisson);
+  ds.GetField("p_poisson").GetData().AsArrayHandle(p_poisson);
   vtkm::cont::ArrayHandle<vtkm::Float32> p_normal;
-  ds.GetField("p_normal").GetData().CopyTo(p_normal);
+  ds.GetField("p_normal").GetData().AsArrayHandle(p_normal);
   vtkm::cont::ArrayHandle<vtkm::Float32> p_chiSquare;
-  ds.GetField("p_chiSquare").GetData().CopyTo(p_chiSquare);
+  ds.GetField("p_chiSquare").GetData().AsArrayHandle(p_chiSquare);
   vtkm::cont::ArrayHandle<vtkm::Float32> p_uniform;
-  ds.GetField("p_uniform").GetData().CopyTo(p_uniform);
+  ds.GetField("p_uniform").GetData().AsArrayHandle(p_uniform);
 
   // Run Poisson data
   vtkm::worklet::FieldStatistics<vtkm::Float32>().Run(p_poisson, statinfo);

vtkm/worklet/testing/UnitTestMask.cxx

@@ -43,7 +43,7 @@ public:
     OutCellSetType outCellSet = maskCells.Run(cellSet, 2);
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
-    dataset.GetField("cellvar").GetData().CopyTo(cellvar);
+    dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray = maskCells.ProcessCellField(cellvar);
 
     VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), 8), "Wrong result for Mask");
@@ -69,7 +69,7 @@ public:
     OutCellSetType outCellSet = maskCells.Run(cellSet, 9);
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
-    dataset.GetField("cellvar").GetData().CopyTo(cellvar);
+    dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray = maskCells.ProcessCellField(cellvar);
 
     VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), 7), "Wrong result for ExtractCells");
@@ -96,7 +96,7 @@ public:
     OutCellSetType outCellSet = maskCells.Run(cellSet, 2);
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
-    dataset.GetField("cellvar").GetData().CopyTo(cellvar);
+    dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray = maskCells.ProcessCellField(cellvar);
 
     VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), 2), "Wrong result for ExtractCells");

vtkm/worklet/testing/UnitTestOrientNormals.cxx

@@ -352,8 +352,8 @@ void TestOrientNormals(bool testPoints, bool testCells)
 
     const auto pointNormalField = dataset.GetPointField("normals");
     const auto cellNormalField = dataset.GetCellField("normals");
-    auto pointNormals = pointNormalField.GetData().Cast<NormalArrayT>();
+    auto pointNormals = pointNormalField.GetData().AsArrayHandle<NormalArrayT>();
-    auto cellNormals = cellNormalField.GetData().Cast<NormalArrayT>();
+    auto cellNormals = cellNormalField.GetData().AsArrayHandle<NormalArrayT>();
 
     vtkm::worklet::OrientNormals::RunPointAndCellNormals(cells, coords, pointNormals, cellNormals);
   }
@@ -361,7 +361,7 @@ void TestOrientNormals(bool testPoints, bool testCells)
   {
     std::cerr << "Testing point normals...\n";
     const auto pointNormalField = dataset.GetPointField("normals");
-    auto pointNormals = pointNormalField.GetData().Cast<NormalArrayT>();
+    auto pointNormals = pointNormalField.GetData().AsArrayHandle<NormalArrayT>();
 
     vtkm::worklet::OrientNormals::RunPointNormals(cells, coords, pointNormals);
   }
@@ -369,7 +369,7 @@ void TestOrientNormals(bool testPoints, bool testCells)
   {
     std::cerr << "Testing cell normals...\n";
     const auto cellNormalField = dataset.GetCellField("normals");
-    auto cellNormals = cellNormalField.GetData().Cast<NormalArrayT>();
+    auto cellNormals = cellNormalField.GetData().AsArrayHandle<NormalArrayT>();
 
     vtkm::worklet::OrientNormals::RunCellNormals(cells, coords, cellNormals);
   }

vtkm/worklet/testing/UnitTestParticleAdvection.cxx

@@ -836,9 +836,10 @@ void TestParticleAdvectionFile(const std::string& fname,
   // If types match, do a simple cast.
   // If not, need to copy it into the appropriate type.
   if (fieldData.IsType<FieldHandle>())
-    fieldArray = fieldData.Cast<FieldHandle>();
+    fieldArray = fieldData.AsArrayHandle<FieldHandle>();
   else
-    vtkm::cont::ArrayCopy(fieldData.ResetTypes<vtkm::TypeListFieldVec3>(), fieldArray);
+    vtkm::cont::ArrayCopy(
+      fieldData.ResetTypes<vtkm::TypeListFieldVec3, VTKM_DEFAULT_STORAGE_LIST>(), fieldArray);
 
   FieldType velocities(fieldArray);
   GridEvalType eval(ds.GetCoordinateSystem(), ds.GetCellSet(), velocities);

vtkm/worklet/testing/UnitTestPointGradient.cxx

@@ -25,7 +25,7 @@ void TestPointGradientUniform2D()
   vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
 
   vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
-  dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
+  dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
 
   vtkm::worklet::PointGradient gradient;
   auto result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), fieldArray);
@@ -51,7 +51,7 @@ void TestPointGradientUniform3D()
   vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
 
   vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
-  dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
+  dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
 
   vtkm::worklet::PointGradient gradient;
   auto result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), fieldArray);
@@ -202,7 +202,7 @@ void TestPointGradientExplicit3D()
   vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet5();
 
   vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
-  dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
+  dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
 
   vtkm::worklet::PointGradient gradient;
   auto result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), fieldArray);
@@ -235,7 +235,7 @@ void TestPointGradientExplicit2D()
   vtkm::cont::DataSet dataSet = testDataSet.Make2DExplicitDataSet0();
 
   vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
-  dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
+  dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
 
   vtkm::worklet::PointGradient gradient;
   auto result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), fieldArray);

vtkm/worklet/testing/UnitTestProbe.cxx

@@ -133,10 +133,10 @@ private:
     vtkm::worklet::Probe probe;
     probe.Run(input.GetCellSet(), input.GetCoordinateSystem(), geometry.GetCoordinateSystem());
 
-    auto pf =
+    auto pf = probe.ProcessPointField(
-      probe.ProcessPointField(input.GetField("pointdata").GetData().Cast<FieldArrayType>(), 0.0f);
+      input.GetField("pointdata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
-    auto cf =
+    auto cf = probe.ProcessCellField(
-      probe.ProcessCellField(input.GetField("celldata").GetData().Cast<FieldArrayType>(), 0.0f);
+      input.GetField("celldata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
     auto hp = probe.GetHiddenPointsField();
     auto hc = probe.GetHiddenCellsField(geometry.GetCellSet());
 
@@ -156,10 +156,10 @@ private:
     vtkm::worklet::Probe probe;
     probe.Run(input.GetCellSet(), input.GetCoordinateSystem(), geometry.GetCoordinateSystem());
 
-    auto pf =
+    auto pf = probe.ProcessPointField(
-      probe.ProcessPointField(input.GetField("pointdata").GetData().Cast<FieldArrayType>(), 0.0f);
+      input.GetField("pointdata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
-    auto cf =
+    auto cf = probe.ProcessCellField(
-      probe.ProcessCellField(input.GetField("celldata").GetData().Cast<FieldArrayType>(), 0.0f);
+      input.GetField("celldata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
 
     auto hp = probe.GetHiddenPointsField();
     auto hc = probe.GetHiddenCellsField(geometry.GetCellSet());
@@ -180,10 +180,10 @@ private:
     vtkm::worklet::Probe probe;
     probe.Run(input.GetCellSet(), input.GetCoordinateSystem(), geometry.GetCoordinateSystem());
 
-    auto pf =
+    auto pf = probe.ProcessPointField(
-      probe.ProcessPointField(input.GetField("pointdata").GetData().Cast<FieldArrayType>(), 0.0f);
+      input.GetField("pointdata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
-    auto cf =
+    auto cf = probe.ProcessCellField(
-      probe.ProcessCellField(input.GetField("celldata").GetData().Cast<FieldArrayType>(), 0.0f);
+      input.GetField("celldata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
 
     auto hp = probe.GetHiddenPointsField();
     auto hc = probe.GetHiddenCellsField(geometry.GetCellSet());

vtkm/worklet/testing/UnitTestSplitSharpEdges.cxx

@@ -126,7 +126,7 @@ void TestSplitSharpEdgesSplitEveryEdge(vtkm::cont::DataSet& simpleCube,
                       newCellset);
 
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> pointvar;
-  simpleCube.GetPointField("pointvar").GetData().CopyTo(pointvar);
+  simpleCube.GetPointField("pointvar").GetData().AsArrayHandle(pointvar);
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> newPointFields =
     splitSharpEdges.ProcessPointField(pointvar);
   VTKM_TEST_ASSERT(newCoords.GetNumberOfValues() == 24,
@@ -171,7 +171,7 @@ void TestSplitSharpEdgesNoSplit(vtkm::cont::DataSet& simpleCube,
                       newCellset);
 
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> pointvar;
-  simpleCube.GetPointField("pointvar").GetData().CopyTo(pointvar);
+  simpleCube.GetPointField("pointvar").GetData().AsArrayHandle(pointvar);
   vtkm::cont::ArrayHandle<vtkm::FloatDefault> newPointFields =
     splitSharpEdges.ProcessPointField(pointvar);
   VTKM_TEST_ASSERT(newCoords.GetNumberOfValues() == 8,

vtkm/worklet/testing/UnitTestThreshold.cxx

@@ -59,7 +59,7 @@ public:
     dataset.GetCellSet().CopyTo(cellset);
 
     vtkm::cont::ArrayHandle<vtkm::Float32> pointvar;
-    dataset.GetField("pointvar").GetData().CopyTo(pointvar);
+    dataset.GetField("pointvar").GetData().AsArrayHandle(pointvar);
 
     vtkm::worklet::Threshold threshold;
     OutCellSetType outCellSet =
@@ -68,7 +68,7 @@ public:
     VTKM_TEST_ASSERT(outCellSet.GetNumberOfCells() == 1, "Wrong number of cells");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
-    dataset.GetField("cellvar").GetData().CopyTo(cellvar);
+    dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray = threshold.ProcessCellField(cellvar);
 
     VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 1 &&
@@ -89,7 +89,7 @@ public:
     dataset.GetCellSet().CopyTo(cellset);
 
     vtkm::cont::ArrayHandle<vtkm::Float32> pointvar;
-    dataset.GetField("pointvar").GetData().CopyTo(pointvar);
+    dataset.GetField("pointvar").GetData().AsArrayHandle(pointvar);
 
     vtkm::worklet::Threshold threshold;
     OutCellSetType outCellSet =
@@ -98,7 +98,7 @@ public:
     VTKM_TEST_ASSERT(outCellSet.GetNumberOfCells() == 2, "Wrong number of cells");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
-    dataset.GetField("cellvar").GetData().CopyTo(cellvar);
+    dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray = threshold.ProcessCellField(cellvar);
 
     VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 2 &&
@@ -120,7 +120,7 @@ public:
     dataset.GetCellSet().CopyTo(cellset);
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
-    dataset.GetField("cellvar").GetData().CopyTo(cellvar);
+    dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
 
     vtkm::worklet::Threshold threshold;
     OutCellSetType outCellSet =

vtkm/worklet/testing/UnitTestThresholdPoints.cxx

@@ -109,7 +109,9 @@ public:
     OutCellSetType outCellSet;
     outCellSet =
       threshold.Run(dataset.GetCellSet(),
-                    dataset.GetField("pointvar").GetData().ResetTypes(vtkm::TypeListFieldScalar()),
+                    dataset.GetField("pointvar")
+                      .GetData()
+                      .ResetTypes(vtkm::TypeListFieldScalar{}, VTKM_DEFAULT_STORAGE_LIST{}),
                     ValuesBetween(40.0f, 71.0f));
     outDataSet.SetCellSet(outCellSet);
 
@@ -118,7 +120,7 @@ public:
 
     vtkm::cont::Field pointField = outDataSet.GetField("pointvar");
     vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
-    pointField.GetData().CopyTo(pointFieldArray);
+    pointField.GetData().AsArrayHandle(pointFieldArray);
     VTKM_TEST_ASSERT(pointFieldArray.ReadPortal().Get(12) == 50.0f, "Wrong point field data");
   }
 
@@ -140,7 +142,9 @@ public:
     OutCellSetType outCellSet;
     outCellSet =
       threshold.Run(dataset.GetCellSet(),
-                    dataset.GetField("pointvar").GetData().ResetTypes(vtkm::TypeListFieldScalar()),
+                    dataset.GetField("pointvar")
+                      .GetData()
+                      .ResetTypes(vtkm::TypeListFieldScalar{}, VTKM_DEFAULT_STORAGE_LIST{}),
                     ValuesAbove(1.0f));
     outDataSet.SetCellSet(outCellSet);
 
@@ -165,7 +169,9 @@ public:
     OutCellSetType outCellSet;
     outCellSet =
       threshold.Run(dataset.GetCellSet(),
-                    dataset.GetField("pointvar").GetData().ResetTypes(vtkm::TypeListFieldScalar()),
+                    dataset.GetField("pointvar")
+                      .GetData()
+                      .ResetTypes(vtkm::TypeListFieldScalar{}, VTKM_DEFAULT_STORAGE_LIST{}),
                     ValuesBelow(50.0f));
     outDataSet.SetCellSet(outCellSet);
 

vtkm/worklet/testing/UnitTestTriangleWinding.cxx

@@ -60,7 +60,7 @@ void Validate(vtkm::cont::DataSet dataSet)
     cellSet.GetOffsetsArray(vtkm::TopologyElementTagCell{}, vtkm::TopologyElementTagPoint{});
   const auto cellArray = vtkm::cont::make_ArrayHandleGroupVecVariable(conn, offsets);
   const auto cellNormalsVar = dataSet.GetCellField("normals").GetData();
-  const auto cellNormalsArray = cellNormalsVar.Cast<vtkm::cont::ArrayHandle<MyNormalT>>();
+  const auto cellNormalsArray = cellNormalsVar.AsArrayHandle<vtkm::cont::ArrayHandle<MyNormalT>>();
 
   const auto cellPortal = cellArray.ReadPortal();
   const auto cellNormals = cellNormalsArray.ReadPortal();
@@ -112,7 +112,7 @@ void DoTest()
   auto cellSet = ds.GetCellSet().Cast<vtkm::cont::CellSetExplicit<>>();
   const auto coords = ds.GetCoordinateSystem().GetData();
   const auto cellNormalsVar = ds.GetCellField("normals").GetData();
-  const auto cellNormals = cellNormalsVar.Cast<vtkm::cont::ArrayHandle<MyNormalT>>();
+  const auto cellNormals = cellNormalsVar.AsArrayHandle<vtkm::cont::ArrayHandle<MyNormalT>>();
 
 
   auto newCells = vtkm::worklet::TriangleWinding::Run(cellSet, coords, cellNormals);