VTK-m  2.1
ArrayHandleCartesianProduct.h
Go to the documentation of this file.
1 //============================================================================
2 // Copyright (c) Kitware, Inc.
3 // All rights reserved.
4 // See LICENSE.txt for details.
5 //
6 // This software is distributed WITHOUT ANY WARRANTY; without even
7 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
8 // PURPOSE. See the above copyright notice for more information.
9 //============================================================================
10 #ifndef vtk_m_cont_ArrayHandleCartesianProduct_h
11 #define vtk_m_cont_ArrayHandleCartesianProduct_h
12 
13 #include <vtkm/Assert.h>
14 #include <vtkm/Range.h>
15 #include <vtkm/VecTraits.h>
16 
17 #include <vtkm/cont/ArrayExtractComponent.h>
18 #include <vtkm/cont/ArrayHandle.h>
19 #include <vtkm/cont/ErrorBadAllocation.h>
20 #include <vtkm/cont/Token.h>
21 
22 #include <array>
23 
24 namespace vtkm
25 {
26 namespace internal
27 {
28 
31 template <typename ValueType_,
32  typename PortalTypeFirst_,
33  typename PortalTypeSecond_,
34  typename PortalTypeThird_>
35 class VTKM_ALWAYS_EXPORT ArrayPortalCartesianProduct
36 {
37 public:
38  using ValueType = ValueType_;
39  using IteratorType = ValueType_;
40  using PortalTypeFirst = PortalTypeFirst_;
41  using PortalTypeSecond = PortalTypeSecond_;
42  using PortalTypeThird = PortalTypeThird_;
43 
44  using set_supported_p1 = vtkm::internal::PortalSupportsSets<PortalTypeFirst>;
45  using set_supported_p2 = vtkm::internal::PortalSupportsSets<PortalTypeSecond>;
46  using set_supported_p3 = vtkm::internal::PortalSupportsSets<PortalTypeThird>;
47 
48  using Writable = std::integral_constant<bool,
49  set_supported_p1::value && set_supported_p2::value &&
50  set_supported_p3::value>;
51 
52  VTKM_SUPPRESS_EXEC_WARNINGS
53  VTKM_EXEC_CONT
54  ArrayPortalCartesianProduct()
55  : PortalFirst()
56  , PortalSecond()
57  , PortalThird()
58  {
59  } //needs to be host and device so that cuda can create lvalue of these
60 
61  VTKM_CONT
62  ArrayPortalCartesianProduct(const PortalTypeFirst& portalfirst,
63  const PortalTypeSecond& portalsecond,
64  const PortalTypeThird& portalthird)
65  : PortalFirst(portalfirst)
66  , PortalSecond(portalsecond)
67  , PortalThird(portalthird)
68  {
69  }
70 
75 
76  template <class OtherV, class OtherP1, class OtherP2, class OtherP3>
77  VTKM_CONT ArrayPortalCartesianProduct(
78  const ArrayPortalCartesianProduct<OtherV, OtherP1, OtherP2, OtherP3>& src)
79  : PortalFirst(src.GetPortalFirst())
80  , PortalSecond(src.GetPortalSecond())
81  , PortalThird(src.GetPortalThird())
82  {
83  }
84 
85  VTKM_SUPPRESS_EXEC_WARNINGS
86  VTKM_EXEC_CONT
87  vtkm::Id GetNumberOfValues() const
88  {
89  return this->PortalFirst.GetNumberOfValues() * this->PortalSecond.GetNumberOfValues() *
90  this->PortalThird.GetNumberOfValues();
91  }
92 
93  VTKM_SUPPRESS_EXEC_WARNINGS
94  VTKM_EXEC_CONT
95  ValueType Get(vtkm::Id index) const
96  {
97  VTKM_ASSERT(index >= 0);
98  VTKM_ASSERT(index < this->GetNumberOfValues());
99 
100  vtkm::Id dim1 = this->PortalFirst.GetNumberOfValues();
101  vtkm::Id dim2 = this->PortalSecond.GetNumberOfValues();
102  vtkm::Id dim12 = dim1 * dim2;
103  vtkm::Id idx12 = index % dim12;
104  vtkm::Id i1 = idx12 % dim1;
105  vtkm::Id i2 = idx12 / dim1;
106  vtkm::Id i3 = index / dim12;
107 
108  return vtkm::make_Vec(
109  this->PortalFirst.Get(i1), this->PortalSecond.Get(i2), this->PortalThird.Get(i3));
110  }
111 
112 
113  VTKM_SUPPRESS_EXEC_WARNINGS
114  template <typename Writable_ = Writable,
115  typename = typename std::enable_if<Writable_::value>::type>
116  VTKM_EXEC_CONT void Set(vtkm::Id index, const ValueType& value) const
117  {
118  VTKM_ASSERT(index >= 0);
119  VTKM_ASSERT(index < this->GetNumberOfValues());
120 
121  vtkm::Id dim1 = this->PortalFirst.GetNumberOfValues();
122  vtkm::Id dim2 = this->PortalSecond.GetNumberOfValues();
123  vtkm::Id dim12 = dim1 * dim2;
124  vtkm::Id idx12 = index % dim12;
125 
126  vtkm::Id i1 = idx12 % dim1;
127  vtkm::Id i2 = idx12 / dim1;
128  vtkm::Id i3 = index / dim12;
129 
130  this->PortalFirst.Set(i1, value[0]);
131  this->PortalSecond.Set(i2, value[1]);
132  this->PortalThird.Set(i3, value[2]);
133  }
134 
135  VTKM_SUPPRESS_EXEC_WARNINGS
136  VTKM_EXEC_CONT
137  const PortalTypeFirst& GetFirstPortal() const { return this->PortalFirst; }
138 
139  VTKM_SUPPRESS_EXEC_WARNINGS
140  VTKM_EXEC_CONT
141  const PortalTypeSecond& GetSecondPortal() const { return this->PortalSecond; }
142 
143  VTKM_SUPPRESS_EXEC_WARNINGS
144  VTKM_EXEC_CONT
145  const PortalTypeThird& GetThirdPortal() const { return this->PortalThird; }
146 
147 private:
148  PortalTypeFirst PortalFirst;
149  PortalTypeSecond PortalSecond;
150  PortalTypeThird PortalThird;
151 };
152 }
153 } // namespace vtkm::internal
154 
155 namespace vtkm
156 {
157 namespace cont
158 {
159 
160 template <typename StorageTag1, typename StorageTag2, typename StorageTag3>
161 struct VTKM_ALWAYS_EXPORT StorageTagCartesianProduct
162 {
163 };
164 
165 namespace internal
166 {
167 
171 template <typename AH1, typename AH2, typename AH3>
172 struct ArrayHandleCartesianProductTraits
173 {
174  VTKM_IS_ARRAY_HANDLE(AH1);
175  VTKM_IS_ARRAY_HANDLE(AH2);
176  VTKM_IS_ARRAY_HANDLE(AH3);
177 
178  using ComponentType = typename AH1::ValueType;
179  VTKM_STATIC_ASSERT_MSG(
180  (std::is_same<ComponentType, typename AH2::ValueType>::value),
181  "All arrays for ArrayHandleCartesianProduct must have the same value type. "
182  "Use ArrayHandleCast as necessary to make types match.");
183  VTKM_STATIC_ASSERT_MSG(
184  (std::is_same<ComponentType, typename AH3::ValueType>::value),
185  "All arrays for ArrayHandleCartesianProduct must have the same value type. "
186  "Use ArrayHandleCast as necessary to make types match.");
187 
190  using ValueType = vtkm::Vec<ComponentType, 3>;
191 
194  using Tag = vtkm::cont::StorageTagCartesianProduct<typename AH1::StorageTag,
195  typename AH2::StorageTag,
196  typename AH3::StorageTag>;
197 
200  using Superclass = vtkm::cont::ArrayHandle<ValueType, Tag>;
201 };
202 
203 template <typename T, typename ST1, typename ST2, typename ST3>
204 class Storage<vtkm::Vec<T, 3>, vtkm::cont::StorageTagCartesianProduct<ST1, ST2, ST3>>
205 {
206  struct Info
207  {
208  std::array<std::size_t, 4> BufferOffset;
209  };
210 
211  using Storage1 = vtkm::cont::internal::Storage<T, ST1>;
212  using Storage2 = vtkm::cont::internal::Storage<T, ST2>;
213  using Storage3 = vtkm::cont::internal::Storage<T, ST3>;
214 
215  using Array1 = vtkm::cont::ArrayHandle<T, ST1>;
216  using Array2 = vtkm::cont::ArrayHandle<T, ST2>;
217  using Array3 = vtkm::cont::ArrayHandle<T, ST3>;
218 
219  VTKM_CONT static std::vector<vtkm::cont::internal::Buffer> GetBuffers(
220  const std::vector<vtkm::cont::internal::Buffer>& buffers,
221  std::size_t subArray)
222  {
223  Info info = buffers[0].GetMetaData<Info>();
224  return std::vector<vtkm::cont::internal::Buffer>(buffers.begin() +
225  info.BufferOffset[subArray - 1],
226  buffers.begin() + info.BufferOffset[subArray]);
227  }
228 
229 public:
230  VTKM_STORAGE_NO_RESIZE;
231 
232  using ReadPortalType =
233  vtkm::internal::ArrayPortalCartesianProduct<vtkm::Vec<T, 3>,
234  typename Storage1::ReadPortalType,
235  typename Storage2::ReadPortalType,
236  typename Storage3::ReadPortalType>;
237  using WritePortalType =
238  vtkm::internal::ArrayPortalCartesianProduct<vtkm::Vec<T, 3>,
239  typename Storage1::WritePortalType,
240  typename Storage2::WritePortalType,
241  typename Storage3::WritePortalType>;
242 
243  VTKM_CONT static vtkm::IdComponent GetNumberOfComponentsFlat(
244  const std::vector<vtkm::cont::internal::Buffer>&)
245  {
246  return vtkm::VecFlat<T>::NUM_COMPONENTS * 3;
247  }
248 
249  VTKM_CONT static vtkm::Id GetNumberOfValues(
250  const std::vector<vtkm::cont::internal::Buffer>& buffers)
251  {
252  return (Storage1::GetNumberOfValues(GetBuffers(buffers, 1)) *
253  Storage2::GetNumberOfValues(GetBuffers(buffers, 2)) *
254  Storage3::GetNumberOfValues(GetBuffers(buffers, 3)));
255  }
256 
257  VTKM_CONT static void Fill(const std::vector<vtkm::cont::internal::Buffer>& buffers,
258  const vtkm::Vec<T, 3>& fillValue,
259  vtkm::Id startIndex,
260  vtkm::Id endIndex,
261  vtkm::cont::Token& token)
262  {
263  if ((startIndex != 0) || (endIndex != GetNumberOfValues(buffers)))
264  {
265  throw vtkm::cont::ErrorBadValue(
266  "Fill for ArrayHandleCartesianProduct can only be used to fill entire array.");
267  }
268  auto subBuffers = GetBuffers(buffers, 1);
269  Storage1::Fill(subBuffers, fillValue[0], 0, Storage1::GetNumberOfValues(subBuffers), token);
270  subBuffers = GetBuffers(buffers, 2);
271  Storage2::Fill(subBuffers, fillValue[1], 0, Storage2::GetNumberOfValues(subBuffers), token);
272  subBuffers = GetBuffers(buffers, 3);
273  Storage3::Fill(subBuffers, fillValue[2], 0, Storage3::GetNumberOfValues(subBuffers), token);
274  }
275 
276  VTKM_CONT static ReadPortalType CreateReadPortal(
277  const std::vector<vtkm::cont::internal::Buffer>& buffers,
278  vtkm::cont::DeviceAdapterId device,
279  vtkm::cont::Token& token)
280  {
281  return ReadPortalType(Storage1::CreateReadPortal(GetBuffers(buffers, 1), device, token),
282  Storage2::CreateReadPortal(GetBuffers(buffers, 2), device, token),
283  Storage3::CreateReadPortal(GetBuffers(buffers, 3), device, token));
284  }
285 
286  VTKM_CONT static WritePortalType CreateWritePortal(
287  const std::vector<vtkm::cont::internal::Buffer>& buffers,
288  vtkm::cont::DeviceAdapterId device,
289  vtkm::cont::Token& token)
290  {
291  return WritePortalType(Storage1::CreateWritePortal(GetBuffers(buffers, 1), device, token),
292  Storage2::CreateWritePortal(GetBuffers(buffers, 2), device, token),
293  Storage3::CreateWritePortal(GetBuffers(buffers, 3), device, token));
294  }
295 
296  VTKM_CONT static Array1 GetArrayHandle1(const std::vector<vtkm::cont::internal::Buffer>& buffers)
297  {
298  return Array1(GetBuffers(buffers, 1));
299  }
300  VTKM_CONT static Array2 GetArrayHandle2(const std::vector<vtkm::cont::internal::Buffer>& buffers)
301  {
302  return Array2(GetBuffers(buffers, 2));
303  }
304  VTKM_CONT static Array3 GetArrayHandle3(const std::vector<vtkm::cont::internal::Buffer>& buffers)
305  {
306  return Array3(GetBuffers(buffers, 3));
307  }
308 
309  VTKM_CONT static std::vector<vtkm::cont::internal::Buffer> CreateBuffers(
310  const Array1& array1 = Array1{},
311  const Array2& array2 = Array2{},
312  const Array3& array3 = Array3{})
313  {
314  const std::vector<vtkm::cont::internal::Buffer>& buffers1 = array1.GetBuffers();
315  const std::vector<vtkm::cont::internal::Buffer>& buffers2 = array2.GetBuffers();
316  const std::vector<vtkm::cont::internal::Buffer>& buffers3 = array3.GetBuffers();
317 
318  Info info;
319  info.BufferOffset[0] = 1;
320  info.BufferOffset[1] = info.BufferOffset[0] + buffers1.size();
321  info.BufferOffset[2] = info.BufferOffset[1] + buffers2.size();
322  info.BufferOffset[3] = info.BufferOffset[2] + buffers3.size();
323 
324  return vtkm::cont::internal::CreateBuffers(info, buffers1, buffers2, buffers3);
325  }
326 };
327 } // namespace internal
328 
333 template <typename FirstHandleType, typename SecondHandleType, typename ThirdHandleType>
334 class ArrayHandleCartesianProduct
335  : public internal::ArrayHandleCartesianProductTraits<FirstHandleType,
336  SecondHandleType,
337  ThirdHandleType>::Superclass
338 {
339  // If the following line gives a compile error, then the FirstHandleType
340  // template argument is not a valid ArrayHandle type.
341  VTKM_IS_ARRAY_HANDLE(FirstHandleType);
342  VTKM_IS_ARRAY_HANDLE(SecondHandleType);
343  VTKM_IS_ARRAY_HANDLE(ThirdHandleType);
344 
345 public:
346  VTKM_ARRAY_HANDLE_SUBCLASS(
347  ArrayHandleCartesianProduct,
348  (ArrayHandleCartesianProduct<FirstHandleType, SecondHandleType, ThirdHandleType>),
349  (typename internal::ArrayHandleCartesianProductTraits<FirstHandleType,
350  SecondHandleType,
351  ThirdHandleType>::Superclass));
352 
353  VTKM_CONT
354  ArrayHandleCartesianProduct(const FirstHandleType& firstArray,
355  const SecondHandleType& secondArray,
356  const ThirdHandleType& thirdArray)
357  : Superclass(StorageType::CreateBuffers(firstArray, secondArray, thirdArray))
358  {
359  }
360 
366  ~ArrayHandleCartesianProduct() {}
367 
368  VTKM_CONT FirstHandleType GetFirstArray() const
369  {
370  return StorageType::GetArrayHandle1(this->GetBuffers());
371  }
372  VTKM_CONT SecondHandleType GetSecondArray() const
373  {
374  return StorageType::GetArrayHandle2(this->GetBuffers());
375  }
376  VTKM_CONT ThirdHandleType GetThirdArray() const
377  {
378  return StorageType::GetArrayHandle3(this->GetBuffers());
379  }
380 };
381 
385 template <typename FirstHandleType, typename SecondHandleType, typename ThirdHandleType>
386 VTKM_CONT
387  vtkm::cont::ArrayHandleCartesianProduct<FirstHandleType, SecondHandleType, ThirdHandleType>
388  make_ArrayHandleCartesianProduct(const FirstHandleType& first,
389  const SecondHandleType& second,
390  const ThirdHandleType& third)
391 {
392  return ArrayHandleCartesianProduct<FirstHandleType, SecondHandleType, ThirdHandleType>(
393  first, second, third);
394 }
395 
396 //--------------------------------------------------------------------------------
397 // Specialization of ArrayExtractComponent
398 namespace internal
399 {
400 
401 // Superclass will inherit the ArrayExtractComponentImplInefficient property if any
402 // of the sub-storage are inefficient (thus making everything inefficient).
403 template <typename... STs>
404 struct ArrayExtractComponentImpl<vtkm::cont::StorageTagCartesianProduct<STs...>>
405  : vtkm::cont::internal::ArrayExtractComponentImplInherit<STs...>
406 {
407  template <typename T>
408  vtkm::cont::ArrayHandleStride<T> AdjustStrideForComponent(
409  const vtkm::cont::ArrayHandleStride<T>& componentArray,
410  const vtkm::Id3& dims,
411  vtkm::IdComponent component,
412  vtkm::Id totalNumValues) const
413  {
414  VTKM_ASSERT(componentArray.GetModulo() == 0);
415  VTKM_ASSERT(componentArray.GetDivisor() == 1);
416 
417  vtkm::Id modulo = 0;
418  if (component < 2)
419  {
420  modulo = dims[component];
421  }
422 
423  vtkm::Id divisor = 1;
424  for (vtkm::IdComponent c = 0; c < component; ++c)
425  {
426  divisor *= dims[c];
427  }
428 
429  return vtkm::cont::ArrayHandleStride<T>(componentArray.GetBasicArray(),
430  totalNumValues,
431  componentArray.GetStride(),
432  componentArray.GetOffset(),
433  modulo,
434  divisor);
435  }
436 
437  template <typename T, typename ST, typename CartesianArrayType>
438  vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType>
439  GetStrideForComponentArray(const vtkm::cont::ArrayHandle<T, ST>& componentArray,
440  const CartesianArrayType& cartesianArray,
441  vtkm::IdComponent subIndex,
442  vtkm::IdComponent productIndex,
443  vtkm::CopyFlag allowCopy) const
444  {
445  vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType> strideArray =
446  ArrayExtractComponentImpl<ST>{}(componentArray, subIndex, allowCopy);
447  if ((strideArray.GetModulo() != 0) || (strideArray.GetDivisor() != 1))
448  {
449  // If the sub array has its own modulo and/or divisor, that will likely interfere
450  // with this math. Give up and fall back to simple copy.
451  constexpr vtkm::IdComponent NUM_SUB_COMPONENTS = vtkm::VecFlat<T>::NUM_COMPONENTS;
452  return vtkm::cont::internal::ArrayExtractComponentFallback(
453  cartesianArray, (productIndex * NUM_SUB_COMPONENTS) + subIndex, allowCopy);
454  }
455 
456  vtkm::Id3 dims = { cartesianArray.GetFirstArray().GetNumberOfValues(),
457  cartesianArray.GetSecondArray().GetNumberOfValues(),
458  cartesianArray.GetThirdArray().GetNumberOfValues() };
459 
460  return this->AdjustStrideForComponent(
461  strideArray, dims, productIndex, cartesianArray.GetNumberOfValues());
462  }
463 
464  template <typename T>
465  vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType> operator()(
466  const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, vtkm::cont::StorageTagCartesianProduct<STs...>>&
467  src,
468  vtkm::IdComponent componentIndex,
469  vtkm::CopyFlag allowCopy) const
470  {
471  vtkm::cont::ArrayHandleCartesianProduct<vtkm::cont::ArrayHandle<T, STs>...> array(src);
472  constexpr vtkm::IdComponent NUM_SUB_COMPONENTS = vtkm::VecFlat<T>::NUM_COMPONENTS;
473  vtkm::IdComponent subIndex = componentIndex % NUM_SUB_COMPONENTS;
474  vtkm::IdComponent productIndex = componentIndex / NUM_SUB_COMPONENTS;
475 
476  switch (productIndex)
477  {
478  case 0:
479  return this->GetStrideForComponentArray(
480  array.GetFirstArray(), array, subIndex, productIndex, allowCopy);
481  case 1:
482  return this->GetStrideForComponentArray(
483  array.GetSecondArray(), array, subIndex, productIndex, allowCopy);
484  case 2:
485  return this->GetStrideForComponentArray(
486  array.GetThirdArray(), array, subIndex, productIndex, allowCopy);
487  default:
488  throw vtkm::cont::ErrorBadValue("Invalid component index to ArrayExtractComponent.");
489  }
490  }
491 };
492 
493 template <typename T, typename S>
494 vtkm::cont::ArrayHandle<vtkm::Range> ArrayRangeComputeGeneric(
495  const vtkm::cont::ArrayHandle<T, S>& input,
496  const vtkm::cont::ArrayHandle<vtkm::UInt8>& maskArray,
497  bool computeFiniteRange,
498  vtkm::cont::DeviceAdapterId device);
499 
500 template <typename S>
501 struct ArrayRangeComputeImpl;
502 
503 template <typename ST1, typename ST2, typename ST3>
504 struct VTKM_CONT_EXPORT ArrayRangeComputeImpl<vtkm::cont::StorageTagCartesianProduct<ST1, ST2, ST3>>
505 {
506  template <typename T>
507  VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> operator()(
508  const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>,
509  vtkm::cont::StorageTagCartesianProduct<ST1, ST2, ST3>>& input_,
510  const vtkm::cont::ArrayHandle<vtkm::UInt8>& maskArray,
511  bool computeFiniteRange,
512  vtkm::cont::DeviceAdapterId device) const
513  {
514  if (maskArray.GetNumberOfValues() != 0)
515  {
516  return vtkm::cont::internal::ArrayRangeComputeGeneric(
517  input_, maskArray, computeFiniteRange, device);
518  }
519 
520  const auto& input =
521  static_cast<const vtkm::cont::ArrayHandleCartesianProduct<vtkm::cont::ArrayHandle<T, ST1>,
522  vtkm::cont::ArrayHandle<T, ST2>,
523  vtkm::cont::ArrayHandle<T, ST3>>&>(
524  input_);
525 
526  vtkm::cont::ArrayHandle<vtkm::Range> ranges[3];
527  ranges[0] = vtkm::cont::internal::ArrayRangeComputeImpl<ST1>{}(
528  input.GetFirstArray(), maskArray, computeFiniteRange, device);
529  ranges[1] = vtkm::cont::internal::ArrayRangeComputeImpl<ST2>{}(
530  input.GetSecondArray(), maskArray, computeFiniteRange, device);
531  ranges[2] = vtkm::cont::internal::ArrayRangeComputeImpl<ST3>{}(
532  input.GetThirdArray(), maskArray, computeFiniteRange, device);
533 
534  auto numComponents =
535  ranges[0].GetNumberOfValues() + ranges[1].GetNumberOfValues() + ranges[2].GetNumberOfValues();
536  vtkm::cont::ArrayHandle<vtkm::Range> result;
537  result.Allocate(numComponents);
538  auto resultPortal = result.WritePortal();
539  for (vtkm::Id i = 0, index = 0; i < 3; ++i)
540  {
541  auto rangePortal = ranges[i].ReadPortal();
542  for (vtkm::Id j = 0; j < rangePortal.GetNumberOfValues(); ++j, ++index)
543  {
544  resultPortal.Set(index, rangePortal.Get(j));
545  }
546  }
547  return result;
548  }
549 };
550 
551 } // namespace internal
552 
553 }
554 } // namespace vtkm::cont
555 
556 //=============================================================================
557 // Specializations of serialization related classes
559 namespace vtkm
560 {
561 namespace cont
562 {
563 
564 template <typename AH1, typename AH2, typename AH3>
565 struct SerializableTypeString<vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>>
566 {
567  static VTKM_CONT const std::string& Get()
568  {
569  static std::string name = "AH_CartesianProduct<" + SerializableTypeString<AH1>::Get() + "," +
570  SerializableTypeString<AH2>::Get() + "," + SerializableTypeString<AH3>::Get() + ">";
571  return name;
572  }
573 };
574 
575 template <typename T, typename ST1, typename ST2, typename ST3>
576 struct SerializableTypeString<
577  vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, vtkm::cont::StorageTagCartesianProduct<ST1, ST2, ST3>>>
578  : SerializableTypeString<vtkm::cont::ArrayHandleCartesianProduct<vtkm::cont::ArrayHandle<T, ST1>,
579  vtkm::cont::ArrayHandle<T, ST2>,
580  vtkm::cont::ArrayHandle<T, ST3>>>
581 {
582 };
583 }
584 } // vtkm::cont
585 
586 namespace mangled_diy_namespace
587 {
588 
589 template <typename AH1, typename AH2, typename AH3>
590 struct Serialization<vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>>
591 {
592 private:
593  using Type = typename vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>;
594  using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
595 
596 public:
597  static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
598  {
599  Type array = obj;
600  vtkmdiy::save(bb, array.GetFirstArray());
601  vtkmdiy::save(bb, array.GetSecondArray());
602  vtkmdiy::save(bb, array.GetThirdArray());
603  }
604 
605  static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
606  {
607  AH1 array1;
608  AH2 array2;
609  AH3 array3;
610 
611  vtkmdiy::load(bb, array1);
612  vtkmdiy::load(bb, array2);
613  vtkmdiy::load(bb, array3);
614 
615  obj = vtkm::cont::make_ArrayHandleCartesianProduct(array1, array2, array3);
616  }
617 };
618 
619 template <typename T, typename ST1, typename ST2, typename ST3>
620 struct Serialization<
621  vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, vtkm::cont::StorageTagCartesianProduct<ST1, ST2, ST3>>>
622  : Serialization<vtkm::cont::ArrayHandleCartesianProduct<vtkm::cont::ArrayHandle<T, ST1>,
623  vtkm::cont::ArrayHandle<T, ST2>,
624  vtkm::cont::ArrayHandle<T, ST3>>>
625 {
626 };
627 } // diy
629 
630 #endif //vtk_m_cont_ArrayHandleCartesianProduct_h
ErrorBadAllocation.h
vtkm::cont::ArrayHandle
Manages an array-worth of data.
Definition: ArrayHandle.h:300
ArrayHandle.h
ArrayExtractComponent.h
vtkm::cont::ArrayHandle::GetBuffers
const std::vector< vtkm::cont::internal::Buffer > & GetBuffers() const
Returns the internal Buffer structures that hold the data.
Definition: ArrayHandle.h:719
vtkm::exec::arg::load
T load(const U &u, vtkm::Id v)
Definition: FetchTagArrayDirectIn.h:36
vtkm
Groups connected points that have the same field value.
Definition: Atomic.h:19
vtkm::Get
auto Get(const vtkm::Tuple< Ts... > &tuple)
Retrieve the object from a vtkm::Tuple at the given index.
Definition: Tuple.h:81
VTKM_ARRAY_HANDLE_SUBCLASS
#define VTKM_ARRAY_HANDLE_SUBCLASS(classname, fullclasstype, superclass)
Macro to make default methods in ArrayHandle subclasses.
Definition: ArrayHandle.h:243
VTKM_ASSERT
#define VTKM_ASSERT(condition)
Definition: Assert.h:43
VTKM_EXEC_CONT
#define VTKM_EXEC_CONT
Definition: ExportMacros.h:52
vtkm::make_Vec
constexpr vtkm::Vec< T, vtkm::IdComponent(sizeof...(Ts)+1)> make_Vec(T value0, Ts &&... args)
Initializes and returns a Vec containing all the arguments.
Definition: Types.h:1250
vtkm::cont::ArrayHandleCartesianProduct::GetThirdArray
ThirdHandleType GetThirdArray() const
Definition: ArrayHandleCartesianProduct.h:376
vtkm::IdComponent
vtkm::Int32 IdComponent
Base type to use to index small lists.
Definition: Types.h:194
vtkm::cont::ArrayHandleStride::GetStride
vtkm::Id GetStride() const
Get the stride that values are accessed.
Definition: ArrayHandleStride.h:377
vtkm::cont::ArrayHandleCartesianProduct
ArrayHandleCartesianProduct is a specialization of ArrayHandle.
Definition: ArrayHandleCartesianProduct.h:334
vtkm::cont::ArrayHandleCartesianProduct::GetFirstArray
FirstHandleType GetFirstArray() const
Definition: ArrayHandleCartesianProduct.h:368
vtkm::cont::ArrayHandleStride::GetOffset
vtkm::Id GetOffset() const
Get the offset to start reading values.
Definition: ArrayHandleStride.h:388
vtkm::cont::ArrayHandle::GetNumberOfValues
vtkm::Id GetNumberOfValues() const
Returns the number of entries in the array.
Definition: ArrayHandle.h:466
vtkm::cont::StorageTagCartesianProduct
Definition: ArrayHandleCartesianProduct.h:161
Assert.h
vtkm::cont::make_ArrayHandleCartesianProduct
vtkm::cont::ArrayHandleCartesianProduct< FirstHandleType, SecondHandleType, ThirdHandleType > make_ArrayHandleCartesianProduct(const FirstHandleType &first, const SecondHandleType &second, const ThirdHandleType &third)
A convenience function for creating an ArrayHandleCartesianProduct.
Definition: ArrayHandleCartesianProduct.h:388
vtkm::cont::ArrayHandleCartesianProduct::GetSecondArray
SecondHandleType GetSecondArray() const
Definition: ArrayHandleCartesianProduct.h:372
VTKM_STORAGE_NO_RESIZE
#define VTKM_STORAGE_NO_RESIZE
Definition: Storage.h:185
mangled_diy_namespace
Definition: Particle.h:351
vtkm::cont::ArrayHandleStride
An ArrayHandle that accesses a basic array with strides and offsets.
Definition: ArrayHandleStride.h:332
vtkm::cont::Token
A token to hold the scope of an ArrayHandle or other object.
Definition: Token.h:35
vtkm::cont::LogLevel::Info
@ Info
Information messages (detected hardware, etc) and temporary debugging output.
vtkm::cont::ArrayHandleStride::GetDivisor
vtkm::Id GetDivisor() const
Get the divisor of the array index.
Definition: ArrayHandleStride.h:404
vtkm::cont::ArrayHandleStride::GetBasicArray
vtkm::cont::ArrayHandleBasic< T > GetBasicArray() const
Return the underlying data as a basic array handle.
Definition: ArrayHandleStride.h:410
VTKM_IS_ARRAY_HANDLE
#define VTKM_IS_ARRAY_HANDLE(T)
Checks that the given type is a vtkm::cont::ArrayHandle.
Definition: ArrayHandle.h:137
VTKM_STATIC_ASSERT_MSG
#define VTKM_STATIC_ASSERT_MSG(condition, message)
Definition: StaticAssert.h:18
VTKM_CONT_EXPORT
#define VTKM_CONT_EXPORT
Definition: vtkm_cont_export.h:44
Range.h
VTKM_CONT
#define VTKM_CONT
Definition: ExportMacros.h:57
vtkm::cont::ArrayHandleCartesianProduct::ArrayHandleCartesianProduct
ArrayHandleCartesianProduct(const FirstHandleType &firstArray, const SecondHandleType &secondArray, const ThirdHandleType &thirdArray)
Definition: ArrayHandleCartesianProduct.h:354
vtkm::Id
vtkm::Int64 Id
Base type to use to index arrays.
Definition: Types.h:227
vtkm::cont::ArrayHandleCartesianProduct::Superclass
typename vtkm::cont::detail::GetTypeInParentheses< void(typename internal::ArrayHandleCartesianProductTraits< FirstHandleType, SecondHandleType, ThirdHandleType >::Superclass) >::type Superclass
Definition: ArrayHandleCartesianProduct.h:351
vtkm::cont::ArrayHandleCartesianProduct::~ArrayHandleCartesianProduct
~ArrayHandleCartesianProduct()
Implemented so that it is defined exclusively in the control environment.
Definition: ArrayHandleCartesianProduct.h:366
vtkm::VecFlat
Treat a Vec or Vec-like object as a flat Vec.
Definition: VecFlat.h:224
vtkm::cont::ArrayHandle::ReadPortal
ReadPortalType ReadPortal() const
Get an array portal that can be used in the control environment.
Definition: ArrayHandle.h:431
vtkm::cont::ArrayHandleStride::GetModulo
vtkm::Id GetModulo() const
Get the modulus of the array index.
Definition: ArrayHandleStride.h:397
vtkm::cont::DeviceAdapterId
An object used to specify a device.
Definition: DeviceAdapterTag.h:58
vtkm::Vec< T, 3 >
Definition: Types.h:1013
vtkm::Vec
A short fixed-length array.
Definition: Types.h:357
vtkm::cont::ErrorBadValue
This class is thrown when a VTKm function or method encounters an invalid value that inhibits progres...
Definition: ErrorBadValue.h:25
vtkm::cont::ArrayHandle::StorageType
vtkm::cont::internal::Storage< ValueType, StorageTag > StorageType
Definition: ArrayHandle.h:309
vtkm::CopyFlag
CopyFlag
Identifier used to specify whether a function should deep copy data.
Definition: Flags.h:17
vtkm::cont::ArrayHandle::Allocate
void Allocate(vtkm::Id numberOfValues, vtkm::CopyFlag preserve, vtkm::cont::Token &token) const
Allocates an array large enough to hold the given number of values.
Definition: ArrayHandle.h:488
VTKM_ALWAYS_EXPORT
#define VTKM_ALWAYS_EXPORT
Definition: ExportMacros.h:89
vtkm::cont::ArrayHandle::WritePortal
WritePortalType WritePortal() const
Get an array portal that can be used in the control environment.
Definition: ArrayHandle.h:452
Token.h
VTKM_SUPPRESS_EXEC_WARNINGS
#define VTKM_SUPPRESS_EXEC_WARNINGS
Definition: ExportMacros.h:53
VecTraits.h
Generated by   doxygen 1.8.17