VTK-m  2.0
ComputeMeshBoundary3D.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 //
42 // This code is an extension of the algorithm presented in the paper:
43 // Parallel Peak Pruning for Scalable SMP Contour Tree Computation.
44 // Hamish Carr, Gunther Weber, Christopher Sewell, and James Ahrens.
45 // Proceedings of the IEEE Symposium on Large Data Analysis and Visualization
46 // (LDAV), October 2016, Baltimore, Maryland.
47 //
48 // The PPP2 algorithm and software were jointly developed by
49 // Hamish Carr (University of Leeds), Gunther H. Weber (LBNL), and
50 // Oliver Ruebel (LBNL)
51 //==============================================================================
52 
53 #ifndef vtk_m_worklet_contourtree_augmented_mesh_dem_mesh_types_mesh_boundary_compute_mesh_boundary_3D_h
54 #define vtk_m_worklet_contourtree_augmented_mesh_dem_mesh_types_mesh_boundary_compute_mesh_boundary_3D_h
55 
58 
59 namespace vtkm
60 {
61 namespace worklet
62 {
63 namespace contourtree_augmented
64 {
65 
66 // Worklet to collapse past regular vertices by updating inbound and outbound as part
67 // loop to find the now-regular vertices and collapse past them without altering
68 // the existing join & split arcs
70 {
71 public:
72  typedef void ControlSignature(FieldIn boundaryId, // (input)
73  WholeArrayIn sortIndices, // (input)
74  ExecObject meshBoundary, // (input)
75  FieldOut boundaryVertexArray, // output
76  FieldOut boundarySortIndexArray // output
77  );
78  typedef void ExecutionSignature(_1, _2, _3, _4, _5);
79  using InputDomain = _1;
80 
81 
82  // Default Constructor
85 
86  template <typename InFieldPortalType, typename MeshBoundaryType>
87  VTKM_EXEC void operator()(const vtkm::Id& boundaryId,
88  const InFieldPortalType sortIndicesPortal,
89  const MeshBoundaryType& meshBoundary,
90  vtkm::Id& boundaryVertex,
91  vtkm::Id& boundarySortIndex) const
92  {
93  auto meshStructure3D = meshBoundary.GetMeshStructure();
94  vtkm::Id3 meshSize = meshStructure3D.MeshSize;
95  // for comments [0]/x -> column, [1]/y -> row, [2]/z -> slice
96  // calculate the number of boundary elements - all of the two xy faces
97  vtkm::Id nBoundary = 2 * meshSize[1] * meshSize[0] // xy faces
98  + 2 * meshSize[1] * (meshSize[2] - 2) // yz faces - excluding vertices on xy
99  + 2 * (meshSize[0] - 2) * (meshSize[2] - 2); // xz face interiors
100 
101  vtkm::Id3 pos{ 0, 0, 0 };
102  vtkm::Id sliceSize = meshSize[1] * meshSize[0];
103  vtkm::Id sliceBoundarySize = 2 * meshSize[1] + 2 * meshSize[0] - 4;
104  // do top plane first
105  if (boundaryId < sliceSize)
106  { // top plane
107  pos[0] = boundaryId % meshSize[0];
108  pos[1] = boundaryId / meshSize[0];
109  pos[2] = 0;
110  } // top plane
111  // then bottom plane
112  else if (boundaryId >= nBoundary - sliceSize)
113  { // bottom plane
114  pos[0] = (boundaryId - (nBoundary - sliceSize)) % meshSize[0];
115  pos[1] = (boundaryId - (nBoundary - sliceSize)) / meshSize[0];
116  pos[2] = meshSize[2] - 1;
117  } // bottom plane
118  // now we have to deal with the exterior of the remaining slices
119  else
120  { // slice exteriors
121  // first we subtract the size of the first slice
122  vtkm::Id offsetBoundaryid = boundaryId - sliceSize;
123  // now we can compute the slice id
124  pos[2] = 1 + offsetBoundaryid / sliceBoundarySize;
125  // compute the local id on the slice
126  vtkm::Id sliceBoundaryId = offsetBoundaryid % sliceBoundarySize;
127  // now test for the first and last pos[1]
128  if (sliceBoundaryId < meshSize[0])
129  { // first row
130  pos[0] = sliceBoundaryId;
131  pos[1] = 0;
132  } // first row
133  else if (sliceBoundaryId >= (sliceBoundarySize - meshSize[0]))
134  { // last row
135  pos[0] = sliceBoundaryId - (sliceBoundarySize - meshSize[0]);
136  pos[1] = meshSize[1] - 1;
137  } // last row
138  else
139  { // any other row
140  pos[0] = ((sliceBoundaryId - meshSize[0]) % 2) ? (meshSize[0] - 1) : 0;
141  pos[1] = ((sliceBoundaryId - meshSize[0]) / 2) + 1;
142  } // any other row
143  } // slice exteriors
144  // now we have row, col, slice all set, compute the actual ID
145  boundaryVertex = meshStructure3D.VertexId(pos);
146  // and fill in the index array as well
147  boundarySortIndex = sortIndicesPortal.Get(boundaryVertex);
148 
149  /*
150  { // GetBoundaryVertices()
151  // calculate the number of boundary elements - all of the two xy faces
152  indexType nBoundary = 2 * nRows * nCols // xy faces
153  + 2 * nRows * (nSlices - 2) // yz faces - excluding vertices on xy
154  + 2 * (nCols - 2) * (nSlices - 2) // xz face interiors
155  ;
156 
157  // resize the arrays accordingly
158  boundaryVertexArray.resize(nBoundary);
159  boundarySortIndexArray.resize(nBoundary);
160 
161  // loop to add in the vertices
162  for (indexType boundaryID = 0; boundaryID < nBoundary; boundaryID++)
163  { // loop through indices
164  indexType row = 0, col = 0, slice = 0;
165  indexType sliceSize = nRows * nCols;
166  indexType sliceBoundarySize = 2 * nRows + 2 * nCols - 4;
167  // do top plane first
168  if (boundaryID < sliceSize)
169  { // top plane
170  row = boundaryID / nCols;
171  col = boundaryID % nCols;
172  slice = 0;
173  } // top plane
174  // then bottom plane
175  else if (boundaryID >= nBoundary - sliceSize)
176  { // bottom plane
177  row = (boundaryID - (nBoundary - sliceSize)) / nCols;
178  col = (boundaryID - (nBoundary - sliceSize)) % nCols;
179  slice = nSlices - 1;
180  } // bottom plane
181  // now we have to deal with the exterior of the remaining slices
182  else
183  { // slice exteriors
184  // first we subtract the size of the first slice
185  indexType offsetBoundaryID = boundaryID - sliceSize;
186  // now we can compute the slice ID
187  slice = 1 + offsetBoundaryID / sliceBoundarySize;
188  // compute the local ID on the slice
189  indexType sliceBoundaryID = offsetBoundaryID % sliceBoundarySize;
190  // now test for the first and last row
191  if (sliceBoundaryID < nCols)
192  { // first row
193  row = 0;
194  col = sliceBoundaryID;
195  } // first row
196  else if (sliceBoundaryID >= (sliceBoundarySize - nCols))
197  { // last row
198  row = nRows - 1;
199  col = sliceBoundaryID - (sliceBoundarySize - nCols);
200  } // last row
201  else
202  { // any other row
203  row = ((sliceBoundaryID - nCols) / 2) + 1;
204  col = ((sliceBoundaryID - nCols) % 2) ? (nCols - 1) : 0;
205  } // any other row
206  } // slice exteriors
207  // now we have row, col, slice all set, compute the actual ID
208  boundaryVertexArray[boundaryID] = vertexId(slice, row, col);
209  // and fill in the index array as well
210  boundarySortIndexArray[boundaryID] = sortIndices[boundaryVertexArray[boundaryID]];
211  } // loop through indices
212  } // GetBoundaryVertices()
213  */
214  }
215 
216 }; // ComputeMeshBoundary3D
217 
218 } // namespace contourtree_augmented
219 } // namespace worklet
220 } // namespace vtkm
221 
222 #endif
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::Id
vtkm::Int32 Id
Represents an ID (index into arrays).
Definition: Types.h:191
vtkm::worklet::contourtree_augmented::ComputeMeshBoundary3D::ControlSignature
void ControlSignature(FieldIn boundaryId, WholeArrayIn sortIndices, ExecObject meshBoundary, FieldOut boundaryVertexArray, FieldOut boundarySortIndexArray)
Definition: ComputeMeshBoundary3D.h:72
vtkm::worklet::contourtree_augmented::ComputeMeshBoundary3D::ExecutionSignature
void ExecutionSignature(_1, _2, _3, _4, _5)
Definition: ComputeMeshBoundary3D.h:78
vtkm::worklet::WorkletMapField::FieldIn
A control signature tag for input fields.
Definition: WorkletMapField.h:49
Types.h
vtkm::worklet::contourtree_augmented::ComputeMeshBoundary3D::operator()
VTKM_EXEC void operator()(const vtkm::Id &boundaryId, const InFieldPortalType sortIndicesPortal, const MeshBoundaryType &meshBoundary, vtkm::Id &boundaryVertex, vtkm::Id &boundarySortIndex) const
Definition: ComputeMeshBoundary3D.h:87
vtkm::worklet::contourtree_augmented::ComputeMeshBoundary3D::InputDomain
_1 InputDomain
Definition: ComputeMeshBoundary3D.h:79
vtkm::Vec< vtkm::Id, 3 >
vtkm::worklet::contourtree_augmented::ComputeMeshBoundary3D::ComputeMeshBoundary3D
VTKM_EXEC_CONT ComputeMeshBoundary3D()
Definition: ComputeMeshBoundary3D.h:84
vtkm::worklet::contourtree_augmented::ComputeMeshBoundary3D
Definition: ComputeMeshBoundary3D.h:69
vtkm::worklet::WorkletMapField
Base class for worklets that do a simple mapping of field arrays.
Definition: WorkletMapField.h:38