VTK-m  2.0
CreateSuperarcsWorklet.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 // Copyright (c) 2018, The Regents of the University of California, through
11 // Lawrence Berkeley National Laboratory (subject to receipt of any required approvals
12 // from the U.S. Dept. of Energy). All rights reserved.
13 //
14 // Redistribution and use in source and binary forms, with or without modification,
15 // are permitted provided that the following conditions are met:
16 //
17 // (1) Redistributions of source code must retain the above copyright notice, this
18 // list of conditions and the following disclaimer.
19 //
20 // (2) Redistributions in binary form must reproduce the above copyright notice,
21 // this list of conditions and the following disclaimer in the documentation
22 // and/or other materials provided with the distribution.
23 //
24 // (3) Neither the name of the University of California, Lawrence Berkeley National
25 // Laboratory, U.S. Dept. of Energy nor the names of its contributors may be
26 // used to endorse or promote products derived from this software without
27 // specific prior written permission.
28 //
29 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
30 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
31 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
32 // IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
33 // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
34 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
36 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
37 // OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
38 // OF THE POSSIBILITY OF SUCH DAMAGE.
39 //
40 //=============================================================================
41 // The PPP2 algorithm and software were jointly developed by
42 // Hamish Carr (University of Leeds), Gunther H. Weber (LBNL), and
43 // Oliver Ruebel (LBNL)
44 //==============================================================================
45 
46 #ifndef vtk_m_worklet_contourtree_distributed_hierarchical_augmenter_create_superarcs_worklet_h
47 #define vtk_m_worklet_contourtree_distributed_hierarchical_augmenter_create_superarcs_worklet_h
48 
51 
52 namespace vtkm
53 {
54 namespace worklet
55 {
56 namespace contourtree_distributed
57 {
58 namespace hierarchical_augmenter
59 {
60 
65 {
66 public:
67  // TODO: Check if augmentedTreeFirstSupernodePerIteration could be changed to WholeArrayOut or if we need the In to preserve orignal values
68 
99  using ControlSignature = void(
100  WholeArrayIn supernodeSorter,
101  WholeArrayIn superparentSet, // input
102  WholeArrayIn baseTreeSuperarcs, // input
103  WholeArrayIn newSupernodeIds, // input
104  WholeArrayIn baseTreeSupernodes, // input
105  WholeArrayIn baseTreeRegularNodeGlobalIds, // input
106  FieldIn globalRegularIdSet, // input
107  WholeArrayIn baseTreeSuper2Hypernode, // input
108  WholeArrayIn baseTreeWhichIteration, // input
109  FieldOut augmentedTreeSuperarcsView, // output
110  WholeArrayInOut augmentedTreeFirstSupernodePerIteration, // input/output
111  FieldOut augmentedTreeSuper2hypernode // ouput
112  );
113  using ExecutionSignature = void(InputIndex, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12);
114  using InputDomain = _1;
115 
123  CreateSuperarcsWorklet(const vtkm::Id& numSupernodesAlready,
124  const vtkm::Id& baseTreeNumRounds,
125  const vtkm::Id& augmentedTreeNumIterations,
126  const vtkm::Id& roundNumber,
127  const vtkm::Id& numAugmentedTreeSupernodes)
128  : NumSupernodesAlready(numSupernodesAlready)
129  , BaseTreeNumRounds(baseTreeNumRounds)
130  , AugmentedTreeNumIterations(augmentedTreeNumIterations)
131  , RoundNumber(roundNumber)
132  , NumAugmentedTreeSupernodes(numAugmentedTreeSupernodes)
133  {
134  }
135 
137  template <typename InFieldPortalType, typename InOutFieldPortalType>
139  const vtkm::Id& supernode, // InputIndex of supernodeSorter
140  const InFieldPortalType& supernodeSorterPortal,
141  const InFieldPortalType& superparentSetPortal,
142  const InFieldPortalType& baseTreeSuperarcsPortal,
143  const InFieldPortalType& newSupernodeIdsPortal,
144  const InFieldPortalType& baseTreeSupernodesPortal,
145  const InFieldPortalType& baseTreeRegularNodeGlobalIdsPortal,
146  const vtkm::Id& globalRegularIdSetValue,
147  const InFieldPortalType& baseTreeSuper2HypernodePortal,
148  const InFieldPortalType& baseTreeWhichIterationPortal,
149  vtkm::Id& augmentedTreeSuperarcsValue, // same as augmentedTree->superarcs[newSupernodeId]
150  const InOutFieldPortalType&
151  augmentedTreeFirstSupernodePerIterationPortal, // augmentedTree->firstSupernodePerIteration[roundNumber]
152  vtkm::Id& augmentedTreeSuper2hypernodeValue) const
153  {
154  // per supernode in the set
155  // retrieve the index from the sorting index array
156  vtkm::Id supernodeSetIndex = supernodeSorterPortal.Get(supernode);
157 
158  // work out the new supernode Id. We have this defined on the outside as a fancy array handle,
159  // however, using the fancy handle here would not really make a performance differnce and
160  // computing it here is more readable
161  vtkm::Id newSupernodeId = this->NumSupernodesAlready + supernode;
162 
163  // NOTE: The newRegularId is no longer needed here since all parts
164  // that used it in the worklet have been moved outside
165  // vtkm::Id newRegularId = newSupernodeId;
166 
167  // NOTE: This part has been moved out of the worklet and is performed using standard vtkm copy constructs
168  // // setting the supernode's regular Id is now trivial
169  // augmentedTreeSupernodesPortal.Set(newSupernodeId, newRegularId);
170 
171  // retrieve the ascending flag from the superparent
172  vtkm::Id superparentSetVal = superparentSetPortal.Get(supernodeSetIndex);
173  // get the ascending flag from the parent
174  bool superarcAscends = vtkm::worklet::contourtree_augmented::IsAscending(superparentSetVal);
175  // strip the ascending flag from the superparent.
176  vtkm::Id superparentOldSuperId =
178 
179  // setting the superarc is done the usual way. Our sort routine has ended up
180  // with the supernodes arranged in either ascending or descending order
181  // inwards along the parent superarc (as expressed by the superparent Id).
182  // Each superarc except the last in the segment points to the next one:
183  // the last one points to the target of the original superarc.
184  // first test to see if we're the last in the array
185  if (supernode == supernodeSorterPortal.GetNumberOfValues() - 1)
186  { // last in the array
187  // special case for root of entire tree at end of top level
188  if (RoundNumber == this->BaseTreeNumRounds)
189  {
190  augmentedTreeSuperarcsValue = vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
191  }
192  else
193  { // not the tree root
194  // retrieve the target of the superarc from the base tree (masking to strip out the ascending flag)
196  baseTreeSuperarcsPortal.Get(superparentOldSuperId));
197  // convert to a new supernode Id
198  vtkm::Id newTargetSuperId = newSupernodeIdsPortal.Get(oldTargetSuperId);
199  // add the ascending flag back in and store in the array
200  augmentedTreeSuperarcsValue = newTargetSuperId |
201  (superarcAscends ? vtkm::worklet::contourtree_augmented::IS_ASCENDING : 0x00);
202  } // not the tree root
203  // since there's an extra entry in the firstSupernode array as a sentinel, set it
204  augmentedTreeFirstSupernodePerIterationPortal.Set(this->AugmentedTreeNumIterations,
206  } // last in the array
207  else if (superparentOldSuperId !=
209  superparentSetPortal.Get(supernodeSorterPortal.Get(supernode + 1))))
210  { // last in the segment
211  // retrieve the target of the superarc from the base tree (masking to strip out the ascending flag)
213  baseTreeSuperarcsPortal.Get(superparentOldSuperId));
214  // convert to a new supernode Id
215  vtkm::Id newTargetSuperId = newSupernodeIdsPortal.Get(oldTargetSuperId);
216  // add the ascending flag back in and store in the array
217  augmentedTreeSuperarcsValue = newTargetSuperId |
218  (superarcAscends ? vtkm::worklet::contourtree_augmented::IS_ASCENDING : 0x00);
219 
220  // since we're the last in the segment, we check to see if we are at the end of an iteration
222  baseTreeWhichIterationPortal.Get(superparentOldSuperId));
224  baseTreeWhichIterationPortal.Get(superparentOldSuperId + 1));
225 
226  if (iterationNumber != iterationNumberOfNext)
227  { // boundary of iterations
228  // If so, we set the "firstSupernodePerIteration" for the next
229  augmentedTreeFirstSupernodePerIterationPortal.Set(iterationNumberOfNext,
230  newSupernodeId + 1);
231  } // boundary of iterations
232  } // last in the segment
233  else
234  { // not last in the segment
235  // the target is always the next one, so just store it with the ascending flag
236  augmentedTreeSuperarcsValue = (newSupernodeId + 1) |
237  (superarcAscends ? vtkm::worklet::contourtree_augmented::IS_ASCENDING : 0x00);
238  } // not last in the segment
239 
240  // set the first supernode in the first iteration to the beginning of the round
241  augmentedTreeFirstSupernodePerIterationPortal.Set(0, this->NumSupernodesAlready);
242 
243 
244  // NOTE: This part has been moved out of the worklet and is performed using standard vtkm copy constructs
245  // // setting the hyperparent is straightforward since the hyperstructure is preserved
246  // // we take the superparent (which is guaranteed to be in the baseTree), find it's hyperparent and use that
247  // augmentedTreeHyperparentsPortal.Set(newSupernodeId, baseTreeHyperparentsPortal.Get(superparentOldSuperId));
248 
249  // NOTE: This part could potentially be made a separate worklet but it does not seem necessary
250  // similarly, the super2hypernode should carry over, but it's harder to test because of the attachment points which
251  // do not have valid old supernode Ids. Instead, we check their superparent's regular global Id against them: if it
252  // matches, then it must be the start of the superarc, in which case it does have an old Id, and we can then use the
253  // existing hypernode Id
254  vtkm::Id superparentOldRegularId = baseTreeSupernodesPortal.Get(superparentOldSuperId);
255  vtkm::Id superparentGlobalId = baseTreeRegularNodeGlobalIdsPortal.Get(superparentOldRegularId);
256  // Here: globalRegularIdSetValue is the same as globalRegularIdSetPortal.Get(supernodeSetIndex)
257  if (superparentGlobalId == globalRegularIdSetValue)
258  {
259  // augmentedTreeSuper2hypernodePortal.Set(newSupernodeId, baseTreeSuper2HypernodePortal.Get(superparentOldSuperId));
260  augmentedTreeSuper2hypernodeValue = baseTreeSuper2HypernodePortal.Get(superparentOldSuperId);
261  }
262  else
263  {
264  // augmentedTreeSuper2hypernodePortal.Set(newSupernodeId, vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT);
265  augmentedTreeSuper2hypernodeValue = vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
266  }
267 
268  // NOTE: This part has been moved out of the worklet and is performed using standard vtkm copy constructs
269  // // which round and iteration carry over
270  // augmentedTreeWhichRoundPortal.Set(newSupernodeId, baseTreeWhichRoundPortal.Get(superparentOldSuperId));
271  // augmentedTreeWhichIterationPortal.Set(newSupernodeId, baseTreeWhichIterationPortal.Get(superparentOldSuperId));
272 
273  // now we deal with the regular-sized arrays
274 
275  // NOTE: This part has been moved out of the worklet and is performed using standard vtkm copy constructs
276  // // copy the global regular Id and data value
277  // augmentedTreeRegularNodeGlobalIdsPortal.Set(newRegularId, globalRegularIdSetPortal.Get(supernodeSetIndex));
278  // augmentedTreeDataValuesPortal.Set(newRegularId, dataValueSetPortal.Get(supernodeSetIndex));
279 
280  // NOTE: This part has been moved out of the worklet and is performed using standard vtkm copy constructs
281  // // the sort order will be dealt with later
282  // // since all of these nodes are supernodes, they will be their own superparent, which means that:
283  // // a. the regular2node can be set immediately
284  // augmentedTreeRegular2SupernodePortal.Set(newRegularId, newSupernodeId);
285  // // b. as can the superparent
286  // augmentedTreeSuperparentsPortal.Set(newRegularId, newSupernodeId);
287 
288  // In serial this worklet implements the following operation
289  /*
290  for (vtkm::Id supernode = 0; supernode < supernodeSorter.size(); supernode++)
291  { // per supernode in the set
292  // retrieve the index from the sorting index array
293  vtkm::Id supernodeSetIndex = supernodeSorter[supernode];
294 
295  // work out the new supernode ID
296  vtkm::Id newSupernodeID = numSupernodesAlready + supernode;
297 
298  // At all levels above 0, we used to keep regular vertices in case they are attachment points. After augmentation, we don't need to.
299  // Instead, at all levels above 0, the regular nodes in each round are identical to the supernodes
300  // In order to avoid confusion, we will copy the ID into a separate variable
301  vtkm::Id newRegularID = newSupernodeID;
302 
303  // setting the supernode's regular ID is now trivial
304  augmentedTree->supernodes [newSupernodeID] = newRegularID;
305 
306  // retrieve the ascending flag from the superparent
307  bool superarcAscends = isAscending(superparentSet[supernodeSetIndex]);
308 
309  // strip the ascending flag from the superparent
310  vtkm::Id superparentOldSuperID = maskedIndex(superparentSet[supernodeSetIndex]);
311 
312  // setting the superarc is done the usual way. Our sort routine has ended up with the supernodes arranged in either ascending or descending order
313  // inwards along the parent superarc (as expressed by the superparent ID). Each superarc except the last in the segment points to the next one:
314  // the last one points to the target of the original superarc.
315  // first test to see if we're the last in the array
316  if (supernode == supernodeSorter.size() - 1)
317  { // last in the array
318  // special case for root of entire tree at end of top level
319  if (roundNumber == baseTree->nRounds)
320  {
321  augmentedTree->superarcs[newSupernodeID] = NO_SUCH_ELEMENT;
322  }
323  else
324  { // not the tree root
325  // retrieve the target of the superarc from the base tree (masking to strip out the ascending flag)
326  vtkm::Id oldTargetSuperID = maskedIndex(baseTree->superarcs[superparentOldSuperID]);
327  // convert to a new supernode ID
328  vtkm::Id newTargetSuperID = newSupernodeIDs[oldTargetSuperID];
329  // add the ascending flag back in and store in the array
330  augmentedTree->superarcs[newSupernodeID] = newTargetSuperID | (superarcAscends ? IS_ASCENDING : 0x00);
331  } // not the tree root
332  // since there's an extra entry in the firstSupernode array as a sentinel, set it
333  augmentedTree->firstSupernodePerIteration[roundNumber][augmentedTree->nIterations[roundNumber]] = augmentedTree->supernodes.size();
334  } // last in the array
335  else if (superparentOldSuperID != maskedIndex(superparentSet[supernodeSorter[supernode+1]]))
336  { // last in the segment
337  // retrieve the target of the superarc from the base tree (masking to strip out the ascending flag)
338  vtkm::Id oldTargetSuperID = maskedIndex(baseTree->superarcs[superparentOldSuperID]);
339  // convert to a new supernode ID
340  vtkm::Id newTargetSuperID = newSupernodeIDs[oldTargetSuperID];
341  // add the ascending flag back in and store in the array
342  augmentedTree->superarcs[newSupernodeID] = newTargetSuperID | (superarcAscends ? IS_ASCENDING : 0x00);
343 
344  // since we're the last in the segment, we check to see if we are at the end of an iteration
345  vtkm::Id iterationNumber = maskedIndex(baseTree->whichIteration[superparentOldSuperID]);
346  vtkm::Id iterationNumberOfNext = maskedIndex(baseTree->whichIteration[superparentOldSuperID + 1]);
347 
348  if (iterationNumber != iterationNumberOfNext)
349  { // boundary of iterations
350  // If so, we set the "firstSupernodePerIteration" for the next
351  augmentedTree->firstSupernodePerIteration[roundNumber][iterationNumberOfNext] = newSupernodeID + 1;
352  } // boundary of iterations
353  } // last in the segment
354  else
355  { // not last in the segment
356  // the target is always the next one, so just store it with the ascending flag
357  augmentedTree->superarcs[newSupernodeID] = (newSupernodeID+1) | (superarcAscends ? IS_ASCENDING : 0x00);
358  } // not last in the segment
359 
360  // set the first supernode in the first iteration to the beginning of the round
361  augmentedTree->firstSupernodePerIteration[roundNumber][0] = numSupernodesAlready;
362 
363  // setting the hyperparent is straightforward since the hyperstructure is preserved
364  // we take the superparent (which is guaranteed to be in the baseTree), find it's hyperparent and use that
365  augmentedTree->hyperparents [newSupernodeID] = baseTree->hyperparents [superparentOldSuperID];
366 
367  // similarly, the super2hypernode should carry over, but it's harder to test because of the attachment points which
368  // do not have valid old supernode IDs. Instead, we check their superparent's regular global ID against them: if it
369  // matches, then it must be the start of the superarc, in which case it does have an old ID, and we can then use the
370  // existing hypernode ID
371  vtkm::Id superparentOldRegularID = baseTree->supernodes[superparentOldSuperID];
372  vtkm::Id superparentGlobalID = baseTree->regularNodeGlobalIDs[superparentOldRegularID];
373  if (superparentGlobalID == globalRegularIDSet[supernodeSetIndex])
374  {
375  augmentedTree->super2hypernode [newSupernodeID] = baseTree->super2hypernode[superparentOldSuperID];
376  }
377  else
378  {
379  augmentedTree->super2hypernode [newSupernodeID] = NO_SUCH_ELEMENT;
380  }
381 
382  // which round and iteration carry over
383  augmentedTree->whichRound [newSupernodeID] = baseTree->whichRound[superparentOldSuperID];
384  augmentedTree->whichIteration [newSupernodeID] = baseTree->whichIteration[superparentOldSuperID];
385 
386  // now we deal with the regular-sized arrays
387 
388  // copy the global regular ID and data value
389  augmentedTree->regularNodeGlobalIDs [newRegularID] = globalRegularIDSet[supernodeSetIndex];
390  augmentedTree->dataValues [newRegularID] = dataValueSet[supernodeSetIndex];
391 
392  // the sort order will be dealt with later
393  // since all of these nodes are supernodes, they will be their own superparent, which means that:
394  // a. the regular2node can be set immediately
395  augmentedTree->regular2supernode [newRegularID] = newSupernodeID;
396  // b. as can the superparent
397  augmentedTree->superparents [newRegularID] = newSupernodeID;
398  } // per supernode in the set
399  */
400  } // operator()()
401 
402 private:
408 
409 }; // CreateSuperarcsWorklet
410 
411 } // namespace hierarchical_augmenter
412 } // namespace contourtree_distributed
413 } // namespace worklet
414 } // namespace vtkm
415 
416 #endif
vtkm::worklet::contourtree_augmented::IsAscending
VTKM_EXEC_CONT bool IsAscending(vtkm::Id flaggedIndex)
Definition: filter/scalar_topology/worklet/contourtree_augmented/Types.h:121
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet
Worklet used to implement the main part of HierarchicalAugmenter::CreateSuperarcs Connect superarcs f...
Definition: CreateSuperarcsWorklet.h:64
VTKM_EXEC
#define VTKM_EXEC
Definition: ExportMacros.h:51
vtkm
Groups connected points that have the same field value.
Definition: Atomic.h:19
WorkletMapField.h
VTKM_EXEC_CONT
#define VTKM_EXEC_CONT
Definition: ExportMacros.h:52
vtkm::worklet::WorkletMapField::FieldOut
A control signature tag for output fields.
Definition: WorkletMapField.h:60
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet::AugmentedTreeNumIterations
const vtkm::Id AugmentedTreeNumIterations
Definition: CreateSuperarcsWorklet.h:405
vtkm::worklet::contourtree_augmented::MaskedIndex
VTKM_EXEC_CONT vtkm::Id MaskedIndex(vtkm::Id flaggedIndex)
Definition: filter/scalar_topology/worklet/contourtree_augmented/Types.h:127
vtkm::Id
vtkm::Int32 Id
Represents an ID (index into arrays).
Definition: Types.h:191
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet::NumSupernodesAlready
const vtkm::Id NumSupernodesAlready
Definition: CreateSuperarcsWorklet.h:403
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet::NumAugmentedTreeSupernodes
const vtkm::Id NumAugmentedTreeSupernodes
Definition: CreateSuperarcsWorklet.h:407
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet::CreateSuperarcsWorklet
VTKM_EXEC_CONT CreateSuperarcsWorklet(const vtkm::Id &numSupernodesAlready, const vtkm::Id &baseTreeNumRounds, const vtkm::Id &augmentedTreeNumIterations, const vtkm::Id &roundNumber, const vtkm::Id &numAugmentedTreeSupernodes)
Default Constructor.
Definition: CreateSuperarcsWorklet.h:123
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet::operator()
VTKM_EXEC void operator()(const vtkm::Id &supernode, const InFieldPortalType &supernodeSorterPortal, const InFieldPortalType &superparentSetPortal, const InFieldPortalType &baseTreeSuperarcsPortal, const InFieldPortalType &newSupernodeIdsPortal, const InFieldPortalType &baseTreeSupernodesPortal, const InFieldPortalType &baseTreeRegularNodeGlobalIdsPortal, const vtkm::Id &globalRegularIdSetValue, const InFieldPortalType &baseTreeSuper2HypernodePortal, const InFieldPortalType &baseTreeWhichIterationPortal, vtkm::Id &augmentedTreeSuperarcsValue, const InOutFieldPortalType &augmentedTreeFirstSupernodePerIterationPortal, vtkm::Id &augmentedTreeSuper2hypernodeValue) const
operator() of the workelt
Definition: CreateSuperarcsWorklet.h:138
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet::ExecutionSignature
void(InputIndex, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) ExecutionSignature
Definition: CreateSuperarcsWorklet.h:113
vtkm::worklet::WorkletMapField::FieldIn
A control signature tag for input fields.
Definition: WorkletMapField.h:49
Types.h
vtkm::worklet::contourtree_augmented::IS_ASCENDING
constexpr vtkm::Id IS_ASCENDING
Definition: filter/scalar_topology/worklet/contourtree_augmented/Types.h:77
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet::RoundNumber
const vtkm::Id RoundNumber
Definition: CreateSuperarcsWorklet.h:406
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet::InputDomain
_1 InputDomain
Definition: CreateSuperarcsWorklet.h:114
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet::BaseTreeNumRounds
const vtkm::Id BaseTreeNumRounds
Definition: CreateSuperarcsWorklet.h:404
vtkm::worklet::contourtree_distributed::hierarchical_augmenter::CreateSuperarcsWorklet::ControlSignature
void(WholeArrayIn supernodeSorter, WholeArrayIn superparentSet, WholeArrayIn baseTreeSuperarcs, WholeArrayIn newSupernodeIds, WholeArrayIn baseTreeSupernodes, WholeArrayIn baseTreeRegularNodeGlobalIds, FieldIn globalRegularIdSet, WholeArrayIn baseTreeSuper2Hypernode, WholeArrayIn baseTreeWhichIteration, FieldOut augmentedTreeSuperarcsView, WholeArrayInOut augmentedTreeFirstSupernodePerIteration, FieldOut augmentedTreeSuper2hypernode) ControlSignature
Control signature for the worklet.
Definition: CreateSuperarcsWorklet.h:112
vtkm::exec::arg::InputIndex
The ExecutionSignature tag to use to get the input index.
Definition: InputIndex.h:42
vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT
constexpr vtkm::Id NO_SUCH_ELEMENT
Definition: filter/scalar_topology/worklet/contourtree_augmented/Types.h:73
vtkm::worklet::WorkletMapField
Base class for worklets that do a simple mapping of field arrays.
Definition: WorkletMapField.h:38