Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 10:35:42 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Added GetOwnedVerticesByGlobalID for the 2D and 3D meshes

Browse Source
This commit is contained in:
Oliver Ruebel 2021-03-02 00:35:21 -08:00 committed by Gunther H. Weber
parent b0fe5ffe40
commit 76d88db157
9 changed files with 394 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
vtkm/worklet/contourtree_augmented/DataSetMesh.h
View File

@ -80,7 +80,9 @@
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/GetOwnedVerticesByGlobalIdWorklet.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/NotNoSuchElementPredicate.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/SimulatedSimplicityComperator.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/SortIndices.h>
@ -181,15 +183,84 @@ public:
meshIds, *localToGlobalIdRelabeler);
} // GetGlobalIDsFromMeshIndices()
///Compute a list of the global Iss of all vertices that logically belong to the data block represented by this
///mesh object (used in distributd parallel computation). This is needed to avoid multiple counting on bousndaries
///in the hierarchy during distributed parallel contour tree computation.
///This function is defined as virtual on the base DataSet mesh to make it easy to reuse across the mesh types
///since in the distributed case we may store the meshes in their generic version. The specific implementation
/// must be handled in the specialized mesh types.
/// @param[in] localToGlobalIdRelabeler IdRelabeler for the mesh needed to map local to global Ids
/// @param[out] ownedVertices List of vertices that logically belong to
virtual void GetOwnedVerticesByGlobalId(
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* localToGlobalIdRelabeler,
IdArrayType& ownedVertices) const
{
(void)localToGlobalIdRelabeler;
(void)ownedVertices;
throw std::logic_error("GetOwnedVerticesByGlobalId not implemented on the "
"base DataSetMesh. The function must be implemented "
"on derived classes, typically using the provided "
"GetOwnedVerticesByGlobalIdImpl function.");
}
//routine that dumps out the contents of the mesh
void DebugPrint(const char* message, const char* fileName, long lineNum);
protected:
/// Implementation of GetOwnedVerticesByGlobalId used internally by derived classes to
/// implement the specific variant of the function .The implementations vary based on the
/// MeshBoundary object used, and so derived classes just need to specify their mesh
/// boundary object and then call this funtion
/// @param[in] mesh For derived meshes set simply to this. Derived meshes inherit also from ExecutionObjectBase
/// and as such have PrepareForExecution functions that return a MeshBoundary object that
/// we can use here. We are passing in the mesh since the base DataSetMesh class does
/// not know about MeshBoundary classes and so we are passing the mesh in.
/// @param[out] ownedVertices List of vertices that logically belong to
template <typename MeshTypeObj>
void GetOwnedVerticesByGlobalIdImpl(
const MeshTypeObj* mesh,
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* localToGlobalIdRelabeler,
IdArrayType& ownedVertices) const;
virtual void DebugPrintExtends();
template <typename T, typename StorageType>
void DebugPrintValues(const vtkm::cont::ArrayHandle<T, StorageType>& values);
}; // class DataSetMesh
// Implementation of GetOwnedVerticesByGlobalId used by subclasses
template <typename MeshTypeObj>
void DataSetMesh::GetOwnedVerticesByGlobalIdImpl(
const MeshTypeObj* mesh,
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* localToGlobalIdRelabeler,
IdArrayType& ownedVertices) const
{
// use temporary array since we need to compress these at the end via CopyIf so we
// can move the values to keep to the ownedVertices ouput array then
IdArrayType tempOwnedVertices;
// Fancy array for the running mesh index
vtkm::cont::ArrayHandleIndex meshIndexArray(this->GetNumberOfVertices());
auto ownedVerticesWorklet =
vtkm::worklet::contourtree_augmented::data_set_mesh::GetOwnedVerticesByGlobalIdWorklet(
localToGlobalIdRelabeler);
vtkm::cont::Invoker invoke;
invoke(ownedVerticesWorklet, // worklet ot run
meshIndexArray, // input mesh index to map
mesh, // input the mesh object
tempOwnedVertices // output
);
// now compress out the NO_SUCH_ELEMENT ones
auto notNoSuchElementPredicate =
vtkm::worklet::contourtree_augmented::data_set_mesh::NotNoSuchElementPredicate();
// compress the array
vtkm::cont::Algorithm::CopyIf(
tempOwnedVertices, // compress the array of owned vertices
tempOwnedVertices, // stencil. Same as input. Values to remove have NO_SUCH_ELEMENT flag
ownedVertices, // array where the compressed ownedVertices are stored
notNoSuchElementPredicate // unary predicate for deciding which nodes are considered true. Here those that do not have a NO_SUCH_ELEMENT flag.
);
}
// Sorts the data and initialises the SortIndices & SortOrder
template <typename T, typename StorageType>
inline void DataSetMesh::SortData(const vtkm::cont::ArrayHandle<T, StorageType>& values)

4
vtkm/worklet/contourtree_augmented/data_set_mesh/CMakeLists.txt
View File

@ -8,11 +8,13 @@
## PURPOSE. See the above copyright notice for more information.
##============================================================================
set(headers
GetOwnedVerticesByGlobalIdWorklet.h
IdRelabeler.h
MeshStructure2D.h
MeshStructure3D.h
NotNoSuchElementPredicate.h
SimulatedSimplicityComperator.h
SortIndices.h
IdRelabeler.h
)
#-----------------------------------------------------------------------------

104
vtkm/worklet/contourtree_augmented/data_set_mesh/GetOwnedVerticesByGlobalIdWorklet.h Normal file
View File

@ -0,0 +1,104 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
// Copyright (c) 2018, The Regents of the University of California, through
// Lawrence Berkeley National Laboratory (subject to receipt of any required approvals
// from the U.S. Dept. of Energy). All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// (2) Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// (3) Neither the name of the University of California, Lawrence Berkeley National
// Laboratory, U.S. Dept. of Energy nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
//
//=============================================================================
//
// This code is an extension of the algorithm presented in the paper:
// Parallel Peak Pruning for Scalable SMP Contour Tree Computation.
// Hamish Carr, Gunther Weber, Christopher Sewell, and James Ahrens.
// Proceedings of the IEEE Symposium on Large Data Analysis and Visualization
// (LDAV), October 2016, Baltimore, Maryland.
//
// The PPP2 algorithm and software were jointly developed by
// Hamish Carr (University of Leeds), Gunther H. Weber (LBNL), and
// Oliver Ruebel (LBNL)
//==============================================================================
#ifndef vtk_m_worklet_contourtree_augmented_mesh_dem_get_owned_vertices_by_global_id_worklet_h
#define vtk_m_worklet_contourtree_augmented_mesh_dem_get_owned_vertices_by_global_id_worklet_h
#include <vtkm/worklet/WorkletMapField.h>
namespace vtkm
{
namespace worklet
{
namespace contourtree_augmented
{
namespace data_set_mesh
{
// Worklet for computing the sort indices from the sort order
class GetOwnedVerticesByGlobalIdWorklet : public vtkm::worklet::WorkletMapField
{
public:
using ControlSignature = void(FieldIn meshIndices, // (input) index into active vertices
ExecObject meshStructure, // (input) mesh structure execution object
FieldOut ownedVertices // (output) vertices owned by the mesh
);
using ExecutionSignature = _3(_1, _2);
using InputDomain = _1;
// Constructor
VTKM_EXEC_CONT
GetOwnedVerticesByGlobalIdWorklet(
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* localToGlobalIdRelabeler)
: LocalToGlobalIdRelabeler(localToGlobalIdRelabeler)
{
}
/// Functor returning NO_SUCH_ELEMENT if vertex is not owed or the global mesh index if the vertex is owned
/// The functor simply calls the GetVertexOwned functin of the meshStructure for all vertices
template <typename MeshStructureType>
VTKM_EXEC vtkm::Id operator()(const vtkm::Id meshIndex,
const MeshStructureType& meshStructure) const
{
return meshStructure.GetVertexOwned(meshIndex, this->LocalToGlobalIdRelabeler);
}
private:
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* LocalToGlobalIdRelabeler;
}; // Mesh2D_DEM_VertexStarter
} // namespace data_set_mesh
} // namespace contourtree_augmented
} // namespace worklet
} // namespace vtkm
#endif

33
vtkm/worklet/contourtree_augmented/data_set_mesh/MeshStructure2D.h
View File

@ -54,6 +54,7 @@
#define vtk_m_worklet_contourtree_augmented_data_set_mesh_execution_object_mesh_2d_h
#include <vtkm/Types.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h>
namespace vtkm
{
@ -80,20 +81,48 @@ public:
{
}
// number of mesh vertices
/// Get the number of mesh vertices
VTKM_EXEC_CONT
vtkm::Id GetNumberOfVertices() const { return (this->MeshSize[0] * this->MeshSize[1]); }
/// Get the (x,y) position of the vertex based on its index
VTKM_EXEC
inline vtkm::Id2 VertexPos(vtkm::Id v) const
{
return vtkm::Id2{ v % this->MeshSize[0], v / this->MeshSize[0] };
}
//vertex ID - row * ncols + col
///vertex ID - row * ncols + col
VTKM_EXEC
inline vtkm::Id VertexId(vtkm::Id2 pos) const { return pos[1] * this->MeshSize[0] + pos[0]; }
/// determine if the vertex is owned by this mesh block or not
/// The function returns NO_SUCH_ELEMENT if the vertex is not owned by the block and
/// otherwise it returns global id of the vertex as determined via the IdRelabeler
VTKM_EXEC_CONT
inline vtkm::Id GetVertexOwned(const vtkm::Id& meshIndex,
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler*
localToGlobalIdRelabeler) const
{
// Get the vertex position
vtkm::Id2 pos = this->VertexPos(meshIndex);
// now test - the low ID boundary belongs to this block
// the high ID boundary belongs to the next block if there is one
if (((pos[1] == this->MeshSize[1] - 1) &&
(pos[1] + localToGlobalIdRelabeler->LocalBlockOrigin[1] !=
localToGlobalIdRelabeler->GlobalSize[1] - 1)) ||
((pos[0] == this->MeshSize[0] - 1) &&
(pos[0] + localToGlobalIdRelabeler->LocalBlockOrigin[0] !=
localToGlobalIdRelabeler->GlobalSize[0] - 1)))
{
return vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
}
else
{
return (*localToGlobalIdRelabeler)(meshIndex);
}
}
vtkm::Id2 MeshSize;
}; // MeshStructure2D

31
vtkm/worklet/contourtree_augmented/data_set_mesh/MeshStructure3D.h
View File

@ -104,6 +104,37 @@ public:
return (pos[2] * this->MeshSize[1] + pos[1]) * this->MeshSize[0] + pos[0];
}
/// determine if the vertex is owned by this mesh block or not
/// The function returns NO_SUCH_ELEMENT if the vertex is not owned by the block and
/// otherwise it returns global id of the vertex as determined via the IdRelabeler
VTKM_EXEC_CONT
inline vtkm::Id GetVertexOwned(const vtkm::Id& meshIndex,
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler*
localToGlobalIdRelabeler) const
{
// Get the vertex position
vtkm::Id3 pos = this->VertexPos(meshIndex);
// now test - the low ID boundary belongs to this block
// the high ID boundary belongs to the next block if there is one
if (((pos[1] == this->MeshSize[1] - 1) &&
(pos[1] + localToGlobalIdRelabeler->LocalBlockOrigin[1] !=
localToGlobalIdRelabeler->GlobalSize[1] - 1)) ||
((pos[0] == this->MeshSize[0] - 1) &&
(pos[0] + localToGlobalIdRelabeler->LocalBlockOrigin[0] !=
localToGlobalIdRelabeler->GlobalSize[0] - 1)) ||
((pos[2] == this->MeshSize[2] - 1) &&
(pos[2] + localToGlobalIdRelabeler->LocalBlockOrigin[2] !=
localToGlobalIdRelabeler->GlobalSize[2] - 1)))
{
return vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
}
else
{
return (*localToGlobalIdRelabeler)(meshIndex);
}
}
vtkm::Id3 MeshSize;
}; // Mesh_DEM_2D_ExecutionObject

89
vtkm/worklet/contourtree_augmented/data_set_mesh/NotNoSuchElementPredicate.h Normal file
View File

@ -0,0 +1,89 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
// Copyright (c) 2018, The Regents of the University of California, through
// Lawrence Berkeley National Laboratory (subject to receipt of any required approvals
// from the U.S. Dept. of Energy). All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// (2) Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// (3) Neither the name of the University of California, Lawrence Berkeley National
// Laboratory, U.S. Dept. of Energy nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
//
//=============================================================================
//
// This code is an extension of the algorithm presented in the paper:
// Parallel Peak Pruning for Scalable SMP Contour Tree Computation.
// Hamish Carr, Gunther Weber, Christopher Sewell, and James Ahrens.
// Proceedings of the IEEE Symposium on Large Data Analysis and Visualization
// (LDAV), October 2016, Baltimore, Maryland.
//
// The PPP2 algorithm and software were jointly developed by
// Hamish Carr (University of Leeds), Gunther H. Weber (LBNL), and
// Oliver Ruebel (LBNL)
//==============================================================================
#ifndef vtk_m_worklet_contourtree_distributed_data_set_mesh_not_no_such_element_predicate_h
#define vtk_m_worklet_contourtree_distributed_data_set_mesh_not_no_such_element_predicate_h
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{
namespace worklet
{
namespace contourtree_augmented
{
namespace data_set_mesh
{
//Simple functor to subset a VTKm ArrayHandle
class NotNoSuchElementPredicate
{
public:
VTKM_EXEC_CONT
NotNoSuchElementPredicate() {}
VTKM_EXEC_CONT
bool operator()(const vtkm::Id& meshVertexId) const
{
return static_cast<bool>(vtkm::worklet::contourtree_augmented::NoSuchElement(meshVertexId));
}
private:
};
} // namespace data_set_mesh
} // namespace contourtree_augmented
} // namespace worklet
} // namespace vtkm
#endif

39
vtkm/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation2DFreudenthal.h
View File

@ -70,30 +70,49 @@ namespace worklet
namespace contourtree_augmented
{
/// Class representing a 2D dataset mesh with freudenthal triangulation connectivity for contour tree computation
class DataSetMeshTriangulation2DFreudenthal
: public DataSetMesh
, public vtkm::cont::ExecutionObjectBase
{ // class DataSetMeshTriangulation
public:
// Constants and case tables
/// Constants and case tables
m2d_freudenthal::EdgeBoundaryDetectionMasksType EdgeBoundaryDetectionMasks;
static constexpr int MAX_OUTDEGREE = 3;
//Mesh dependent helper functions
void SetPrepareForExecutionBehavior(bool getMax);
/// Prepare mesh for use in VTKm worklets. This function creates a MeshStructureFreudenthal2D
/// ExecutionObject that implements relevant mesh functions on the device.
MeshStructureFreudenthal2D PrepareForExecution(vtkm::cont::DeviceAdapterId device,
vtkm::cont::Token& token) const;
/// Constructor
/// @param meshSize vtkm::Id2 object describing the number of vertices in x and y
DataSetMeshTriangulation2DFreudenthal(vtkm::Id2 meshSize);
/// Helper function to create a boundary excution object for the mesh. The MeshBoundary2DExec object
/// implements functions for using in worklets in VTKm's execution environment related the boundary
/// of the mesh.
MeshBoundary2DExec GetMeshBoundaryExecutionObject() const;
void GetBoundaryVertices(IdArrayType& boundaryVertexArray, // output
IdArrayType& boundarySortIndexArray, // output
MeshBoundary2DExec* meshBoundaryExecObj =
NULL // optional input, included for consistency with ContourTreeMesh
) const;
/// Get boundary vertices
/// @param[out] boundaryVertexArray Array of boundary vertices
/// @param[out] boundarySortIndexArray Array of sort index of boundary vertices
/// @param[in] meshBoundaryExecObj Optional mesh boundary object inluced for consistency with ContourTreeMesh.
/// if omitted, GetMeshBoundaryExecutionObject() will be used.
void GetBoundaryVertices(IdArrayType& boundaryVertexArray,
IdArrayType& boundarySortIndexArray,
MeshBoundary2DExec* meshBoundaryExecObj = NULL) const;
/// Get of global indices of the vertices owned by this mesh. Defined in DataSetMesh and implemented via
/// DataSetMesh.GetOwnedVerticesByGlobalIdImpl. The function is overwritten here to get around the
/// virtual nature because we need the PrepareForExecution function from this mesh which the base
/// DataSetMesh does not provide, so we need to define this here and call GetOwnedVerticesByGlobalIdImp with this mesh.
virtual void GetOwnedVerticesByGlobalId(
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* localToGlobalIdRelabeler,
IdArrayType& ownedVertices) const;
private:
bool UseGetMax; // Define the behavior ofr the PrepareForExecution function
@ -157,6 +176,14 @@ inline void DataSetMeshTriangulation2DFreudenthal::GetBoundaryVertices(
);
}
// Overwrite the implemenation from the base DataSetMesh parent class
void DataSetMeshTriangulation2DFreudenthal::GetOwnedVerticesByGlobalId(
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* localToGlobalIdRelabeler,
IdArrayType& ownedVertices) const
{
return this->GetOwnedVerticesByGlobalIdImpl(this, localToGlobalIdRelabeler, ownedVertices);
}
} // namespace contourtree_augmented
} // worklet
} // vtkm

16
vtkm/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation3DFreudenthal.h
View File

@ -100,6 +100,14 @@ public:
NULL // optional input, included for consistency with ContourTreeMesh
) const;
/// Get of global indices of the vertices owned by this mesh. Defined in DataSetMesh and implemented via
/// DataSetMesh.GetOwnedVerticesByGlobalIdImpl. The function is overwritten here to get around the
/// virtual nature because we need the PrepareForExecution function from this mesh which the base
/// DataSetMesh does not provide, so we need to define this here and call GetOwnedVerticesByGlobalIdImp with this mesh.
virtual void GetOwnedVerticesByGlobalId(
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* localToGlobalIdRelabeler,
IdArrayType& ownedVertices) const;
private:
bool UseGetMax; // Define the behavior ofr the PrepareForExecution function
}; // class DataSetMeshTriangulation
@ -173,6 +181,14 @@ inline void DataSetMeshTriangulation3DFreudenthal::GetBoundaryVertices(
);
}
// Overwrite the implemenation from the base DataSetMesh parent class
void DataSetMeshTriangulation3DFreudenthal::GetOwnedVerticesByGlobalId(
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* localToGlobalIdRelabeler,
IdArrayType& ownedVertices) const
{
return this->GetOwnedVerticesByGlobalIdImpl(this, localToGlobalIdRelabeler, ownedVertices);
}
} // namespace contourtree_augmented
} // worklet
} // vtkm

16
vtkm/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation3DMarchingCubes.h
View File

@ -105,6 +105,14 @@ public:
nullptr // optional input, included for consistency with ContourTreeMesh
) const;
/// Get of global indices of the vertices owned by this mesh. Defined in DataSetMesh and implemented via
/// DataSetMesh.GetOwnedVerticesByGlobalIdImpl. The function is overwritten here to get around the
/// virtual nature because we need the PrepareForExecution function from this mesh which the base
/// DataSetMesh does not provide, so we need to define this here and call GetOwnedVerticesByGlobalIdImp with this mesh.
virtual void GetOwnedVerticesByGlobalId(
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* localToGlobalIdRelabeler,
IdArrayType& ownedVertices) const;
private:
bool UseGetMax; // Define the behavior ofr the PrepareForExecution function
}; // class DataSetMesh_Triangulation
@ -206,6 +214,14 @@ inline void DataSetMeshTriangulation3DMarchingCubes::GetBoundaryVertices(
);
}
// Overwrite the implemenation from the base DataSetMesh parent class
void DataSetMeshTriangulation3DMarchingCubes::GetOwnedVerticesByGlobalId(
const vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler* localToGlobalIdRelabeler,
IdArrayType& ownedVertices) const
{
return this->GetOwnedVerticesByGlobalIdImpl(this, localToGlobalIdRelabeler, ownedVertices);
}
} // namespace contourtree_augmented
} // worklet
} // vtkm