VTK-m  2.2
StreamLineUniformGrid.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_StreamLineUniformGrid_h
12 #define vtk_m_worklet_StreamLineUniformGrid_h
13 
14 #include <vtkm/cont/Algorithm.h>
15 #include <vtkm/cont/ArrayHandle.h>
16 #include <vtkm/cont/ArrayHandleCounting.h>
17 #include <vtkm/cont/CellSetExplicit.h>
18 #include <vtkm/cont/CellSetStructured.h>
19 #include <vtkm/cont/ConvertNumComponentsToOffsets.h>
20 #include <vtkm/cont/DataSet.h>
21 #include <vtkm/cont/DeviceAdapter.h>
22 #include <vtkm/cont/Field.h>
23 #include <vtkm/cont/Invoker.h>
24 
25 #include <vtkm/worklet/ScatterUniform.h>
26 #include <vtkm/worklet/WorkletMapField.h>
27 
28 namespace vtkm
29 {
30 namespace worklet
31 {
32 namespace streamline
33 {
34 // Take this out when defined in CellShape.h
35 const vtkm::UInt8 CELL_SHAPE_POLY_LINE = 4;
36 
37 enum StreamLineMode
38 {
39  FORWARD = 0,
40  BACKWARD = 1,
41  BOTH = 2
42 };
43 
44 // Trilinear interpolation to calculate vector data at position
45 template <typename FieldType, typename PortalType>
46 VTKM_EXEC vtkm::Vec<FieldType, 3> VecDataAtPos(vtkm::Vec<FieldType, 3> pos,
47  const vtkm::Id3& vdims,
48  const vtkm::Id& planesize,
49  const vtkm::Id& rowsize,
50  const PortalType& vecdata)
51 {
52  // Adjust initial position to be within bounding box of grid
53  for (vtkm::IdComponent d = 0; d < 3; d++)
54  {
55  if (pos[d] < 0.0f)
56  pos[d] = 0.0f;
57  if (pos[d] > static_cast<FieldType>(vdims[d] - 1))
58  pos[d] = static_cast<FieldType>(vdims[d] - 1);
59  }
60 
61  // Set the eight corner indices with no wraparound
62  vtkm::Id3 idx000, idx001, idx010, idx011, idx100, idx101, idx110, idx111;
63  idx000[0] = static_cast<vtkm::Id>(floor(pos[0]));
64  idx000[1] = static_cast<vtkm::Id>(floor(pos[1]));
65  idx000[2] = static_cast<vtkm::Id>(floor(pos[2]));
66 
67  idx001 = idx000;
68  idx001[0] = (idx001[0] + 1) <= vdims[0] - 1 ? idx001[0] + 1 : vdims[0] - 1;
69  idx010 = idx000;
70  idx010[1] = (idx010[1] + 1) <= vdims[1] - 1 ? idx010[1] + 1 : vdims[1] - 1;
71  idx011 = idx010;
72  idx011[0] = (idx011[0] + 1) <= vdims[0] - 1 ? idx011[0] + 1 : vdims[0] - 1;
73  idx100 = idx000;
74  idx100[2] = (idx100[2] + 1) <= vdims[2] - 1 ? idx100[2] + 1 : vdims[2] - 1;
75  idx101 = idx100;
76  idx101[0] = (idx101[0] + 1) <= vdims[0] - 1 ? idx101[0] + 1 : vdims[0] - 1;
77  idx110 = idx100;
78  idx110[1] = (idx110[1] + 1) <= vdims[1] - 1 ? idx110[1] + 1 : vdims[1] - 1;
79  idx111 = idx110;
80  idx111[0] = (idx111[0] + 1) <= vdims[0] - 1 ? idx111[0] + 1 : vdims[0] - 1;
81 
82  // Get the vecdata at the eight corners
83  vtkm::Vec<FieldType, 3> v000, v001, v010, v011, v100, v101, v110, v111;
84  v000 = vecdata.Get(idx000[2] * planesize + idx000[1] * rowsize + idx000[0]);
85  v001 = vecdata.Get(idx001[2] * planesize + idx001[1] * rowsize + idx001[0]);
86  v010 = vecdata.Get(idx010[2] * planesize + idx010[1] * rowsize + idx010[0]);
87  v011 = vecdata.Get(idx011[2] * planesize + idx011[1] * rowsize + idx011[0]);
88  v100 = vecdata.Get(idx100[2] * planesize + idx100[1] * rowsize + idx100[0]);
89  v101 = vecdata.Get(idx101[2] * planesize + idx101[1] * rowsize + idx101[0]);
90  v110 = vecdata.Get(idx110[2] * planesize + idx110[1] * rowsize + idx110[0]);
91  v111 = vecdata.Get(idx111[2] * planesize + idx111[1] * rowsize + idx111[0]);
92 
93  // Interpolation in X
94  vtkm::Vec<FieldType, 3> v00, v01, v10, v11;
95  FieldType a = pos[0] - static_cast<FieldType>(floor(pos[0]));
96  v00[0] = (1.0f - a) * v000[0] + a * v001[0];
97  v00[1] = (1.0f - a) * v000[1] + a * v001[1];
98  v00[2] = (1.0f - a) * v000[2] + a * v001[2];
99 
100  v01[0] = (1.0f - a) * v010[0] + a * v011[0];
101  v01[1] = (1.0f - a) * v010[1] + a * v011[1];
102  v01[2] = (1.0f - a) * v010[2] + a * v011[2];
103 
104  v10[0] = (1.0f - a) * v100[0] + a * v101[0];
105  v10[1] = (1.0f - a) * v100[1] + a * v101[1];
106  v10[2] = (1.0f - a) * v100[2] + a * v101[2];
107 
108  v11[0] = (1.0f - a) * v110[0] + a * v111[0];
109  v11[1] = (1.0f - a) * v110[1] + a * v111[1];
110  v11[2] = (1.0f - a) * v110[2] + a * v111[2];
111 
112  // Interpolation in Y
113  vtkm::Vec<FieldType, 3> v0, v1;
114  a = pos[1] - static_cast<FieldType>(floor(pos[1]));
115  v0[0] = (1.0f - a) * v00[0] + a * v01[0];
116  v0[1] = (1.0f - a) * v00[1] + a * v01[1];
117  v0[2] = (1.0f - a) * v00[2] + a * v01[2];
118 
119  v1[0] = (1.0f - a) * v10[0] + a * v11[0];
120  v1[1] = (1.0f - a) * v10[1] + a * v11[1];
121  v1[2] = (1.0f - a) * v10[2] + a * v11[2];
122 
123  // Interpolation in Z
124  vtkm::Vec<FieldType, 3> v;
125  a = pos[2] - static_cast<FieldType>(floor(pos[2]));
126  v[0] = (1.0f - a) * v0[0] + v1[0];
127  v[1] = (1.0f - a) * v0[1] + v1[1];
128  v[2] = (1.0f - a) * v0[2] + v1[2];
129  return v;
130 }
131 
132 struct IsUnity
133 {
134  template <typename T>
135  VTKM_EXEC_CONT bool operator()(const T& x) const
136  {
137  return x == T(1);
138  }
139 };
140 
141 template <typename FieldType>
142 class MakeStreamLines : public vtkm::worklet::WorkletMapField
143 {
144 public:
145  using ControlSignature = void(WholeArrayIn field,
146  FieldIn seedId,
147  FieldIn position,
148  WholeArrayOut numIndices,
149  WholeArrayOut validPoint,
150  WholeArrayOut streamLines);
151  using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, VisitIndex);
152  using InputDomain = _2;
153 
154  using ScatterType = vtkm::worklet::ScatterUniform<2>;
155 
156  const vtkm::Id3 vdims;
157  const vtkm::Id maxsteps;
158  const FieldType timestep;
159  const vtkm::Id planesize;
160  const vtkm::Id rowsize;
161  const vtkm::Id streammode;
162 
163  VTKM_CONT
164  MakeStreamLines() {}
165 
166  VTKM_CONT
167  MakeStreamLines(const FieldType tStep,
168  const vtkm::Id sMode,
169  const vtkm::Id nSteps,
170  const vtkm::Id3 dims)
171  : vdims(dims)
172  , maxsteps(nSteps)
173  , timestep(tStep)
174  , planesize(dims[0] * dims[1])
175  , rowsize(dims[0])
176  , streammode(sMode)
177  {
178  }
179 
180  template <typename FieldPortalType, typename IdComponentPortalType, typename FieldVec3PortalType>
181  VTKM_EXEC void operator()(const FieldPortalType& field,
182  vtkm::Id& seedId,
183  vtkm::Vec<FieldType, 3>& seedPos,
184  IdComponentPortalType& numIndices,
185  IdComponentPortalType& validPoint,
186  FieldVec3PortalType& slLists,
187  vtkm::IdComponent visitIndex) const
188  {
189  // Set initial offset into the output streams array
190  vtkm::Vec<FieldType, 3> pos = seedPos;
191  vtkm::Vec<FieldType, 3> pre_pos = seedPos;
192 
193  // Forward tracing
194  if (visitIndex == 0 && (streammode == FORWARD || streammode == BOTH))
195  {
196  vtkm::Id index = (seedId * 2) * maxsteps;
197  bool done = false;
198  vtkm::Id step = 0;
199  validPoint.Set(index, 1);
200  slLists.Set(index++, pos);
201 
202  while (done != true && step < maxsteps)
203  {
204  vtkm::Vec<FieldType, 3> vdata, adata, bdata, cdata, ddata;
205  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
206  for (vtkm::IdComponent d = 0; d < 3; d++)
207  {
208  adata[d] = timestep * vdata[d];
209  pos[d] += adata[d] / 2.0f;
210  }
211 
212  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
213  for (vtkm::IdComponent d = 0; d < 3; d++)
214  {
215  bdata[d] = timestep * vdata[d];
216  pos[d] += bdata[d] / 2.0f;
217  }
218 
219  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
220  for (vtkm::IdComponent d = 0; d < 3; d++)
221  {
222  cdata[d] = timestep * vdata[d];
223  pos[d] += cdata[d] / 2.0f;
224  }
225 
226  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
227  for (vtkm::IdComponent d = 0; d < 3; d++)
228  {
229  ddata[d] = timestep * vdata[d];
230  pos[d] += (adata[d] + (2.0f * bdata[d]) + (2.0f * cdata[d]) + ddata[d]) / 6.0f;
231  }
232 
233  if (pos[0] < 0.0f || pos[0] > static_cast<FieldType>(vdims[0]) || pos[1] < 0.0f ||
234  pos[1] > static_cast<FieldType>(vdims[1]) || pos[2] < 0.0f ||
235  pos[2] > static_cast<FieldType>(vdims[2]))
236  {
237  pos = pre_pos;
238  done = true;
239  }
240  else
241  {
242  validPoint.Set(index, 1);
243  slLists.Set(index++, pos);
244  pre_pos = pos;
245  }
246  step++;
247  }
248  numIndices.Set(seedId * 2, static_cast<vtkm::IdComponent>(step));
249  }
250 
251  // Backward tracing
252  if (visitIndex == 1 && (streammode == BACKWARD || streammode == BOTH))
253  {
254  vtkm::Id index = (seedId * 2 + 1) * maxsteps;
255  bool done = false;
256  vtkm::Id step = 0;
257  validPoint.Set(index, 1);
258  slLists.Set(index++, pos);
259 
260  while (done != true && step < maxsteps)
261  {
262  vtkm::Vec<FieldType, 3> vdata, adata, bdata, cdata, ddata;
263  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
264  for (vtkm::IdComponent d = 0; d < 3; d++)
265  {
266  adata[d] = timestep * (0.0f - vdata[d]);
267  pos[d] += adata[d] / 2.0f;
268  }
269 
270  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
271  for (vtkm::IdComponent d = 0; d < 3; d++)
272  {
273  bdata[d] = timestep * (0.0f - vdata[d]);
274  pos[d] += bdata[d] / 2.0f;
275  }
276 
277  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
278  for (vtkm::IdComponent d = 0; d < 3; d++)
279  {
280  cdata[d] = timestep * (0.0f - vdata[d]);
281  pos[d] += cdata[d] / 2.0f;
282  }
283 
284  vdata = VecDataAtPos(pos, vdims, planesize, rowsize, field);
285  for (vtkm::IdComponent d = 0; d < 3; d++)
286  {
287  ddata[d] = timestep * (0.0f - vdata[d]);
288  pos[d] += (adata[d] + (2.0f * bdata[d]) + (2.0f * cdata[d]) + ddata[d]) / 6.0f;
289  }
290 
291  if (pos[0] < 0.0f || pos[0] > static_cast<FieldType>(vdims[0]) || pos[1] < 0.0f ||
292  pos[1] > static_cast<FieldType>(vdims[1]) || pos[2] < 0.0f ||
293  pos[2] > static_cast<FieldType>(vdims[2]))
294  {
295  pos = pre_pos;
296  done = true;
297  }
298  else
299  {
300  validPoint.Set(index, 1);
301  slLists.Set(index++, pos);
302  pre_pos = pos;
303  }
304  step++;
305  }
306  numIndices.Set((seedId * 2) + 1, static_cast<vtkm::IdComponent>(step));
307  }
308  }
309 };
310 
311 
312 } // namespace streamline
313 
315 template <typename FieldType>
316 class StreamLineFilterUniformGrid
317 {
318 public:
319  StreamLineFilterUniformGrid() {}
320 
321  vtkm::cont::DataSet Run(const vtkm::cont::DataSet& InDataSet,
322  vtkm::Id streamMode,
323  vtkm::Id numSeeds,
324  vtkm::Id maxSteps,
325  FieldType timeStep)
326  {
327  using Algorithm = vtkm::cont::Algorithm;
328 
329  // Get information from input dataset
330  vtkm::cont::CellSetStructured<3> inCellSet;
331  InDataSet.GetCellSet().AsCellSet(inCellSet);
332  vtkm::Id3 vdims = inCellSet.GetSchedulingRange(vtkm::TopologyElementTagPoint());
333 
334  vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> fieldArray;
335  InDataSet.GetField("vecData").GetData().AsArrayHandle(fieldArray);
336 
337  // Generate random seeds for starting streamlines
338  vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> seedPosArray;
339  seedPosArray.Allocate(numSeeds);
340  {
341  auto seedPosPortal = seedPosArray.WritePortal();
342  for (vtkm::Id i = 0; i < numSeeds; i++)
343  {
344  vtkm::Vec<FieldType, 3> seed;
345  seed[0] = static_cast<FieldType>(rand() % vdims[0]);
346  seed[1] = static_cast<FieldType>(rand() % vdims[1]);
347  seed[2] = static_cast<FieldType>(rand() % vdims[2]);
348  seedPosPortal.Set(i, seed);
349  }
350  }
351  vtkm::cont::ArrayHandleIndex seedIdArray(numSeeds);
352 
353  // Number of streams * number of steps * [forward, backward]
354  vtkm::Id numCells = numSeeds * 2;
355  vtkm::Id maxConnectivityLen = numCells * maxSteps;
356 
357  // Stream array at max size will be filled with stream coordinates
358  vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> streamArray;
359  streamArray.Allocate(maxConnectivityLen);
360 
361  // NumIndices per polyline cell filled in by MakeStreamLines
362  vtkm::cont::ArrayHandle<vtkm::IdComponent> numIndices;
363  numIndices.Allocate(numCells);
364 
365  // All cells are polylines
366  vtkm::cont::ArrayHandle<vtkm::UInt8> cellTypes;
367  cellTypes.Allocate(numCells);
368  vtkm::cont::ArrayHandleConstant<vtkm::UInt8> polyLineShape(streamline::CELL_SHAPE_POLY_LINE,
369  numCells);
370  Algorithm::Copy(polyLineShape, cellTypes);
371 
372  // Possible maxSteps points but if less use stencil
373  vtkm::cont::ArrayHandle<vtkm::IdComponent> validPoint;
374  vtkm::cont::ArrayHandleConstant<vtkm::Id> zeros(0, maxConnectivityLen);
375  validPoint.Allocate(maxConnectivityLen);
376  Algorithm::Copy(zeros, validPoint);
377 
378  // Worklet to make the streamlines
379  streamline::MakeStreamLines<FieldType> makeStreamLines(timeStep, streamMode, maxSteps, vdims);
380 
381  vtkm::cont::Invoker{}(
382  makeStreamLines, fieldArray, seedIdArray, seedPosArray, numIndices, validPoint, streamArray);
383 
384  // Size of connectivity based on size of returned streamlines
385  vtkm::Id connectivityLen;
386  auto offsets = vtkm::cont::ConvertNumComponentsToOffsets(numIndices, connectivityLen);
387 
388  // Connectivity is sequential
389  vtkm::cont::ArrayHandleCounting<vtkm::Id> connCount(0, 1, connectivityLen);
390  vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
391  Algorithm::Copy(connCount, connectivity);
392 
393  // Compact the stream array so it only has valid points
394  vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> coordinates;
395  Algorithm::CopyIf(streamArray, validPoint, coordinates, streamline::IsUnity());
396 
397  // Create the output data set
398  vtkm::cont::DataSet OutDataSet;
399  vtkm::cont::CellSetExplicit<> outCellSet;
400 
401  outCellSet.Fill(coordinates.GetNumberOfValues(), cellTypes, connectivity, offsets);
402  OutDataSet.SetCellSet(outCellSet);
403  OutDataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
404 
405  return OutDataSet;
406  }
407 };
408 }
409 }
410 
411 #endif // vtk_m_worklet_StreamLineUniformGrid_h
vtkm::TopologyElementTagPoint
A tag used to identify the point elements in a topology.
Definition: TopologyElementTag.h:34
vtkm::worklet::StreamLineFilterUniformGrid::Run
vtkm::cont::DataSet Run(const vtkm::cont::DataSet &InDataSet, vtkm::Id streamMode, vtkm::Id numSeeds, vtkm::Id maxSteps, FieldType timeStep)
Definition: StreamLineUniformGrid.h:321
vtkm::cont::DataSet::GetCellSet
const vtkm::cont::UnknownCellSet & GetCellSet() const
Definition: DataSet.h:403
vtkm::cont::ArrayHandle
Manages an array-worth of data.
Definition: ArrayHandle.h:300
ArrayHandle.h
VTKM_EXEC
#define VTKM_EXEC
Definition: ExportMacros.h:51
vtkm
Groups connected points that have the same field value.
Definition: Atomic.h:19
vtkm::worklet::streamline::BACKWARD
@ BACKWARD
Definition: StreamLineUniformGrid.h:40
vtkm::worklet::streamline::MakeStreamLines::MakeStreamLines
MakeStreamLines()
Definition: StreamLineUniformGrid.h:164
WorkletMapField.h
CellSetExplicit.h
VTKM_EXEC_CONT
#define VTKM_EXEC_CONT
Definition: ExportMacros.h:52
ScatterUniform.h
vtkm::worklet::streamline::IsUnity
Definition: StreamLineUniformGrid.h:132
vtkm::IdComponent
vtkm::Int32 IdComponent
Base type to use to index small lists.
Definition: Types.h:194
vtkm::cont::CellSetStructured
Defines a 1-, 2-, or 3-dimensional structured grid of points.
Definition: CastAndCall.h:32
vtkm::worklet::streamline::MakeStreamLines::operator()
void operator()(const FieldPortalType &field, vtkm::Id &seedId, vtkm::Vec< FieldType, 3 > &seedPos, IdComponentPortalType &numIndices, IdComponentPortalType &validPoint, FieldVec3PortalType &slLists, vtkm::IdComponent visitIndex) const
Definition: StreamLineUniformGrid.h:181
vtkm::worklet::streamline::MakeStreamLines::timestep
const FieldType timestep
Definition: StreamLineUniformGrid.h:158
vtkm::worklet::ScatterUniform
A scatter that maps input to some constant numbers of output.
Definition: ScatterUniform.h:53
vtkm::cont::DataSet::GetField
const vtkm::cont::Field & GetField(vtkm::Id index) const
Retrieves a field by index.
Definition: DataSet.h:108
vtkm::cont::DataSet::SetCellSet
void SetCellSet(const CellSetType &cellSet)
Definition: DataSet.h:396
vtkm::worklet::StreamLineFilterUniformGrid
Compute the streamline.
Definition: StreamLineUniformGrid.h:316
vtkm::cont::DataSet
Contains and manages the geometric data structures that VTK-m operates on.
Definition: DataSet.h:57
vtkm::cont::ArrayHandle::GetNumberOfValues
vtkm::Id GetNumberOfValues() const
Returns the number of entries in the array.
Definition: ArrayHandle.h:468
vtkm::worklet::streamline::MakeStreamLines::streammode
const vtkm::Id streammode
Definition: StreamLineUniformGrid.h:161
Invoker.h
vtkm::cont::UnknownArrayHandle::AsArrayHandle
void AsArrayHandle(vtkm::cont::ArrayHandle< T, S > &array) const
Returns this array cast appropriately and stored in the given ArrayHandle type.
Definition: UnknownArrayHandle.h:657
vtkm::worklet::streamline::MakeStreamLines::ControlSignature
void(WholeArrayIn field, FieldIn seedId, FieldIn position, WholeArrayOut numIndices, WholeArrayOut validPoint, WholeArrayOut streamLines) ControlSignature
Definition: StreamLineUniformGrid.h:150
vtkm::cont::UnknownCellSet::AsCellSet
void AsCellSet(CellSetType &cellSet) const
Get the cell set as a known type.
Definition: UnknownCellSet.h:178
vtkm::cont::CellSetExplicit::Fill
void Fill(vtkm::Id numPoints, const vtkm::cont::ArrayHandle< vtkm::UInt8, ShapesStorageTag > &cellTypes, const vtkm::cont::ArrayHandle< vtkm::Id, ConnectivityStorageTag > &connectivity, const vtkm::cont::ArrayHandle< vtkm::Id, OffsetsStorageTag > &offsets)
Set all the cells of the mesh.
vtkm::cont::Field::GetData
const vtkm::cont::UnknownArrayHandle & GetData() const
Get the array of the data for the field.
vtkm::worklet::streamline::MakeStreamLines::ExecutionSignature
void(_1, _2, _3, _4, _5, _6, VisitIndex) ExecutionSignature
Definition: StreamLineUniformGrid.h:151
vtkm::cont::CoordinateSystem
Manages a coordinate system for a DataSet.
Definition: CoordinateSystem.h:30
DeviceAdapter.h
vtkm::worklet::streamline::MakeStreamLines::rowsize
const vtkm::Id rowsize
Definition: StreamLineUniformGrid.h:160
vtkm::cont::ConvertNumComponentsToOffsets
void ConvertNumComponentsToOffsets(const vtkm::cont::UnknownArrayHandle &numComponentsArray, vtkm::cont::ArrayHandle< vtkm::Id > &offsetsArray, vtkm::Id &componentsArraySize, vtkm::cont::DeviceAdapterId device=vtkm::cont::DeviceAdapterTagAny{})
ConvertNumComponentsToOffsets takes an array of Vec sizes (i.e.
Algorithm.h
vtkm::worklet::streamline::CELL_SHAPE_POLY_LINE
const vtkm::UInt8 CELL_SHAPE_POLY_LINE
Definition: StreamLineUniformGrid.h:35
vtkm::worklet::WorkletMapField::FieldIn
A control signature tag for input fields.
Definition: WorkletMapField.h:60
vtkm::worklet::streamline::VecDataAtPos
vtkm::Vec< FieldType, 3 > VecDataAtPos(vtkm::Vec< FieldType, 3 > pos, const vtkm::Id3 &vdims, const vtkm::Id &planesize, const vtkm::Id &rowsize, const PortalType &vecdata)
Definition: StreamLineUniformGrid.h:46
vtkm::cont::ArrayHandleCounting
ArrayHandleCounting is a specialization of ArrayHandle.
Definition: ArrayHandleCounting.h:130
vtkm::cont::Invoker
Allows launching any worklet without a dispatcher.
Definition: Invoker.h:41
vtkm::worklet::StreamLineFilterUniformGrid::StreamLineFilterUniformGrid
StreamLineFilterUniformGrid()
Definition: StreamLineUniformGrid.h:319
vtkm::cont::CellSetStructured::GetSchedulingRange
SchedulingRangeType GetSchedulingRange(TopologyElement) const
Definition: CellSetStructured.h:131
VTKM_CONT
#define VTKM_CONT
Definition: ExportMacros.h:57
Field.h
vtkm::Id
vtkm::Int64 Id
Base type to use to index arrays.
Definition: Types.h:227
vtkm::cont::ArrayHandleConstant
An array handle with a constant value.
Definition: ArrayHandleConstant.h:70
vtkm::UInt8
uint8_t UInt8
Base type to use for 8-bit unsigned integer numbers.
Definition: Types.h:169
vtkm::worklet::streamline::MakeStreamLines::MakeStreamLines
MakeStreamLines(const FieldType tStep, const vtkm::Id sMode, const vtkm::Id nSteps, const vtkm::Id3 dims)
Definition: StreamLineUniformGrid.h:167
vtkm::cont::DataSet::AddCoordinateSystem
vtkm::IdComponent AddCoordinateSystem(const vtkm::cont::CoordinateSystem &cs)
Adds the given CoordinateSystem to the DataSet.
vtkm::worklet::streamline::FORWARD
@ FORWARD
Definition: StreamLineUniformGrid.h:39
vtkm::cont::Algorithm
Definition: Algorithm.h:386
vtkm::Vec
A short fixed-length array.
Definition: Types.h:357
vtkm::worklet::streamline::MakeStreamLines::planesize
const vtkm::Id planesize
Definition: StreamLineUniformGrid.h:159
vtkm::worklet::streamline::StreamLineMode
StreamLineMode
Definition: StreamLineUniformGrid.h:37
vtkm::worklet::streamline::MakeStreamLines::maxsteps
const vtkm::Id maxsteps
Definition: StreamLineUniformGrid.h:157
ConvertNumComponentsToOffsets.h
vtkm::cont::CellSetExplicit
Defines an irregular collection of cells.
Definition: CastAndCall.h:36
ArrayHandleCounting.h
CellSetStructured.h
vtkm::worklet::ScatterIdentity
A scatter that maps input directly to output.
Definition: ScatterIdentity.h:30
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:490
vtkm::worklet::streamline::MakeStreamLines::vdims
const vtkm::Id3 vdims
Definition: StreamLineUniformGrid.h:156
vtkm::worklet::streamline::MakeStreamLines
Definition: StreamLineUniformGrid.h:142
vtkm::exec::arg::VisitIndex
The ExecutionSignature tag to use to get the visit index.
Definition: VisitIndex.h:46
vtkm::cont::ArrayHandle::WritePortal
WritePortalType WritePortal() const
Get an array portal that can be used in the control environment.
Definition: ArrayHandle.h:454
vtkm::worklet::streamline::BOTH
@ BOTH
Definition: StreamLineUniformGrid.h:41
DataSet.h
vtkm::cont::ArrayHandleIndex
An implicit array handle containing the its own indices.
Definition: ArrayHandleIndex.h:55
vtkm::worklet::WorkletMapField
Base class for worklets that do a simple mapping of field arrays.
Definition: WorkletMapField.h:39
vtkm::worklet::streamline::IsUnity::operator()
bool operator()(const T &x) const
Definition: StreamLineUniformGrid.h:135
Generated by   doxygen 1.8.17