VTK-m  2.0
worklet/Gradient.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 
11 #ifndef vtk_m_worklet_Gradient_h
12 #define vtk_m_worklet_Gradient_h
13 
14 #include <vtkm/worklet/DispatcherMapTopology.h>
15 #include <vtkm/worklet/DispatcherPointNeighborhood.h>
16 
17 #include <vtkm/filter/vector_analysis/worklet/gradient/CellGradient.h>
18 #include <vtkm/filter/vector_analysis/worklet/gradient/Divergence.h>
19 #include <vtkm/filter/vector_analysis/worklet/gradient/GradientOutput.h>
20 #include <vtkm/filter/vector_analysis/worklet/gradient/PointGradient.h>
21 #include <vtkm/filter/vector_analysis/worklet/gradient/QCriterion.h>
22 #include <vtkm/filter/vector_analysis/worklet/gradient/StructuredPointGradient.h>
23 #include <vtkm/filter/vector_analysis/worklet/gradient/Transpose.h>
24 #include <vtkm/filter/vector_analysis/worklet/gradient/Vorticity.h>
25 
26 // Required for instantiations
27 #include <vtkm/cont/ArrayHandle.h>
28 #include <vtkm/cont/ArrayHandleCartesianProduct.h>
29 #include <vtkm/cont/ArrayHandleSOA.h>
30 #include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
31 #include <vtkm/cont/CoordinateSystem.h>
32 #include <vtkm/cont/UnknownCellSet.h>
33 #include <vtkm/internal/Instantiations.h>
34 
35 #ifndef vtkm_GradientInstantiation
36 // Turn this on to check to see if all the instances of the gradient worklet are covered
37 // in external instances. If they are not, you will get a compile error.
38 //#define VTKM_GRADIENT_CHECK_WORKLET_INSTANCES
39 #endif
40 
41 namespace vtkm
42 {
43 namespace worklet
44 {
45 
46 template <typename T>
47 struct GradientOutputFields;
48 
49 namespace gradient
50 {
51 
52 //-----------------------------------------------------------------------------
53 template <typename CoordinateSystem, typename T, typename S>
54 struct DeducedPointGrad
55 {
56  DeducedPointGrad(const CoordinateSystem& coords,
57  const vtkm::cont::ArrayHandle<T, S>& field,
58  GradientOutputFields<T>* result)
59  : Points(&coords)
60  , Field(&field)
61  , Result(result)
62  {
63  }
64 
65  template <typename CellSetType>
66  void operator()(const CellSetType& cellset) const;
67 
68  template <typename CellSetType>
69  void Go(const CellSetType& cellset) const
70  {
71  vtkm::worklet::DispatcherMapTopology<PointGradient> dispatcher;
72  dispatcher.Invoke(cellset, //topology to iterate on a per point basis
73  cellset, //whole cellset in
74  *this->Points,
75  *this->Field,
76  *this->Result);
77  }
78 
79  void Go(const vtkm::cont::CellSetStructured<3>& cellset) const
80  {
81  vtkm::worklet::DispatcherPointNeighborhood<StructuredPointGradient> dispatcher;
82  dispatcher.Invoke(cellset, //topology to iterate on a per point basis
83  *this->Points,
84  *this->Field,
85  *this->Result);
86  }
87 
88  template <typename PermIterType>
89  void Go(const vtkm::cont::CellSetPermutation<vtkm::cont::CellSetStructured<3>, PermIterType>&
90  cellset) const
91  {
92  vtkm::worklet::DispatcherPointNeighborhood<StructuredPointGradient> dispatcher;
93  dispatcher.Invoke(cellset, //topology to iterate on a per point basis
94  *this->Points,
95  *this->Field,
96  *this->Result);
97  }
98 
99  void Go(const vtkm::cont::CellSetStructured<2>& cellset) const
100  {
101  vtkm::worklet::DispatcherPointNeighborhood<StructuredPointGradient> dispatcher;
102  dispatcher.Invoke(cellset, //topology to iterate on a per point basis
103  *this->Points,
104  *this->Field,
105  *this->Result);
106  }
107 
108  template <typename PermIterType>
109  void Go(const vtkm::cont::CellSetPermutation<vtkm::cont::CellSetStructured<2>, PermIterType>&
110  cellset) const
111  {
112  vtkm::worklet::DispatcherPointNeighborhood<StructuredPointGradient> dispatcher;
113  dispatcher.Invoke(cellset, //topology to iterate on a per point basis
114  *this->Points,
115  *this->Field,
116  *this->Result);
117  }
118 
119 
120  const CoordinateSystem* const Points;
121  const vtkm::cont::ArrayHandle<T, S>* const Field;
122  GradientOutputFields<T>* Result;
123 
124 private:
125  void operator=(const DeducedPointGrad<CoordinateSystem, T, S>&) = delete;
126 };
127 
128 #ifndef VTKM_GRADIENT_CHECK_WORKLET_INSTANCES
129 // Declare the methods that get instances outside of the class so that they are not inline.
130 // If they are inline, the compiler may decide to compile them anyway.
131 template <typename CoordinateSystem, typename T, typename S>
132 template <typename CellSetType>
133 void DeducedPointGrad<CoordinateSystem, T, S>::operator()(const CellSetType& cellset) const
134 {
135  this->Go(cellset);
136 }
137 #endif
138 
139 } //namespace gradient
140 
141 template <typename T>
142 struct GradientOutputFields : public vtkm::cont::ExecutionObjectBase
143 {
144 
145  using ValueType = T;
146  using BaseTType = typename vtkm::VecTraits<T>::BaseComponentType;
147 
148  template <typename DeviceAdapter>
149  struct ExecutionTypes
150  {
151  using Portal = vtkm::exec::GradientOutput<T>;
152  };
153 
154  GradientOutputFields()
155  : Gradient()
156  , Divergence()
157  , Vorticity()
158  , QCriterion()
159  , StoreGradient(true)
160  , ComputeDivergence(false)
161  , ComputeVorticity(false)
162  , ComputeQCriterion(false)
163  {
164  }
165 
166  GradientOutputFields(bool store, bool divergence, bool vorticity, bool qc)
167  : Gradient()
168  , Divergence()
169  , Vorticity()
170  , QCriterion()
171  , StoreGradient(store)
172  , ComputeDivergence(divergence)
173  , ComputeVorticity(vorticity)
174  , ComputeQCriterion(qc)
175  {
176  }
177 
181  void SetComputeDivergence(bool enable) { ComputeDivergence = enable; }
182  bool GetComputeDivergence() const { return ComputeDivergence; }
183 
187  void SetComputeVorticity(bool enable) { ComputeVorticity = enable; }
188  bool GetComputeVorticity() const { return ComputeVorticity; }
189 
193  void SetComputeQCriterion(bool enable) { ComputeQCriterion = enable; }
194  bool GetComputeQCriterion() const { return ComputeQCriterion; }
195 
199  void SetComputeGradient(bool enable) { StoreGradient = enable; }
200  bool GetComputeGradient() const { return StoreGradient; }
201 
202  //todo fix this for scalar
203  vtkm::exec::GradientOutput<T> PrepareForOutput(vtkm::Id size)
204  {
205  vtkm::exec::GradientOutput<T> portal(this->StoreGradient,
206  this->ComputeDivergence,
207  this->ComputeVorticity,
208  this->ComputeQCriterion,
209  this->Gradient,
210  this->Divergence,
211  this->Vorticity,
212  this->QCriterion,
213  size);
214  return portal;
215  }
216 
217  vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> Gradient;
218  vtkm::cont::ArrayHandle<BaseTType> Divergence;
219  vtkm::cont::ArrayHandle<vtkm::Vec<BaseTType, 3>> Vorticity;
220  vtkm::cont::ArrayHandle<BaseTType> QCriterion;
221 
222 private:
223  bool StoreGradient;
224  bool ComputeDivergence;
225  bool ComputeVorticity;
226  bool ComputeQCriterion;
227 };
228 class PointGradient
229 {
230 public:
231  template <typename CellSetType, typename CoordinateSystem, typename T, typename S>
232  vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> Run(const CellSetType& cells,
233  const CoordinateSystem& coords,
234  const vtkm::cont::ArrayHandle<T, S>& field,
235  GradientOutputFields<T>& extraOutput)
236  {
237  //we are using cast and call here as we pass the cells twice to the invoke
238  //and want the type resolved once before hand instead of twice
239  //by the dispatcher ( that will cost more in time and binary size )
240  gradient::DeducedPointGrad<CoordinateSystem, T, S> func(coords, field, &extraOutput);
241  vtkm::cont::CastAndCall(cells, func);
242  return extraOutput.Gradient;
243  }
244 };
245 
246 class CellGradient
247 {
248 public:
249  template <typename CellSetType, typename CoordinateSystem, typename T, typename S>
250  static vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> Run(const CellSetType& cells,
251  const CoordinateSystem& coords,
252  const vtkm::cont::ArrayHandle<T, S>& field,
253  GradientOutputFields<T>& extraOutput);
254 };
255 
256 #ifndef VTKM_GRADIENT_CHECK_WORKLET_INSTANCES
257 // Declare the methods that get instances outside of the class so that they are not inline.
258 // If they are inline, the compiler may decide to compile them anyway.
259 template <typename CellSetType, typename CoordinateSystem, typename T, typename S>
260 vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> CellGradient::Run(
261  const CellSetType& cells,
262  const CoordinateSystem& coords,
263  const vtkm::cont::ArrayHandle<T, S>& field,
264  GradientOutputFields<T>& extraOutput)
265 {
266  vtkm::worklet::DispatcherMapTopology<vtkm::worklet::gradient::CellGradient> dispatcher;
267  dispatcher.Invoke(cells, coords, field, extraOutput);
268  return extraOutput.Gradient;
269 }
270 #endif
271 
272 }
273 } // namespace vtkm::worklet
274 
275 //==============================================================================
276 //---------------------------------------------------------------------------
277 VTKM_INSTANTIATION_BEGIN
278 extern template void vtkm::worklet::gradient::DeducedPointGrad<
279  vtkm::cont::CoordinateSystem,
280  vtkm::Float32,
281  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetStructured<3>&) const;
282 VTKM_INSTANTIATION_END
283 VTKM_INSTANTIATION_BEGIN
284 extern template void vtkm::worklet::gradient::DeducedPointGrad<
285  vtkm::cont::CoordinateSystem,
286  vtkm::Float64,
287  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetStructured<3>&) const;
288 VTKM_INSTANTIATION_END
289 VTKM_INSTANTIATION_BEGIN
290 extern template void vtkm::worklet::gradient::DeducedPointGrad<
291  vtkm::cont::CoordinateSystem,
292  vtkm::Vec3f_32,
293  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetStructured<3>&) const;
294 VTKM_INSTANTIATION_END
295 VTKM_INSTANTIATION_BEGIN
296 extern template void vtkm::worklet::gradient::DeducedPointGrad<
297  vtkm::cont::CoordinateSystem,
298  vtkm::Vec3f_64,
299  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetStructured<3>&) const;
300 VTKM_INSTANTIATION_END
301 
302 VTKM_INSTANTIATION_BEGIN
303 extern template void vtkm::worklet::gradient::DeducedPointGrad<
304  vtkm::cont::CoordinateSystem,
305  vtkm::Vec3f_32,
306  vtkm::cont::StorageTagSOA>::operator()(const vtkm::cont::CellSetStructured<3>&) const;
307 VTKM_INSTANTIATION_END
308 VTKM_INSTANTIATION_BEGIN
309 extern template void vtkm::worklet::gradient::DeducedPointGrad<
310  vtkm::cont::CoordinateSystem,
311  vtkm::Vec3f_64,
312  vtkm::cont::StorageTagSOA>::operator()(const vtkm::cont::CellSetStructured<3>&) const;
313 VTKM_INSTANTIATION_END
314 
315 VTKM_INSTANTIATION_BEGIN
316 extern template void vtkm::worklet::gradient::DeducedPointGrad<
317  vtkm::cont::CoordinateSystem,
318  vtkm::Vec3f_32,
319  vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
320  vtkm::cont::StorageTagBasic,
321  vtkm::cont::StorageTagBasic>>::
322 operator()(const vtkm::cont::CellSetStructured<3>&) const;
323 VTKM_INSTANTIATION_END
324 VTKM_INSTANTIATION_BEGIN
325 extern template void vtkm::worklet::gradient::DeducedPointGrad<
326  vtkm::cont::CoordinateSystem,
327  vtkm::Vec3f_64,
328  vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
329  vtkm::cont::StorageTagBasic,
330  vtkm::cont::StorageTagBasic>>::
331 operator()(const vtkm::cont::CellSetStructured<3>&) const;
332 VTKM_INSTANTIATION_END
333 
334 VTKM_INSTANTIATION_BEGIN
335 extern template void vtkm::worklet::gradient::DeducedPointGrad<
336  vtkm::cont::CoordinateSystem,
337  vtkm::Vec3f,
338  vtkm::cont::StorageTagUniformPoints>::operator()(const vtkm::cont::CellSetStructured<3>&) const;
339 VTKM_INSTANTIATION_END
340 
341 
342 //---------------------------------------------------------------------------
343 VTKM_INSTANTIATION_BEGIN
344 extern template void vtkm::worklet::gradient::DeducedPointGrad<
345  vtkm::cont::CoordinateSystem,
346  vtkm::Float32,
347  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetStructured<2>&) const;
348 VTKM_INSTANTIATION_END
349 VTKM_INSTANTIATION_BEGIN
350 extern template void vtkm::worklet::gradient::DeducedPointGrad<
351  vtkm::cont::CoordinateSystem,
352  vtkm::Float64,
353  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetStructured<2>&) const;
354 VTKM_INSTANTIATION_END
355 VTKM_INSTANTIATION_BEGIN
356 extern template void vtkm::worklet::gradient::DeducedPointGrad<
357  vtkm::cont::CoordinateSystem,
358  vtkm::Vec3f_32,
359  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetStructured<2>&) const;
360 VTKM_INSTANTIATION_END
361 VTKM_INSTANTIATION_BEGIN
362 extern template void vtkm::worklet::gradient::DeducedPointGrad<
363  vtkm::cont::CoordinateSystem,
364  vtkm::Vec3f_64,
365  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetStructured<2>&) const;
366 VTKM_INSTANTIATION_END
367 
368 VTKM_INSTANTIATION_BEGIN
369 extern template void vtkm::worklet::gradient::DeducedPointGrad<
370  vtkm::cont::CoordinateSystem,
371  vtkm::Vec3f_32,
372  vtkm::cont::StorageTagSOA>::operator()(const vtkm::cont::CellSetStructured<2>&) const;
373 VTKM_INSTANTIATION_END
374 VTKM_INSTANTIATION_BEGIN
375 extern template void vtkm::worklet::gradient::DeducedPointGrad<
376  vtkm::cont::CoordinateSystem,
377  vtkm::Vec3f_64,
378  vtkm::cont::StorageTagSOA>::operator()(const vtkm::cont::CellSetStructured<2>&) const;
379 VTKM_INSTANTIATION_END
380 
381 VTKM_INSTANTIATION_BEGIN
382 extern template void vtkm::worklet::gradient::DeducedPointGrad<
383  vtkm::cont::CoordinateSystem,
384  vtkm::Vec3f_32,
385  vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
386  vtkm::cont::StorageTagBasic,
387  vtkm::cont::StorageTagBasic>>::
388 operator()(const vtkm::cont::CellSetStructured<2>&) const;
389 VTKM_INSTANTIATION_END
390 VTKM_INSTANTIATION_BEGIN
391 extern template void vtkm::worklet::gradient::DeducedPointGrad<
392  vtkm::cont::CoordinateSystem,
393  vtkm::Vec3f_64,
394  vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
395  vtkm::cont::StorageTagBasic,
396  vtkm::cont::StorageTagBasic>>::
397 operator()(const vtkm::cont::CellSetStructured<2>&) const;
398 VTKM_INSTANTIATION_END
399 
400 VTKM_INSTANTIATION_BEGIN
401 extern template void vtkm::worklet::gradient::DeducedPointGrad<
402  vtkm::cont::CoordinateSystem,
403  vtkm::Vec3f,
404  vtkm::cont::StorageTagUniformPoints>::operator()(const vtkm::cont::CellSetStructured<2>&) const;
405 VTKM_INSTANTIATION_END
406 
407 
408 //---------------------------------------------------------------------------
409 VTKM_INSTANTIATION_BEGIN
410 extern template void vtkm::worklet::gradient::DeducedPointGrad<
411  vtkm::cont::CoordinateSystem,
412  vtkm::Float32,
413  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetExplicit<>&) const;
414 VTKM_INSTANTIATION_END
415 VTKM_INSTANTIATION_BEGIN
416 extern template void vtkm::worklet::gradient::DeducedPointGrad<
417  vtkm::cont::CoordinateSystem,
418  vtkm::Float64,
419  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetExplicit<>&) const;
420 VTKM_INSTANTIATION_END
421 VTKM_INSTANTIATION_BEGIN
422 extern template void vtkm::worklet::gradient::DeducedPointGrad<
423  vtkm::cont::CoordinateSystem,
424  vtkm::Vec3f_32,
425  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetExplicit<>&) const;
426 VTKM_INSTANTIATION_END
427 VTKM_INSTANTIATION_BEGIN
428 extern template void vtkm::worklet::gradient::DeducedPointGrad<
429  vtkm::cont::CoordinateSystem,
430  vtkm::Vec3f_64,
431  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetExplicit<>&) const;
432 VTKM_INSTANTIATION_END
433 
434 VTKM_INSTANTIATION_BEGIN
435 extern template void vtkm::worklet::gradient::DeducedPointGrad<
436  vtkm::cont::CoordinateSystem,
437  vtkm::Vec3f_32,
438  vtkm::cont::StorageTagSOA>::operator()(const vtkm::cont::CellSetExplicit<>&) const;
439 VTKM_INSTANTIATION_END
440 VTKM_INSTANTIATION_BEGIN
441 extern template void vtkm::worklet::gradient::DeducedPointGrad<
442  vtkm::cont::CoordinateSystem,
443  vtkm::Vec3f_64,
444  vtkm::cont::StorageTagSOA>::operator()(const vtkm::cont::CellSetExplicit<>&) const;
445 VTKM_INSTANTIATION_END
446 
447 VTKM_INSTANTIATION_BEGIN
448 extern template void vtkm::worklet::gradient::DeducedPointGrad<
449  vtkm::cont::CoordinateSystem,
450  vtkm::Vec3f_32,
451  vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
452  vtkm::cont::StorageTagBasic,
453  vtkm::cont::StorageTagBasic>>::
454 operator()(const vtkm::cont::CellSetExplicit<>&) const;
455 VTKM_INSTANTIATION_END
456 VTKM_INSTANTIATION_BEGIN
457 extern template void vtkm::worklet::gradient::DeducedPointGrad<
458  vtkm::cont::CoordinateSystem,
459  vtkm::Vec3f_64,
460  vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
461  vtkm::cont::StorageTagBasic,
462  vtkm::cont::StorageTagBasic>>::
463 operator()(const vtkm::cont::CellSetExplicit<>&) const;
464 VTKM_INSTANTIATION_END
465 
466 VTKM_INSTANTIATION_BEGIN
467 extern template void vtkm::worklet::gradient::DeducedPointGrad<
468  vtkm::cont::CoordinateSystem,
469  vtkm::Vec3f,
470  vtkm::cont::StorageTagUniformPoints>::operator()(const vtkm::cont::CellSetExplicit<>&) const;
471 VTKM_INSTANTIATION_END
472 
473 
474 //---------------------------------------------------------------------------
475 VTKM_INSTANTIATION_BEGIN
476 extern template void vtkm::worklet::gradient::DeducedPointGrad<
477  vtkm::cont::CoordinateSystem,
478  vtkm::Float32,
479  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetSingleType<>&) const;
480 VTKM_INSTANTIATION_END
481 VTKM_INSTANTIATION_BEGIN
482 extern template void vtkm::worklet::gradient::DeducedPointGrad<
483  vtkm::cont::CoordinateSystem,
484  vtkm::Float64,
485  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetSingleType<>&) const;
486 VTKM_INSTANTIATION_END
487 VTKM_INSTANTIATION_BEGIN
488 extern template void vtkm::worklet::gradient::DeducedPointGrad<
489  vtkm::cont::CoordinateSystem,
490  vtkm::Vec3f_32,
491  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetSingleType<>&) const;
492 VTKM_INSTANTIATION_END
493 VTKM_INSTANTIATION_BEGIN
494 extern template void vtkm::worklet::gradient::DeducedPointGrad<
495  vtkm::cont::CoordinateSystem,
496  vtkm::Vec3f_64,
497  vtkm::cont::StorageTagBasic>::operator()(const vtkm::cont::CellSetSingleType<>&) const;
498 VTKM_INSTANTIATION_END
499 
500 VTKM_INSTANTIATION_BEGIN
501 extern template void vtkm::worklet::gradient::DeducedPointGrad<
502  vtkm::cont::CoordinateSystem,
503  vtkm::Vec3f_32,
504  vtkm::cont::StorageTagSOA>::operator()(const vtkm::cont::CellSetSingleType<>&) const;
505 VTKM_INSTANTIATION_END
506 VTKM_INSTANTIATION_BEGIN
507 extern template void vtkm::worklet::gradient::DeducedPointGrad<
508  vtkm::cont::CoordinateSystem,
509  vtkm::Vec3f_64,
510  vtkm::cont::StorageTagSOA>::operator()(const vtkm::cont::CellSetSingleType<>&) const;
511 VTKM_INSTANTIATION_END
512 
513 VTKM_INSTANTIATION_BEGIN
514 extern template void vtkm::worklet::gradient::DeducedPointGrad<
515  vtkm::cont::CoordinateSystem,
516  vtkm::Vec3f_32,
517  vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
518  vtkm::cont::StorageTagBasic,
519  vtkm::cont::StorageTagBasic>>::
520 operator()(const vtkm::cont::CellSetSingleType<>&) const;
521 VTKM_INSTANTIATION_END
522 VTKM_INSTANTIATION_BEGIN
523 extern template void vtkm::worklet::gradient::DeducedPointGrad<
524  vtkm::cont::CoordinateSystem,
525  vtkm::Vec3f_64,
526  vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
527  vtkm::cont::StorageTagBasic,
528  vtkm::cont::StorageTagBasic>>::
529 operator()(const vtkm::cont::CellSetSingleType<>&) const;
530 VTKM_INSTANTIATION_END
531 
532 VTKM_INSTANTIATION_BEGIN
533 extern template void vtkm::worklet::gradient::DeducedPointGrad<
534  vtkm::cont::CoordinateSystem,
535  vtkm::Vec3f,
536  vtkm::cont::StorageTagUniformPoints>::operator()(const vtkm::cont::CellSetSingleType<>&) const;
537 VTKM_INSTANTIATION_END
538 
539 
540 
541 //==============================================================================
542 //---------------------------------------------------------------------------
543 VTKM_INSTANTIATION_BEGIN
544 extern template vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 3>>
545 vtkm::worklet::CellGradient::Run(
546  const vtkm::cont::UnknownCellSet&,
547  const vtkm::cont::CoordinateSystem&,
548  const vtkm::cont::ArrayHandle<vtkm::Float32, vtkm::cont::StorageTagBasic>&,
549  GradientOutputFields<vtkm::Float32>&);
550 VTKM_INSTANTIATION_END
551 VTKM_INSTANTIATION_BEGIN
552 extern template vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float64, 3>>
553 vtkm::worklet::CellGradient::Run(
554  const vtkm::cont::UnknownCellSet&,
555  const vtkm::cont::CoordinateSystem&,
556  const vtkm::cont::ArrayHandle<vtkm::Float64, vtkm::cont::StorageTagBasic>&,
557  GradientOutputFields<vtkm::Float64>&);
558 VTKM_INSTANTIATION_END
559 VTKM_INSTANTIATION_BEGIN
560 extern template vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_32, 3>>
561 vtkm::worklet::CellGradient::Run(
562  const vtkm::cont::UnknownCellSet&,
563  const vtkm::cont::CoordinateSystem&,
564  const vtkm::cont::ArrayHandle<vtkm::Vec3f_32, vtkm::cont::StorageTagBasic>&,
565  GradientOutputFields<vtkm::Vec3f_32>&);
566 VTKM_INSTANTIATION_END
567 VTKM_INSTANTIATION_BEGIN
568 extern template vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_64, 3>>
569 vtkm::worklet::CellGradient::Run(
570  const vtkm::cont::UnknownCellSet&,
571  const vtkm::cont::CoordinateSystem&,
572  const vtkm::cont::ArrayHandle<vtkm::Vec3f_64, vtkm::cont::StorageTagBasic>&,
573  GradientOutputFields<vtkm::Vec3f_64>&);
574 VTKM_INSTANTIATION_END
575 
576 VTKM_INSTANTIATION_BEGIN
577 extern template vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_32, 3>>
578 vtkm::worklet::CellGradient::Run(
579  const vtkm::cont::UnknownCellSet&,
580  const vtkm::cont::CoordinateSystem&,
581  const vtkm::cont::ArrayHandle<vtkm::Vec3f_32, vtkm::cont::StorageTagSOA>&,
582  GradientOutputFields<vtkm::Vec3f_32>&);
583 VTKM_INSTANTIATION_END
584 VTKM_INSTANTIATION_BEGIN
585 extern template vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_64, 3>>
586 vtkm::worklet::CellGradient::Run(
587  const vtkm::cont::UnknownCellSet&,
588  const vtkm::cont::CoordinateSystem&,
589  const vtkm::cont::ArrayHandle<vtkm::Vec3f_64, vtkm::cont::StorageTagSOA>&,
590  GradientOutputFields<vtkm::Vec3f_64>&);
591 VTKM_INSTANTIATION_END
592 
593 VTKM_INSTANTIATION_BEGIN
594 extern template vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_32, 3>>
595 vtkm::worklet::CellGradient::Run(
596  const vtkm::cont::UnknownCellSet&,
597  const vtkm::cont::CoordinateSystem&,
598  const vtkm::cont::ArrayHandle<
599  vtkm::Vec3f_32,
600  vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
601  vtkm::cont::StorageTagBasic,
602  vtkm::cont::StorageTagBasic>>&,
603  GradientOutputFields<vtkm::Vec3f_32>&);
604 VTKM_INSTANTIATION_END
605 VTKM_INSTANTIATION_BEGIN
606 extern template vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_64, 3>>
607 vtkm::worklet::CellGradient::Run(
608  const vtkm::cont::UnknownCellSet&,
609  const vtkm::cont::CoordinateSystem&,
610  const vtkm::cont::ArrayHandle<
611  vtkm::Vec3f_64,
612  vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
613  vtkm::cont::StorageTagBasic,
614  vtkm::cont::StorageTagBasic>>&,
615  GradientOutputFields<vtkm::Vec3f_64>&);
616 VTKM_INSTANTIATION_END
617 
618 VTKM_INSTANTIATION_BEGIN
619 extern template vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f, 3>> vtkm::worklet::CellGradient::Run(
620  const vtkm::cont::UnknownCellSet&,
621  const vtkm::cont::CoordinateSystem&,
622  const vtkm::cont::ArrayHandle<vtkm::Vec3f, vtkm::cont::StorageTagUniformPoints>&,
623  GradientOutputFields<vtkm::Vec3f>&);
624 VTKM_INSTANTIATION_END
625 
626 #endif
vtkm::worklet::GradientOutputFields::GradientOutputFields
GradientOutputFields(bool store, bool divergence, bool vorticity, bool qc)
Definition: worklet/Gradient.h:166
vtkm::worklet::GradientOutputFields::PrepareForOutput
vtkm::exec::GradientOutput< T > PrepareForOutput(vtkm::Id size)
Definition: worklet/Gradient.h:203
vtkm::cont::ArrayHandle< T, S >
ArrayHandle.h
vtkm::worklet::PointGradient
Definition: worklet/Gradient.h:228
vtkm
Groups connected points that have the same field value.
Definition: Atomic.h:19
vtkm::worklet::GradientOutputFields::ComputeDivergence
bool ComputeDivergence
Definition: worklet/Gradient.h:224
vtkm::cont::CellSetPermutation
Definition: CastAndCall.h:38
vtkm::worklet::GradientOutputFields::GetComputeDivergence
bool GetComputeDivergence() const
Definition: worklet/Gradient.h:182
vtkm::worklet::GradientOutputFields::ComputeQCriterion
bool ComputeQCriterion
Definition: worklet/Gradient.h:226
CellGradient.h
UnknownCellSet.h
vtkm::cont::CellSetStructured< 3 >
vtkm::worklet::GradientOutputFields::ValueType
T ValueType
Definition: worklet/Gradient.h:145
Instantiations.h
vtkm::cont::StorageTagSOA
Definition: ArrayHandleSOA.h:124
vtkm::worklet::gradient::DeducedPointGrad::Result
GradientOutputFields< T > * Result
Definition: worklet/Gradient.h:122
vtkm::worklet::GradientOutputFields::GetComputeQCriterion
bool GetComputeQCriterion() const
Definition: worklet/Gradient.h:194
vtkm::worklet::gradient::DeducedPointGrad::Go
void Go(const vtkm::cont::CellSetStructured< 2 > &cellset) const
Definition: worklet/Gradient.h:99
DispatcherPointNeighborhood.h
vtkm::cont::CellSetSingleType
Definition: CastAndCall.h:34
vtkm::cont::StorageTagCartesianProduct
Definition: ArrayHandleCartesianProduct.h:159
vtkm::worklet::GradientOutputFields::BaseTType
typename vtkm::VecTraits< T >::BaseComponentType BaseTType
Definition: worklet/Gradient.h:146
vtkm::Vec3f_32
vtkm::Vec< vtkm::Float32, 3 > Vec3f_32
Vec3f_32 corresponds to a 3-dimensional vector of 32-bit floating point values.
Definition: Types.h:1020
PointGradient.h
vtkm::worklet::gradient::DeducedPointGrad::Points
const CoordinateSystem *const Points
Definition: worklet/Gradient.h:120
vtkm::cont::UnknownCellSet
A CellSet of an unknown type.
Definition: UnknownCellSet.h:48
vtkm::cont::CastAndCall
void CastAndCall(const DynamicObject &dynamicObject, Functor &&f, Args &&... args)
A Generic interface to CastAndCall.
Definition: CastAndCall.h:47
CoordinateSystem.h
vtkm::worklet::GradientOutputFields::Gradient
vtkm::cont::ArrayHandle< vtkm::Vec< T, 3 > > Gradient
Definition: worklet/Gradient.h:217
vtkm::worklet::GradientOutputFields::Vorticity
vtkm::cont::ArrayHandle< vtkm::Vec< BaseTType, 3 > > Vorticity
Definition: worklet/Gradient.h:219
vtkm::VecTraits::BaseComponentType
typename vtkm::VecTraits< ComponentType >::BaseComponentType BaseComponentType
Base component type in the vector.
Definition: VecTraits.h:80
vtkm::worklet::gradient::DeducedPointGrad::DeducedPointGrad
DeducedPointGrad(const CoordinateSystem &coords, const vtkm::cont::ArrayHandle< T, S > &field, GradientOutputFields< T > *result)
Definition: worklet/Gradient.h:56
vtkm::Id
vtkm::Int32 Id
Represents an ID (index into arrays).
Definition: Types.h:191
vtkm::worklet::GradientOutputFields::GetComputeGradient
bool GetComputeGradient() const
Definition: worklet/Gradient.h:200
vtkm::worklet::GradientOutputFields::ComputeVorticity
bool ComputeVorticity
Definition: worklet/Gradient.h:225
vtkm::cont::CoordinateSystem
Definition: CoordinateSystem.h:25
vtkm::worklet::gradient::DeducedPointGrad::operator=
void operator=(const DeducedPointGrad< CoordinateSystem, T, S > &)=delete
ArrayHandleUniformPointCoordinates.h
vtkm::Vec3f_64
vtkm::Vec< vtkm::Float64, 3 > Vec3f_64
Vec3f_64 corresponds to a 3-dimensional vector of 64-bit floating point values.
Definition: Types.h:1026
ArrayHandleSOA.h
GradientOutput.h
vtkm::worklet::CellGradient
Definition: worklet/Gradient.h:246
vtkm::worklet::gradient::DeducedPointGrad::operator()
void operator()(const CellSetType &cellset) const
Definition: worklet/Gradient.h:133
Vorticity.h
vtkm::worklet::CellGradient::Run
static vtkm::cont::ArrayHandle< vtkm::Vec< T, 3 > > Run(const CellSetType &cells, const CoordinateSystem &coords, const vtkm::cont::ArrayHandle< T, S > &field, GradientOutputFields< T > &extraOutput)
Definition: worklet/Gradient.h:260
vtkm::worklet::DispatcherMapTopology
Dispatcher for worklets that inherit from WorkletMapTopology.
Definition: DispatcherMapTopology.h:31
Divergence.h
vtkm::worklet::GradientOutputFields
Definition: worklet/Gradient.h:47
vtkm::cont::StorageTagUniformPoints
Definition: ArrayHandleUniformPointCoordinates.h:22
VTKM_INSTANTIATION_END
#define VTKM_INSTANTIATION_END
Definition: Instantiations.h:48
ArrayHandleCartesianProduct.h
vtkm::worklet::GradientOutputFields::GradientOutputFields
GradientOutputFields()
Definition: worklet/Gradient.h:154
vtkm::worklet::GradientOutputFields::StoreGradient
bool StoreGradient
Definition: worklet/Gradient.h:223
vtkm::worklet::GradientOutputFields::SetComputeQCriterion
void SetComputeQCriterion(bool enable)
Add Q-criterion field to the output data.
Definition: worklet/Gradient.h:193
vtkm::worklet::GradientOutputFields::Divergence
vtkm::cont::ArrayHandle< BaseTType > Divergence
Definition: worklet/Gradient.h:218
Transpose.h
vtkm::worklet::GradientOutputFields::SetComputeGradient
void SetComputeGradient(bool enable)
Add gradient field to the output data.
Definition: worklet/Gradient.h:199
vtkm::Vec3f
vtkm::Vec< vtkm::FloatDefault, 3 > Vec3f
Vec3f corresponds to a 3-dimensional vector of floating point values.
Definition: Types.h:1014
vtkm::cont::ExecutionObjectBase
Base ExecutionObjectBase for execution objects to inherit from so that you can use an arbitrary objec...
Definition: ExecutionObjectBase.h:31
vtkm::Vec< vtkm::Float32, 3 >
vtkm::worklet::GradientOutputFields::ExecutionTypes
Definition: worklet/Gradient.h:149
vtkm::exec::GradientOutput
Definition: GradientOutput.h:237
vtkm::worklet::gradient::DeducedPointGrad::Go
void Go(const vtkm::cont::CellSetPermutation< vtkm::cont::CellSetStructured< 2 >, PermIterType > &cellset) const
Definition: worklet/Gradient.h:109
vtkm::worklet::GradientOutputFields::SetComputeDivergence
void SetComputeDivergence(bool enable)
Add divergence field to the output data.
Definition: worklet/Gradient.h:181
vtkm::worklet::gradient::DeducedPointGrad::Go
void Go(const vtkm::cont::CellSetPermutation< vtkm::cont::CellSetStructured< 3 >, PermIterType > &cellset) const
Definition: worklet/Gradient.h:89
vtkm::worklet::GradientOutputFields::GetComputeVorticity
bool GetComputeVorticity() const
Definition: worklet/Gradient.h:188
vtkm::cont::CellSetExplicit
Definition: CastAndCall.h:36
vtkm::worklet::PointGradient::Run
vtkm::cont::ArrayHandle< vtkm::Vec< T, 3 > > Run(const CellSetType &cells, const CoordinateSystem &coords, const vtkm::cont::ArrayHandle< T, S > &field, GradientOutputFields< T > &extraOutput)
Definition: worklet/Gradient.h:232
vtkm::worklet::GradientOutputFields::SetComputeVorticity
void SetComputeVorticity(bool enable)
Add voriticity/curl field to the output data.
Definition: worklet/Gradient.h:187
vtkm::Float32
float Float32
Definition: Types.h:154
vtkm::worklet::DispatcherPointNeighborhood
Dispatcher for worklets that inherit from WorkletPointNeighborhood.
Definition: DispatcherPointNeighborhood.h:26
vtkm::cont::StorageTagBasic
A tag for the basic implementation of a Storage object.
Definition: ArrayHandle.h:45
vtkm::Float64
double Float64
Definition: Types.h:155
vtkm::worklet::gradient::DeducedPointGrad
Definition: worklet/Gradient.h:54
QCriterion.h
vtkm::worklet::gradient::DeducedPointGrad::Go
void Go(const CellSetType &cellset) const
Definition: worklet/Gradient.h:69
DispatcherMapTopology.h
vtkm::worklet::gradient::DeducedPointGrad::Field
const vtkm::cont::ArrayHandle< T, S > *const Field
Definition: worklet/Gradient.h:121
vtkm::worklet::gradient::DeducedPointGrad::Go
void Go(const vtkm::cont::CellSetStructured< 3 > &cellset) const
Definition: worklet/Gradient.h:79
VTKM_INSTANTIATION_BEGIN
#define VTKM_INSTANTIATION_BEGIN
The following empty macros are instantiation delimiters used by vtk_add_instantiations at CMake/VTKmW...
Definition: Instantiations.h:47
StructuredPointGradient.h
vtkm::worklet::GradientOutputFields::QCriterion
vtkm::cont::ArrayHandle< BaseTType > QCriterion
Definition: worklet/Gradient.h:220
Generated by   doxygen 1.8.17