Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Move computing branch decomposition to a separate filter

Browse Source
This commit is contained in:
Gunther H. Weber 2022-05-02 18:15:40 -07:00
parent 4fe495be8d
commit f871f51cb8
29 changed files with 1275 additions and 742 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
examples/contour_tree_distributed/ContourTreeApp.cxx
View File

@ -72,11 +72,12 @@
#include <vtkm/io/BOVDataSetReader.h>
#include <vtkm/filter/ContourTreeUniformDistributed.h>
#include <vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.h>
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/HierarchicalVolumetricBranchDecomposer.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/ProcessContourTree.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_distributed/HierarchicalContourTree.h>
#include <vtkm/worklet/contourtree_distributed/HierarchicalVolumetricBranchDecomposer.h>
#include <vtkm/worklet/contourtree_distributed/TreeCompiler.h>
// clang-format off
@ -862,19 +863,17 @@ int main(int argc, char* argv[])
prevTime = currTime;
// Convert the mesh of values into contour tree, pairs of vertex ids
vtkm::filter::ContourTreeUniformDistributed filter(
blocksPerDim,
globalSize,
localBlockIndices,
localBlockOrigins,
localBlockSizes,
useBoundaryExtremaOnly,
useMarchingCubes,
augmentHierarchicalTree,
computeHierarchicalVolumetricBranchDecomposition,
saveDotFiles,
timingsLogLevel,
treeLogLevel);
vtkm::filter::ContourTreeUniformDistributed filter(blocksPerDim,
globalSize,
localBlockIndices,
localBlockOrigins,
localBlockSizes,
useBoundaryExtremaOnly,
useMarchingCubes,
augmentHierarchicalTree,
saveDotFiles,
timingsLogLevel,
treeLogLevel);
filter.SetActiveField("values");
// Execute the contour tree analysis
@ -896,17 +895,20 @@ int main(int argc, char* argv[])
{
if (computeHierarchicalVolumetricBranchDecomposition)
{
vtkm::filter::scalar_topology::DistributedBranchDecompositionFilter bd_filter(
blocksPerDim, globalSize, localBlockIndices, localBlockOrigins, localBlockSizes);
auto bd_result = bd_filter.Execute(result);
for (vtkm::Id ds_no = 0; ds_no < result.GetNumberOfPartitions(); ++ds_no)
{
auto ds = result.GetPartition(ds_no);
auto ds = bd_result.GetPartition(ds_no);
std::string branchDecompositionFileName = std::string("BranchDecomposition_Rank_") +
std::to_string(static_cast<int>(rank)) + std::string("_Block_") +
std::to_string(static_cast<int>(ds_no)) + std::string(".txt");
std::ofstream treeStream(branchDecompositionFileName.c_str());
treeStream
<< vtkm::worklet::contourtree_distributed::HierarchicalVolumetricBranchDecomposer<
ValueType>::PrintBranches(ds);
treeStream << vtkm::worklet::scalar_topology::HierarchicalVolumetricBranchDecomposer::
PrintBranches(ds);
}
}
else

1
vtkm/filter/CMakeLists.txt
View File

@ -199,6 +199,7 @@ add_subdirectory(geometry_refinement)
add_subdirectory(mesh_info)
add_subdirectory(multi_block)
add_subdirectory(resampling)
add_subdirectory(scalar_topology)
add_subdirectory(vector_analysis)
add_subdirectory(zfp)

12
vtkm/filter/ContourTreeUniformDistributed.h
View File

@ -119,7 +119,6 @@ public:
bool useBoundaryExtremaOnly = true,
bool useMarchingCubes = false,
bool augmentHierarchicalTree = false,
bool computeHierarchicalVolumetricBranchDecomposition = false,
bool saveDotFiles = false,
vtkm::cont::LogLevel timingsLogLevel = vtkm::cont::LogLevel::Perf,
vtkm::cont::LogLevel treeLogLevel = vtkm::cont::LogLevel::Info);
@ -173,14 +172,6 @@ public:
std::stringstream& timingsStream,
std::vector<vtkm::cont::DataSet>& hierarchicalTreeOutputDataSet);
template <typename FieldType>
VTKM_CONT void ComputeBranchDecomposition(vtkmdiy::Master& inputContourTreeMaster,
vtkmdiy::DynamicAssigner& assigner,
vtkmdiy::RegularSwapPartners& partners,
const FieldType&, // dummy parameter to get the type
std::stringstream& timingsStream,
std::vector<vtkm::cont::DataSet>& outputDataSet);
///
/// Internal helper function that implements the actual functionality of PostExecute
///
@ -205,9 +196,6 @@ private:
/// Augment hierarchical tree
bool AugmentHierarchicalTree;
/// Compute the hierarchical volumetric branch decomposition
bool ComputeHierarchicalVolumetricBranchDecomposition;
/// Save dot files for all tree computations
bool SaveDotFiles;

265
vtkm/filter/ContourTreeUniformDistributed.hxx
View File

@ -66,15 +66,12 @@
// distributed contour tree includes
#include <vtkm/worklet/contourtree_distributed/BoundaryTree.h>
#include <vtkm/worklet/contourtree_distributed/BoundaryTreeMaker.h>
#include <vtkm/worklet/contourtree_distributed/BranchDecompositionBlock.h>
#include <vtkm/worklet/contourtree_distributed/CombineHyperSweepBlockFunctor.h>
#include <vtkm/worklet/contourtree_distributed/ComputeDistributedBranchDecompositionFunctor.h>
#include <vtkm/worklet/contourtree_distributed/ComputeDistributedContourTreeFunctor.h>
#include <vtkm/worklet/contourtree_distributed/DistributedContourTreeBlockData.h>
#include <vtkm/worklet/contourtree_distributed/HierarchicalAugmenter.h>
#include <vtkm/worklet/contourtree_distributed/HierarchicalAugmenterFunctor.h>
#include <vtkm/worklet/contourtree_distributed/HierarchicalHyperSweeper.h>
#include <vtkm/worklet/contourtree_distributed/HierarchicalVolumetricBranchDecomposer.h>
#include <vtkm/worklet/contourtree_distributed/HyperSweepBlock.h>
#include <vtkm/worklet/contourtree_distributed/InteriorForest.h>
#include <vtkm/worklet/contourtree_distributed/PrintGraph.h>
@ -211,7 +208,6 @@ ContourTreeUniformDistributed::ContourTreeUniformDistributed(
bool useBoundaryExtremaOnly,
bool useMarchingCubes,
bool augmentHierarchicalTree,
bool computeHierarchicalVolumetricBranchDecomposition,
bool saveDotFiles,
vtkm::cont::LogLevel timingsLogLevel,
vtkm::cont::LogLevel treeLogLevel)
@ -219,8 +215,6 @@ ContourTreeUniformDistributed::ContourTreeUniformDistributed(
, UseBoundaryExtremaOnly(useBoundaryExtremaOnly)
, UseMarchingCubes(useMarchingCubes)
, AugmentHierarchicalTree(augmentHierarchicalTree)
, ComputeHierarchicalVolumetricBranchDecomposition(
computeHierarchicalVolumetricBranchDecomposition)
, SaveDotFiles(saveDotFiles)
, TimingsLogLevel(timingsLogLevel)
, TreeLogLevel(treeLogLevel)
@ -235,13 +229,6 @@ ContourTreeUniformDistributed::ContourTreeUniformDistributed(
, LocalInteriorForests(static_cast<std::size_t>(localBlockSizes.GetNumberOfValues()))
{
this->SetOutputFieldName("resultData");
if (this->ComputeHierarchicalVolumetricBranchDecomposition && !this->AugmentHierarchicalTree)
{
this->AugmentHierarchicalTree = true;
VTKM_LOG_S(vtkm::cont::LogLevel::Error,
"Volumetric branch decmomposition requires augmentation. "
<< "Enabling the AugmentHierarchicalTree option.");
}
}
@ -842,144 +829,6 @@ inline VTKM_CONT void ContourTreeUniformDistributed::ComputeVolumeMetric(
});
}
//-----------------------------------------------------------------------------
template <typename FieldType>
inline VTKM_CONT void ContourTreeUniformDistributed::ComputeBranchDecomposition(
vtkmdiy::Master& inputContourTreeMaster,
vtkmdiy::DynamicAssigner& assigner,
vtkmdiy::RegularSwapPartners& partners,
const FieldType&, // dummy parameter to get the type
std::stringstream& timingsStream,
std::vector<vtkm::cont::DataSet>& outputDataSet)
{
vtkm::cont::Timer timer;
timer.Start();
using BranchDecompositionBlock =
vtkm::worklet::contourtree_distributed::BranchDecompositionBlock<FieldType>;
auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
vtkmdiy::Master branch_decomposition_master(comm,
1, // Use 1 thread, VTK-M will do the treading
-1, // All blocks in memory
0, // No create function
BranchDecompositionBlock::Destroy);
// Log the time to create the DIY master for the hyper sweep
timingsStream << " " << std::setw(38) << std::left
<< "Create DIY Master (Branch Decomposition):" << timer.GetElapsedTime()
<< " seconds" << std::endl;
timer.Start();
// Copy data from hierarchical hypersweep to initialize branch decomposition computation
using DistributedContourTreeBlockData =
vtkm::worklet::contourtree_distributed::DistributedContourTreeBlockData<FieldType>;
inputContourTreeMaster.foreach (
[&](DistributedContourTreeBlockData* currInBlock, const vtkmdiy::Master::ProxyWithLink&) {
BranchDecompositionBlock* newBlock = new BranchDecompositionBlock(
currInBlock->LocalBlockNo, currInBlock->GlobalBlockId, currInBlock->AugmentedTree);
// NOTE: Use dummy link to make DIY happy. The dummy link is never used, since all
// communication is via RegularDecomposer, which sets up its own links. No need
// to keep the pointer, as DIY will "own" it and delete it when no longer needed.
// NOTE: Since we passed a "Destroy" function to DIY master, it will own the local data
// blocks and delete them when done.
branch_decomposition_master.add(currInBlock->GlobalBlockId, newBlock, new vtkmdiy::Link());
});
// Log time to copy the data to the HyperSweepBlock data objects
timingsStream << " " << std::setw(38) << std::left << "Initialize Branch Decomposition Data"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
vtkmdiy::fix_links(branch_decomposition_master, assigner);
// Record time to fix the links
timingsStream << " " << std::setw(38) << std::left << "Fix DIY Links (Branch Decomposition)"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
branch_decomposition_master.foreach (
[&](BranchDecompositionBlock* b, const vtkmdiy::Master::ProxyWithLink&) {
// Get intrinsic and dependent volume from data set
vtkm::cont::DataSet ds = outputDataSet[b->LocalBlockNo];
vtkm::cont::ArrayHandle<vtkm::Id> intrinsicVolume =
ds.GetField("IntrinsicVolume").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
vtkm::cont::ArrayHandle<vtkm::Id> dependentVolume =
ds.GetField("DependentVolume").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
// Get global size and compute total volume from it
const auto& globalSize = this->MultiBlockSpatialDecomposition.GlobalSize;
vtkm::Id totalVolume = globalSize[0] * globalSize[1] * globalSize[2];
// Compute local best up and down paths by volume
b->HierarchicalVolumetricBranchDecomposer.LocalBestUpDownByVolume(
&b->HierarchicalContourTree, intrinsicVolume, dependentVolume, totalVolume);
#ifdef DEBUG_PRINT
VTKM_LOG_S(this->TreeLogLevel, "Before reduction");
{
std::stringstream rs;
vtkm::worklet::contourtree_augmented::PrintHeader(
b->HierarchicalVolumetricBranchDecomposer.BestUpSupernode.GetNumberOfValues(), rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestUpSupernode", b->HierarchicalVolumetricBranchDecomposer.BestUpSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestDownSupernode", b->HierarchicalVolumetricBranchDecomposer.BestDownSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestUpVolume", b->HierarchicalVolumetricBranchDecomposer.BestUpVolume, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestDownVolume", b->HierarchicalVolumetricBranchDecomposer.BestDownVolume, -1, rs);
VTKM_LOG_S(this->TreeLogLevel, rs.str());
}
#endif
});
timingsStream << " " << std::setw(38) << std::left << "LocalBestUpDownByVolume"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
// Reduce
// partners for merge over regular block grid
vtkmdiy::reduce(
branch_decomposition_master,
assigner,
partners,
vtkm::worklet::contourtree_distributed::ComputeDistributedBranchDecompositionFunctor<
FieldType>{});
timingsStream << " " << std::setw(38) << std::left
<< "Exchanging best up/down supernode and volume"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
branch_decomposition_master.foreach (
[&](BranchDecompositionBlock* b, const vtkmdiy::Master::ProxyWithLink&) {
b->HierarchicalVolumetricBranchDecomposer.CollapseBranches(&b->HierarchicalContourTree,
b->BranchRoots);
});
timingsStream << " " << std::setw(38) << std::left << "CollapseBranches"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
branch_decomposition_master.foreach ([&](BranchDecompositionBlock* b,
const vtkmdiy::Master::ProxyWithLink&) {
#ifdef DEBUG_PRINT
VTKM_LOG_S(this->TreeLogLevel,
b->HierarchicalVolumetricBranchDecomposer.PrintBranches(&b->HierarchicalContourTree,
b->BranchRoots));
#endif
vtkm::cont::Field branchRootField(
"BranchRoots", vtkm::cont::Field::Association::WholeMesh, b->BranchRoots);
outputDataSet[b->LocalBlockNo].AddField(branchRootField);
});
timingsStream << " " << std::setw(38) << std::left
<< "Creating Branch Decomposition Output Data"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
}
//-----------------------------------------------------------------------------
template <typename FieldType, typename StorageType, typename DerivedPolicy>
VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
@ -1350,77 +1199,61 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
// ******** 5. Create output data set ********
std::vector<vtkm::cont::DataSet> hierarchicalTreeOutputDataSet(master.size());
master.foreach (
[&](DistributedContourTreeBlockData* blockData, const vtkmdiy::Master::ProxyWithLink&) {
std::stringstream createOutdataTimingsStream;
vtkm::cont::Timer iterationTimer;
iterationTimer.Start();
master.foreach ([&](DistributedContourTreeBlockData* blockData,
const vtkmdiy::Master::ProxyWithLink&) {
std::stringstream createOutdataTimingsStream;
vtkm::cont::Timer iterationTimer;
iterationTimer.Start();
// Use the augmented tree if available or otherwise use the unaugmented hierarchical tree from the current block
auto blockHierarchcialTree = this->AugmentHierarchicalTree
? (*blockData->HierarchicalAugmenter.AugmentedTree)
: blockData->HierarchicalTree;
// Use the augmented tree if available or otherwise use the unaugmented hierarchical tree from the current block
const auto& blockHierarchcialTree = this->AugmentHierarchicalTree
? (*blockData->HierarchicalAugmenter.AugmentedTree)
: blockData->HierarchicalTree;
// Create data set from output
vtkm::cont::Field dataValuesField(
"DataValues", vtkm::cont::Field::Association::WholeMesh, blockHierarchcialTree.DataValues);
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(dataValuesField);
vtkm::cont::Field regularNodeGlobalIdsField("RegularNodeGlobalIds",
vtkm::cont::Field::Association::WholeMesh,
blockHierarchcialTree.RegularNodeGlobalIds);
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(regularNodeGlobalIdsField);
vtkm::cont::Field superarcsField(
"Superarcs", vtkm::cont::Field::Association::WholeMesh, blockHierarchcialTree.Superarcs);
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(superarcsField);
vtkm::cont::Field supernodesField(
"Supernodes", vtkm::cont::Field::Association::WholeMesh, blockHierarchcialTree.Supernodes);
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(supernodesField);
vtkm::cont::Field superparentsField("Superparents",
vtkm::cont::Field::Association::WholeMesh,
blockHierarchcialTree.Superparents);
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(superparentsField);
// Add the information to the output data set
blockHierarchcialTree.AddToVTKMDataSet(hierarchicalTreeOutputDataSet[blockData->LocalBlockNo]);
// Copy cell set from input data set. This is mainly to ensure that the output data set
// has a defined cell set. Without one, serialization for DIY does not work properly.
// Having the extents of the input data set may also help in other use cases.
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].SetCellSet(
input.GetPartition(blockData->LocalBlockNo).GetCellSet());
// Copy cell set from input data set. This is mainly to ensure that the output data set
// has a defined cell set. Without one, serialization for DIY does not work properly.
// Having the extents of the input data set may also help in other use cases.
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].SetCellSet(
input.GetPartition(blockData->LocalBlockNo).GetCellSet());
// Log the time for each of the iterations of the fan out loop
createOutdataTimingsStream << " Create Output Dataset (block=" << blockData->LocalBlockNo
// Log the time for each of the iterations of the fan out loop
createOutdataTimingsStream << " Create Output Dataset (block=" << blockData->LocalBlockNo
<< ") : " << iterationTimer.GetElapsedTime() << " seconds"
<< std::endl;
iterationTimer.Start();
// save the corresponding .gv file
if (this->SaveDotFiles)
{
auto nRounds = blockData->ContourTrees.size() - 1;
vtkm::filter::contourtree_distributed_detail::SaveHierarchicalTreeDot(
blockData, rank, nRounds);
createOutdataTimingsStream << " Save Dot (block=" << blockData->LocalBlockNo
<< ") : " << iterationTimer.GetElapsedTime() << " seconds"
<< std::endl;
iterationTimer.Start();
} // if(this->SaveDotFiles)
// save the corresponding .gv file
if (this->SaveDotFiles)
{
auto nRounds = blockData->ContourTrees.size() - 1;
vtkm::filter::contourtree_distributed_detail::SaveHierarchicalTreeDot(
blockData, rank, nRounds);
// Log the timing stats we collected
VTKM_LOG_S(this->TimingsLogLevel,
std::endl
<< " ------------ Create Output Data (block=" << blockData->LocalBlockNo
<< ") ------------" << std::endl
<< createOutdataTimingsStream.str());
createOutdataTimingsStream << " Save Dot (block=" << blockData->LocalBlockNo
<< ") : " << iterationTimer.GetElapsedTime() << " seconds"
<< std::endl;
iterationTimer.Start();
} // if(this->SaveDotFiles)
// Log the timing stats we collected
VTKM_LOG_S(this->TimingsLogLevel,
std::endl
<< " ------------ Create Output Data (block=" << blockData->LocalBlockNo
<< ") ------------" << std::endl
<< createOutdataTimingsStream.str());
// Log the stats from the hierarchical contour tree
VTKM_LOG_S(this->TreeLogLevel,
std::endl
<< " ------------ Hierarchical Tree Construction Stats ------------"
<< std::endl
<< std::setw(42) << std::left << " LocalBlockNo"
<< ": " << blockData->LocalBlockNo << std::endl
<< blockData->HierarchicalTree.PrintTreeStats() << std::endl);
}); // master.foreach
// Log the stats from the hierarchical contour tree
VTKM_LOG_S(this->TreeLogLevel,
std::endl
<< " ------------ Hierarchical Tree Construction Stats ------------"
<< std::endl
<< std::setw(42) << std::left << " LocalBlockNo"
<< ": " << blockData->LocalBlockNo << std::endl
<< blockData->HierarchicalTree.PrintTreeStats() << std::endl);
}); // master.foreach
// 3.1 Log total augmentation time
timingsStream << " " << std::setw(38) << std::left << "Create Output Data"
@ -1433,12 +1266,6 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
master, assigner, partners, FieldType{}, timingsStream, hierarchicalTreeOutputDataSet);
}
if (this->ComputeHierarchicalVolumetricBranchDecomposition)
{
this->ComputeBranchDecomposition(
master, assigner, partners, FieldType{}, timingsStream, hierarchicalTreeOutputDataSet);
}
VTKM_LOG_S(this->TimingsLogLevel,
std::endl
<< " ------------ DoPostExecute Timings ------------" << std::endl

99
vtkm/filter/scalar_topology/BranchDecompositionBlock.cxx Normal file
View File

@ -0,0 +1,99 @@
//============================================================================
// 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)
//==============================================================================
#include <vtkm/filter/scalar_topology/BranchDecompositionBlock.h>
// Contour tree includes, not ye moved to new filter design
#include <vtkm/worklet/contourtree/Types.h>
namespace vtkm
{
namespace worklet
{
namespace scalar_topology
{
vtkm::cont::ArrayHandleGroupVecVariable<vtkm::cont::ArrayHandle<vtkm::Id>,
vtkm::cont::ArrayHandle<vtkm::Id>>
BranchDecompositionBlock::CreateFirstsupernodePerIterationArrayHandle(
const vtkm::cont::DataSet& hierarchicalContourTreeDataSet)
{
vtkm::cont::ArrayHandle<vtkm::Id> FirstSupernodePerIterationComponents;
vtkm::cont::ArrayHandle<vtkm::Id> FirstSupernodePerIterationOffsets;
vtkm::cont::ArrayCopyShallowIfPossible(
hierarchicalContourTreeDataSet.GetField("FirstSupernodePerIterationComponents").GetData(),
FirstSupernodePerIterationComponents);
vtkm::cont::ArrayCopyShallowIfPossible(
hierarchicalContourTreeDataSet.GetField("FirstSupernodePerIterationOffsets").GetData(),
FirstSupernodePerIterationOffsets);
return vtkm::cont::make_ArrayHandleGroupVecVariable(FirstSupernodePerIterationComponents,
FirstSupernodePerIterationOffsets);
}
BranchDecompositionBlock::BranchDecompositionBlock(
vtkm::Id localBlockNo,
int globalBlockId,
const vtkm::cont::DataSet& hierarchicalTreeDataSet)
: LocalBlockNo(localBlockNo)
, GlobalBlockId(globalBlockId)
, FirstSupernodePerIteration(CreateFirstsupernodePerIterationArrayHandle(hierarchicalTreeDataSet))
{
vtkm::Id nSupernodes =
hierarchicalTreeDataSet.GetField("Supernodes").GetData().GetNumberOfValues();
this->BranchRoots.AllocateAndFill(nSupernodes,
vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT);
}
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm

54
vtkm/worklet/contourtree_distributed/BranchDecompositionBlock.h → vtkm/filter/scalar_topology/BranchDecompositionBlock.h
View File

@ -53,55 +53,45 @@
#ifndef vtk_m_worklet_contourtree_distributed_branchdecompositionblock_h
#define vtk_m_worklet_contourtree_distributed_branchdecompositionblock_h
#include <vtkm/worklet/contourtree/Types.h>
#include <vtkm/worklet/contourtree_distributed/HierarchicalContourTree.h>
#include <vtkm/worklet/contourtree_distributed/HierarchicalVolumetricBranchDecomposer.h>
// Contour tree includes
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/HierarchicalVolumetricBranchDecomposer.h>
namespace vtkm
{
namespace worklet
{
namespace contourtree_distributed
namespace scalar_topology
{
template <typename ContourTreeDataFieldType>
struct BranchDecompositionBlock
{
BranchDecompositionBlock(
vtkm::Id localBlockNo,
int globalBlockId,
const vtkm::worklet::contourtree_distributed::HierarchicalContourTree<ContourTreeDataFieldType>&
hierarchicalContourTree)
: LocalBlockNo(localBlockNo)
, GlobalBlockId(globalBlockId)
, HierarchicalContourTree(hierarchicalContourTree)
{
// Import/alias for readability
using vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
const vtkm::Id nSupernodes = HierarchicalContourTree.Supernodes.GetNumberOfValues();
//VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Allocating " << nSupernodes << " valies in BranchRoots");
BranchRoots.AllocateAndFill(nSupernodes, NO_SUCH_ELEMENT);
}
static vtkm::cont::ArrayHandleGroupVecVariable<vtkm::cont::ArrayHandle<vtkm::Id>,
vtkm::cont::ArrayHandle<vtkm::Id>>
CreateFirstsupernodePerIterationArrayHandle(
const vtkm::cont::DataSet& hierarchicalContourTreeDataSet);
// Block metadata TODO/FIXME: Check whether really needed
BranchDecompositionBlock(vtkm::Id localBlockNo,
int globalBlockId,
const vtkm::cont::DataSet& hierarchicalTreeDataSet);
// Block metadata
vtkm::Id LocalBlockNo;
int GlobalBlockId;
int GlobalBlockId; // TODO/FIXME: Check whether really needed. Possibly only during debugging
const vtkm::worklet::contourtree_distributed::HierarchicalContourTree<ContourTreeDataFieldType>&
HierarchicalContourTree;
vtkm::worklet::contourtree_distributed::HierarchicalVolumetricBranchDecomposer<
ContourTreeDataFieldType>
HierarchicalVolumetricBranchDecomposer;
// Data from hierarchical tree needed during reduction
vtkm::cont::ArrayHandleGroupVecVariable<vtkm::cont::ArrayHandle<vtkm::Id>,
vtkm::cont::ArrayHandle<vtkm::Id>>
FirstSupernodePerIteration;
// Decomposer used during reduction and output data set
HierarchicalVolumetricBranchDecomposer VolumetricBranchDecomposer;
vtkm::cont::ArrayHandle<vtkm::Id> BranchRoots;
// Destroy function allowing DIY to own blocks and clean them up after use
static void Destroy(void* b)
{
delete static_cast<BranchDecompositionBlock<ContourTreeDataFieldType>*>(b);
}
static void Destroy(void* b) { delete static_cast<BranchDecompositionBlock*>(b); }
};
} // namespace contourtree_distributed
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm
#endif

49
vtkm/filter/scalar_topology/CMakeLists.txt Normal file
View File

@ -0,0 +1,49 @@
##============================================================================
## 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.
##============================================================================
set(scalar_topology_headers
BranchDecompositionBlock.h
ComputeDistributedBranchDecompositionFunctor.h
DistributedBranchDecompositionFilter.h
)
set(scalar_topology_sources
BranchDecompositionBlock.cxx
ComputeDistributedBranchDecompositionFunctor.cxx
DistributedBranchDecompositionFilter.cxx
)
# TODO/FIXME: Is the following line needed
# set_source_files_properties(DistributedBranchDecompositionFilter.cxx PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
vtkm_library(
NAME vtkm_filter_scalar_topology
HEADERS ${scalar_topology_headers}
DEVICE_SOURCES ${scalar_topology_sources}
USE_VTKM_JOB_POOL
)
# TODO/FIXME: Are the following lines needed
# set_property(TARGET
# vtkm_filter_scalar_topology
# PROPERTY UNITY_BUILD_MODE GROUP
# )
target_link_libraries(vtkm_filter_scalar_topology PUBLIC vtkm_worklet vtkm_filter_core)
if (VTKm_ENABLE_MPI)
target_link_libraries(vtkm_filter_scalar_topology PUBLIC MPI::MPI_CXX)
endif ()
target_link_libraries(vtkm_filter PUBLIC INTERFACE vtkm_filter_scalar_topology)
add_subdirectory(worklet)
#-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
if (VTKm_ENABLE_TESTING)
add_subdirectory(testing)
endif ()

220
vtkm/filter/scalar_topology/ComputeDistributedBranchDecompositionFunctor.cxx Normal file
View File

@ -0,0 +1,220 @@
//============================================================================
// 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)
//==============================================================================
#include <vtkm/filter/scalar_topology/ComputeDistributedBranchDecompositionFunctor.h>
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/FindBestSupernodeWorklet.h>
#include <vtkm/Types.h>
#ifdef DEBUG_PRINT
#define DEBUG_PRINT_COMBINED_BLOCK_IDS
#endif
namespace vtkm
{
namespace worklet
{
namespace scalar_topology
{
void ComputeDistributedBranchDecompositionFunctor::operator()(
vtkm::worklet::scalar_topology::BranchDecompositionBlock* b,
const vtkmdiy::ReduceProxy& rp, // communication proxy
const vtkmdiy::RegularSwapPartners& // partners of the current block (unused)
) const
{
// Get our rank and DIY id
//const vtkm::Id rank = vtkm::cont::EnvironmentTracker::GetCommunicator().rank();
const auto selfid = rp.gid();
// Aliases to reduce verbosity
auto& branchDecomposer = b->VolumetricBranchDecomposer;
std::vector<int> incoming;
rp.incoming(incoming);
for (const int ingid : incoming)
{
// NOTE/IMPORTANT: In each round we should have only one swap partner (despite for-loop here).
// If that assumption does not hold, it will break things.
// NOTE/IMPORTANT: This assumption only holds if the number of blocks is a power of two.
// Otherwise, we may need to process more than one incoming block
if (ingid != selfid)
{
#ifdef DEBUG_PRINT_COMBINED_BLOCK_IDS
int incomingGlobalBlockId;
rp.dequeue(ingid, incomingGlobalBlockId);
VTKM_LOG_S(vtkm::cont::LogLevel::Info,
"Combining local block " << b->GlobalBlockId << " with incomoing block "
<< incomingGlobalBlockId);
#endif
// Receive data from swap partner
vtkm::cont::ArrayHandle<vtkm::Id> incomingBestUpVolume;
rp.dequeue(ingid, incomingBestUpVolume);
vtkm::cont::ArrayHandle<vtkm::Id> incomingBestUpSupernode;
rp.dequeue(ingid, incomingBestUpSupernode);
vtkm::cont::ArrayHandle<vtkm::Id> incomingBestDownVolume;
rp.dequeue(ingid, incomingBestDownVolume);
vtkm::cont::ArrayHandle<vtkm::Id> incomingBestDownSupernode;
rp.dequeue(ingid, incomingBestDownSupernode);
vtkm::Id prefixLength = b->FirstSupernodePerIteration.ReadPortal().Get(rp.round() - 1)[0];
#ifdef DEBUG_PRINT
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Prefix length is " << prefixLength);
{
std::stringstream rs;
vtkm::worklet::contourtree_augmented::PrintHeader(
incomingBestUpSupernode.GetNumberOfValues(), rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"incomingBestUpSupernode", incomingBestUpSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"incomingBestDownSupernode", incomingBestDownSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"incomingBestUpVolume", incomingBestUpVolume, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"incomingBestDownVolume", incomingBestDownVolume, -1, rs);
VTKM_LOG_S(vtkm::cont::LogLevel::Info, rs.str());
}
#endif
// NOTE: We are processing input data from the previous round, hence, get
// first supernide per ieteration from previous round
// Create 'views' to restrict worklet to relevant portion of arrays
auto bestUpVolumeView = make_ArrayHandleView(branchDecomposer.BestUpVolume, 0, prefixLength);
auto bestUpSupernodeView =
make_ArrayHandleView(branchDecomposer.BestUpSupernode, 0, prefixLength);
auto bestDownVolumeView =
make_ArrayHandleView(branchDecomposer.BestDownVolume, 0, prefixLength);
auto bestDownSupernodeView =
make_ArrayHandleView(branchDecomposer.BestDownSupernode, 0, prefixLength);
// Check if swap partner knows a better up /down and update
vtkm::cont::Invoker invoke;
invoke(vtkm::worklet::scalar_topology::hierarchical_volumetric_branch_decomposer::
FindBestSupernodeWorklet<true>{},
incomingBestUpVolume,
incomingBestUpSupernode,
bestUpVolumeView,
bestUpSupernodeView);
invoke(vtkm::worklet::scalar_topology::hierarchical_volumetric_branch_decomposer::
FindBestSupernodeWorklet<false>{},
incomingBestDownVolume,
incomingBestDownSupernode,
bestDownVolumeView,
bestDownSupernodeView);
#ifdef DEBUG_PRINT
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "After round " << rp.round() - 1);
{
std::stringstream rs;
vtkm::worklet::contourtree_augmented::PrintHeader(
branchDecomposer.BestUpSupernode.GetNumberOfValues(), rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestUpSupernode", branchDecomposer.BestUpSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestDownSupernode", branchDecomposer.BestDownSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestUpVolume", branchDecomposer.BestUpVolume, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestDownVolume", branchDecomposer.BestDownVolume, -1, rs);
VTKM_LOG_S(vtkm::cont::LogLevel::Info, rs.str());
}
#endif
}
}
for (int cc = 0; cc < rp.out_link().size(); ++cc)
{
auto target = rp.out_link().target(cc);
if (target.gid != selfid)
{
#ifdef DEBUG_PRINT_COMBINED_BLOCK_IDS
rp.enqueue(target, b->GlobalBlockId);
#endif
// Determine which portion of up/down volume/supernode to send
vtkm::Id prefixLength = b->FirstSupernodePerIteration.ReadPortal().Get(rp.round())[0];
// Create 'views' to restrict sending to relevant portion of arrays
auto bestUpVolumeView = make_ArrayHandleView(branchDecomposer.BestUpVolume, 0, prefixLength);
auto bestUpSupernodeView =
make_ArrayHandleView(branchDecomposer.BestUpSupernode, 0, prefixLength);
auto bestDownVolumeView =
make_ArrayHandleView(branchDecomposer.BestDownVolume, 0, prefixLength);
auto bestDownSupernodeView =
make_ArrayHandleView(branchDecomposer.BestDownSupernode, 0, prefixLength);
// TODO/FIXME: Check if it is possible to send a portion of the arrays
// without copy. enqueue does not accept ArrayHandleView as input as it
// is not trivially copyable
vtkm::cont::ArrayHandle<vtkm::Id> sendBestUpVolume;
vtkm::cont::Algorithm::Copy(bestUpVolumeView, sendBestUpVolume);
vtkm::cont::ArrayHandle<vtkm::Id> sendBestUpSupernode;
vtkm::cont::Algorithm::Copy(bestUpSupernodeView, sendBestUpSupernode);
vtkm::cont::ArrayHandle<vtkm::Id> sendBestDownVolume;
vtkm::cont::Algorithm::Copy(bestDownVolumeView, sendBestDownVolume);
vtkm::cont::ArrayHandle<vtkm::Id> sendBestDownSupernode;
vtkm::cont::Algorithm::Copy(bestDownSupernodeView, sendBestDownSupernode);
rp.enqueue(target, sendBestUpVolume);
rp.enqueue(target, sendBestUpSupernode);
rp.enqueue(target, sendBestDownVolume);
rp.enqueue(target, sendBestDownSupernode);
}
}
}
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm

84
vtkm/filter/scalar_topology/ComputeDistributedBranchDecompositionFunctor.h Normal file
View File

@ -0,0 +1,84 @@
//============================================================================
// 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__h
#define vtk_m_worklet_contourtree_distributed__h
#include <vtkm/filter/scalar_topology/BranchDecompositionBlock.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include <vtkm/thirdparty/diy/diy.h>
VTKM_THIRDPARTY_POST_INCLUDE
// clang-format on
namespace vtkm
{
namespace worklet
{
namespace scalar_topology
{
struct ComputeDistributedBranchDecompositionFunctor
{
void operator()(vtkm::worklet::scalar_topology::BranchDecompositionBlock* b,
const vtkmdiy::ReduceProxy& rp, // communication proxy
const vtkmdiy::RegularSwapPartners& // partners of the current block (unused)
) const;
};
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm
#endif

281
vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx Normal file
View File

@ -0,0 +1,281 @@
//============================================================================
// 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.
//============================================================================
#include <vtkm/filter/scalar_topology/BranchDecompositionBlock.h>
#include <vtkm/filter/scalar_topology/ComputeDistributedBranchDecompositionFunctor.h>
#include <vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.h>
// vtkm includes
#include <vtkm/cont/Timer.h>
// DIY includes
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include <vtkm/thirdparty/diy/Configure.h>
#include <vtkm/thirdparty/diy/diy.h>
VTKM_THIRDPARTY_POST_INCLUDE
// clang-format on
namespace vtkm
{
namespace filter
{
namespace scalar_topology
{
// Constructor to record information about spatial decomposition
// TODO/FIXME: Add this information to PartitionedDataSet, so that we do
// not need to pass it sperately (or check if it can already be derived from
// information stored in PartitionedDataSet)
VTKM_CONT DistributedBranchDecompositionFilter::DistributedBranchDecompositionFilter(
vtkm::Id3 blocksPerDim,
vtkm::Id3 globalSize,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes)
: MultiBlockSpatialDecomposition(blocksPerDim,
globalSize,
localBlockIndices,
localBlockOrigins,
localBlockSizes)
{
}
VTKM_CONT vtkm::cont::DataSet DistributedBranchDecompositionFilter::DoExecute(
const vtkm::cont::DataSet& input)
{
// TODO/FIXME: Is there a better way to do this?
return input; // Dummy function, not used
}
VTKM_CONT vtkm::cont::PartitionedDataSet DistributedBranchDecompositionFilter::DoExecutePartitions(
const vtkm::cont::PartitionedDataSet& input)
{
vtkm::cont::Timer timer;
timer.Start();
std::stringstream timingsStream;
// Set up DIY master
// TODO/FIXME: A lot of the code to set up DIY is the same for this filter and
// ContourTreeUniformDistributed. Consolidate? (Which is difficult to do as
// multiple variables are set up with some subtle differences)
auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
int rank = comm.rank();
int size = comm.size();
using BranchDecompositionBlock = vtkm::worklet::scalar_topology::BranchDecompositionBlock;
vtkmdiy::Master branch_decomposition_master(comm,
1, // Use 1 thread, VTK-M will do the treading
-1, // All blocks in memory
0, // No create function
BranchDecompositionBlock::Destroy);
timingsStream << " " << std::setw(60) << std::left
<< "Create DIY Master (Branch Decomposition)"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
// Compute global ids (gids) for our local blocks
using RegularDecomposer = vtkmdiy::RegularDecomposer<vtkmdiy::DiscreteBounds>;
int globalNumberOfBlocks =
static_cast<int>(this->MultiBlockSpatialDecomposition.GetGlobalNumberOfBlocks());
int numDims = static_cast<int>(this->MultiBlockSpatialDecomposition.NumberOfDimensions());
// ... compute division vector for global domain
RegularDecomposer::DivisionsVector diyDivisions(numDims);
for (vtkm::IdComponent d = 0; d < static_cast<vtkm::IdComponent>(numDims); ++d)
{
diyDivisions[d] = static_cast<int>(this->MultiBlockSpatialDecomposition.BlocksPerDimension[d]);
}
// ... compute coordinates of local blocks
std::vector<int> vtkmdiyLocalBlockGids(static_cast<size_t>(input.GetNumberOfPartitions()));
auto localBlockIndicesPortal =
this->MultiBlockSpatialDecomposition.LocalBlockIndices.ReadPortal();
for (vtkm::Id bi = 0; bi < input.GetNumberOfPartitions(); bi++)
{
RegularDecomposer::DivisionsVector diyCoords(static_cast<size_t>(numDims));
auto currentCoords = localBlockIndicesPortal.Get(bi);
for (vtkm::IdComponent d = 0; d < numDims; ++d)
{
diyCoords[d] = static_cast<int>(currentCoords[d]);
}
vtkmdiyLocalBlockGids[static_cast<size_t>(bi)] =
RegularDecomposer::coords_to_gid(diyCoords, diyDivisions);
}
// Record time to compute the local block ids
timingsStream << " " << std::setw(60) << std::left
<< "Compute Block Ids and Local Links (Branch Decomposition)"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
// Initialize branch decomposition computation from data in PartitionedDataSet blocks
for (vtkm::Id localBlockIndex = 0; localBlockIndex < input.GetNumberOfPartitions();
++localBlockIndex)
{
int globalBlockId = vtkmdiyLocalBlockGids[localBlockIndex];
const vtkm::cont::DataSet& ds = input.GetPartition(localBlockIndex);
BranchDecompositionBlock* newBlock =
new BranchDecompositionBlock(localBlockIndex, globalBlockId, ds);
// NOTE: Use dummy link to make DIY happy. The dummy link is never used, since all
// communication is via RegularDecomposer, which sets up its own links. No need
// to keep the pointer, as DIY will "own" it and delete it when no longer needed.
// NOTE: Since we passed a "Destroy" function to DIY master, it will own the local data
// blocks and delete them when done.
branch_decomposition_master.add(globalBlockId, newBlock, new vtkmdiy::Link());
}
// Log time to copy the data to the HyperSweepBlock data objects
timingsStream << " " << std::setw(60) << std::left << "Initialize Branch Decomposition Data"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
// Set up DIY for binary reduction
RegularDecomposer::BoolVector shareFace(3, true);
RegularDecomposer::BoolVector wrap(3, false);
RegularDecomposer::CoordinateVector ghosts(3, 1);
RegularDecomposer decomposer(numDims,
this->MultiBlockSpatialDecomposition.GetVTKmDIYBounds(),
static_cast<int>(globalNumberOfBlocks),
shareFace,
wrap,
ghosts,
diyDivisions);
// Define which blocks live on which rank so that vtkmdiy can manage them
vtkmdiy::DynamicAssigner assigner(comm, size, globalNumberOfBlocks);
for (vtkm::Id bi = 0; bi < input.GetNumberOfPartitions(); bi++)
{
assigner.set_rank(rank, vtkmdiyLocalBlockGids[static_cast<size_t>(bi)]);
}
timingsStream << " " << std::setw(60) << std::left
<< "Create DIY Decomposer and Assigner (Branch Decomposition)"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
// Fix the vtkmdiy links.
vtkmdiy::fix_links(branch_decomposition_master, assigner);
timingsStream << " " << std::setw(60) << std::left << "Fix DIY Links (Branch Decomposition)"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
// partners for merge over regular block grid
vtkmdiy::RegularSwapPartners partners(
decomposer, // domain decomposition
2, // radix of k-ary reduction.
true // contiguous: true=distance doubling, false=distance halving
);
timingsStream << " " << std::setw(60) << std::left
<< "Create DIY Swap Partners (Branch Decomposition)"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
// Compute the initial volumes
branch_decomposition_master.foreach (
[&](BranchDecompositionBlock* b, const vtkmdiy::Master::ProxyWithLink&) {
// Get intrinsic and dependent volume from data set
const vtkm::cont::DataSet& ds = input.GetPartition(b->LocalBlockNo);
vtkm::cont::ArrayHandle<vtkm::Id> intrinsicVolume =
ds.GetField("IntrinsicVolume").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
vtkm::cont::ArrayHandle<vtkm::Id> dependentVolume =
ds.GetField("DependentVolume").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
// Get global size and compute total volume from it
const auto& globalSize = this->MultiBlockSpatialDecomposition.GlobalSize;
vtkm::Id totalVolume = globalSize[0] * globalSize[1] * globalSize[2];
// Compute local best up and down paths by volume
b->VolumetricBranchDecomposer.LocalBestUpDownByVolume(
ds, intrinsicVolume, dependentVolume, totalVolume);
#ifdef DEBUG_PRINT
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Before reduction");
{
std::stringstream rs;
vtkm::worklet::contourtree_augmented::PrintHeader(
b->HierarchicalVolumetricBranchDecomposer.BestUpSupernode.GetNumberOfValues(), rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestUpSupernode", b->HierarchicalVolumetricBranchDecomposer.BestUpSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestDownSupernode", b->HierarchicalVolumetricBranchDecomposer.BestDownSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestUpVolume", b->HierarchicalVolumetricBranchDecomposer.BestUpVolume, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestDownVolume", b->HierarchicalVolumetricBranchDecomposer.BestDownVolume, -1, rs);
VTKM_LOG_S(this->TreeLogLevel, rs.str());
}
#endif
});
timingsStream << " " << std::setw(60) << std::left << "LocalBestUpDownByVolume"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
// Reduce
// partners for merge over regular block grid
vtkmdiy::reduce(branch_decomposition_master,
assigner,
partners,
vtkm::worklet::scalar_topology::ComputeDistributedBranchDecompositionFunctor{});
timingsStream << " " << std::setw(60) << std::left
<< "Exchanging best up/down supernode and volume"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
branch_decomposition_master.foreach (
[&](BranchDecompositionBlock* b, const vtkmdiy::Master::ProxyWithLink&) {
const vtkm::cont::DataSet& ds = input.GetPartition(b->LocalBlockNo);
b->VolumetricBranchDecomposer.CollapseBranches(ds, b->BranchRoots);
});
timingsStream << " " << std::setw(38) << std::left << "CollapseBranches"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
timer.Start();
std::vector<vtkm::cont::DataSet> outputDataSets(input.GetNumberOfPartitions());
// Copy input data set to output
// TODO/FIXME: Should we really do this? Or just output branchRoots
// and let the application deal with two ParitionedDataSet objects
// if it also needs access to the other contour tree data
for (vtkm::Id ds_no = 0; ds_no < input.GetNumberOfPartitions(); ++ds_no)
{
outputDataSets[ds_no] = input.GetPartition(ds_no);
}
branch_decomposition_master.foreach (
[&](BranchDecompositionBlock* b, const vtkmdiy::Master::ProxyWithLink&) {
vtkm::cont::Field branchRootField(
"BranchRoots", vtkm::cont::Field::Association::WholeMesh, b->BranchRoots);
outputDataSets[b->LocalBlockNo].AddField(branchRootField);
});
timingsStream << " " << std::setw(38) << std::left
<< "Creating Branch Decomposition Output Data"
<< ": " << timer.GetElapsedTime() << " seconds" << std::endl;
VTKM_LOG_S(vtkm::cont::LogLevel::Perf,
std::endl
<< "----------- DoExecutePartitions Timings ------------" << std::endl
<< timingsStream.str());
return vtkm::cont::PartitionedDataSet{ outputDataSets };
}
} // namespace scalar_topology
} // namespace filter
} // namespace vtkm

82
vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.h Normal file
View File

@ -0,0 +1,82 @@
//============================================================================
// 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.
//
//=============================================================================
#ifndef vtk_m_filter_contour_tree_DistributedBranchDecompositionFilter_h
#define vtk_m_filter_contour_tree_DistributedBranchDecompositionFilter_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/scalar_topology/vtkm_filter_scalar_topology_export.h>
#include <vtkm/worklet/contourtree_distributed/SpatialDecomposition.h>
namespace vtkm
{
namespace filter
{
namespace scalar_topology
{
/// \brief Compute branch decompostion from distributed contour tree
class VTKM_FILTER_SCALAR_TOPOLOGY_EXPORT DistributedBranchDecompositionFilter
: public vtkm::filter::NewFilter
{
public:
VTKM_CONT DistributedBranchDecompositionFilter(
vtkm::Id3 blocksPerDim,
vtkm::Id3 globalSize,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes);
private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
const vtkm::cont::PartitionedDataSet& inData) override;
/// Information about the spatial decomposition
vtkm::worklet::contourtree_distributed::SpatialDecomposition MultiBlockSpatialDecomposition;
};
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm
#endif

11
vtkm/filter/scalar_topology/testing/CMakeLists.txt Normal file
View File

@ -0,0 +1,11 @@
##=============================================================================
##
## 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.
##
##=============================================================================

11
vtkm/filter/scalar_topology/worklet/CMakeLists.txt Normal file
View File

@ -0,0 +1,11 @@
##============================================================================
## 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.
##============================================================================
add_subdirectory(branch_decomposition)

17
vtkm/filter/scalar_topology/worklet/branch_decomposition/CMakeLists.txt Normal file
View File

@ -0,0 +1,17 @@
##============================================================================
## 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.
##============================================================================
set(headers
HierarchicalVolumetricBranchDecomposer.h
)
#-----------------------------------------------------------------------------
add_subdirectory(hierarchical_volumetric_branch_decomposer)
vtkm_declare_headers(${headers})

363
vtkm/worklet/contourtree_distributed/HierarchicalVolumetricBranchDecomposer.h → vtkm/filter/scalar_topology/worklet/branch_decomposition/HierarchicalVolumetricBranchDecomposer.h
View File

@ -116,24 +116,27 @@
//=======================================================================================
#ifndef vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_h
#define vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_h
#ifndef vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_h
#define vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_h
#include <iomanip>
#include <string>
// Contour tree includes, not yet moved into new filter structure
#include <vtkm/worklet/contourtree_augmented/NotNoSuchElementPredicate.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_distributed/PrintGraph.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_contour_tree/FindRegularByGlobal.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_contour_tree/FindSuperArcBetweenNodes.h>
#include <vtkm/worklet/contourtree_distributed/HierarchicalContourTree.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/CollapseBranchesPointerDoublingWorklet.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/CollapseBranchesWorklet.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeBestUpDownEdgeWorklet.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeInitSuperarcListWorklet.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeWorklet.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/SuperArcVolumetricComparatorIndirectGlobalIdComparator.h>
// Worklets
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/CollapseBranchesPointerDoublingWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/CollapseBranchesWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeBestUpDownEdgeWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeInitSuperarcListWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/SuperArcVolumetricComparatorIndirectGlobalIdComparator.h>
#ifdef DEBUG_PRINT
#define DEBUG_HIERARCHICAL_VOLUMETRIC_BRANCH_DECOMPOSER
@ -143,11 +146,10 @@ namespace vtkm
{
namespace worklet
{
namespace contourtree_distributed
namespace scalar_topology
{
/// Facture class for augmenting the hierarchical contour tree to enable computations of measures, e.g., volumne
template <typename FieldType>
class HierarchicalVolumetricBranchDecomposer
{ // class HierarchicalVolumetricBranchDecomposer
public:
@ -162,11 +164,6 @@ public:
vtkm::worklet::contourtree_augmented::IdArrayType UpVolume;
vtkm::worklet::contourtree_augmented::IdArrayType DownVolume;
/// Because we want to use array allocation in main, we need a default constructor
/// Unfortunately, that means we have problems with references, and the workaround is to have
/// the references passed to the individual functions
HierarchicalVolumetricBranchDecomposer<FieldType>(){};
/// routines to compute branch decomposition by volume
/// WARNING: we now have two types of hierarchical tree sharing a data structure:
/// I. hierarchical tree without augmentation
@ -194,23 +191,22 @@ public:
/// routine that determines the best upwards/downwards edges at each vertex
/// Unlike the local version, the best might only be stored on another rank
/// so we will compute the locally best up or down, then swap until all ranks choose the same best
void LocalBestUpDownByVolume(
const vtkm::worklet::contourtree_distributed::HierarchicalContourTree<FieldType>*
hierarchicalTree,
const vtkm::cont::ArrayHandle<vtkm::Id>& intrinsicValues,
const vtkm::cont::ArrayHandle<vtkm::Id>& dependentValues,
vtkm::Id totalVolume);
void LocalBestUpDownByVolume(const vtkm::cont::DataSet& hierarchicalTreeDataSet,
const vtkm::cont::ArrayHandle<vtkm::Id>& intrinsicValues,
const vtkm::cont::ArrayHandle<vtkm::Id>& dependentValues,
vtkm::Id totalVolume);
/// routine to compute the local set of superarcs that root at a given one
void CollapseBranches(const vtkm::worklet::contourtree_distributed::HierarchicalContourTree<
FieldType>* hierarchicalTree,
void CollapseBranches(const vtkm::cont::DataSet& hierarchicalTreeDataSet,
vtkm::worklet::contourtree_augmented::IdArrayType& branchRoot);
// routine to print branches
std::string PrintBranches(const vtkm::worklet::contourtree_distributed::HierarchicalContourTree<
FieldType>* hierarchicalTree,
const vtkm::worklet::contourtree_augmented::IdArrayType& branchRoot);
/// routines to print branches
template <typename IdArrayHandleType, typename DataValueArrayHandleType>
static std::string PrintBranches(const IdArrayHandleType& hierarchicalTreeSuperarcsAH,
const IdArrayHandleType& hierarchicalTreeSupernodesAH,
const IdArrayHandleType& hierarchicalTreeRegularNodeGlobalIdsAH,
const DataValueArrayHandleType& hierarchicalTreeDataValuesAH,
const IdArrayHandleType& branchRootAH);
static std::string PrintBranches(const vtkm::cont::DataSet& ds);
/// debug routine
@ -223,31 +219,39 @@ private:
}; // class HierarchicalVolumetricBranchDecomposer
template <typename FieldType>
void HierarchicalVolumetricBranchDecomposer<FieldType>::LocalBestUpDownByVolume(
const vtkm::worklet::contourtree_distributed::HierarchicalContourTree<FieldType>*
hierarchicalTree,
inline void HierarchicalVolumetricBranchDecomposer::LocalBestUpDownByVolume(
const vtkm::cont::DataSet& hierarchicalTreeDataSet,
const vtkm::cont::ArrayHandle<vtkm::Id>& intrinsicValues,
const vtkm::cont::ArrayHandle<vtkm::Id>& dependentValues,
vtkm::Id totalVolume)
{
// Get required arrays for hierarchical tree form data set
auto hierarchicalTreeSupernodes = hierarchicalTreeDataSet.GetField("Supernodes")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
auto hierarchicalTreeSuperarcs = hierarchicalTreeDataSet.GetField("Superarcs")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
auto hierarchicalTreeRegularNodeGlobalIds =
hierarchicalTreeDataSet.GetField("RegularNodeGlobalIds")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
// LocalBestUpDownByVolume
// STAGE I: Allocate memory for our arrays
vtkm::Id nSupernodes = hierarchicalTree->Supernodes.GetNumberOfValues();
vtkm::Id nSupernodes = hierarchicalTreeSupernodes.GetNumberOfValues();
// WARNING: This differs from the non-hierarchical version by using the full size *WITH* virtual superarcs
vtkm::Id nSuperarcs = hierarchicalTree->Superarcs.GetNumberOfValues();
vtkm::Id nSuperarcs = hierarchicalTreeSuperarcs.GetNumberOfValues();
// set up a list of superarcs as Edges for reference in our comparator
vtkm::worklet::contourtree_augmented::EdgePairArray superarcList;
superarcList.Allocate(nSuperarcs);
VTKM_ASSERT(hierarchicalTree->Superarcs.GetNumberOfValues() == superarcList.GetNumberOfValues());
this->Invoke(vtkm::worklet::contourtree_distributed::hierarchical_volumetric_branch_decomposer::
this->Invoke(vtkm::worklet::scalar_topology::hierarchical_volumetric_branch_decomposer::
LocalBestUpDownByVolumeInitSuperarcListWorklet{}, // the worklet
hierarchicalTree->Superarcs, // input
hierarchicalTreeSuperarcs, // input
superarcList // output
);
#ifdef DEBUG_HIERARCHICAL_VOLUMETRIC_BRANCH_DECOMPOSER
{
std::stringstream resultStream;
@ -265,7 +269,7 @@ void HierarchicalVolumetricBranchDecomposer<FieldType>::LocalBestUpDownByVolume(
// and fill it up with index values [0, 1, 2 ... nSuperarcs-1] while simultaneously stream compacting the
// values by keeping only those indices where the hierarchicalTree->Superarcs is not NoSuchElement.
vtkm::cont::Algorithm::CopyIf(vtkm::cont::ArrayHandleIndex(nSuperarcs), //input
hierarchicalTree->Superarcs, // stencil
hierarchicalTreeSuperarcs, // stencil
actualSuperarcs, // output target array
vtkm::worklet::contourtree_augmented::NotNoSuchElementPredicate{});
// NOTE: The behavior here is slightly different from the original implementation, as the original code
@ -307,12 +311,12 @@ void HierarchicalVolumetricBranchDecomposer<FieldType>::LocalBestUpDownByVolume(
// given that we have already suppressed the non-virtual superarcs
// however, in this case, we need to use the actualSuperarcs array instead of the main array
{
vtkm::worklet::contourtree_distributed::hierarchical_volumetric_branch_decomposer::
vtkm::worklet::scalar_topology::hierarchical_volumetric_branch_decomposer::
LocalBestUpDownByVolumeBestUpDownEdgeWorklet bestUpDownEdgeWorklet(totalVolume);
// permut input and output arrays here so we can use FieldIn and FieldOut to
// avoid the use of WholeArray access in the worklet
auto permutedHierarchicalTreeSuperarcs = vtkm::cont::make_ArrayHandlePermutation(
actualSuperarcs, hierarchicalTree->Superarcs); // input
auto permutedHierarchicalTreeSuperarcs =
vtkm::cont::make_ArrayHandlePermutation(actualSuperarcs, hierarchicalTreeSuperarcs); // input
auto permutedDependetValues =
vtkm::cont::make_ArrayHandlePermutation(actualSuperarcs, dependentValues); // input
auto permutedIntrinsicValues =
@ -348,10 +352,10 @@ void HierarchicalVolumetricBranchDecomposer<FieldType>::LocalBestUpDownByVolume(
// NB: We reuse the actual superarcs list here - this works because we have indexed the volumes on the underlying superarc ID
// NB 2: Notice that we only sort the "actual" ones - this is to avoid unnecessary resize() calls in vtkm later on
{
vtkm::worklet::contourtree_distributed::hierarchical_volumetric_branch_decomposer::
vtkm::worklet::scalar_topology::hierarchical_volumetric_branch_decomposer::
SuperArcVolumetricComparatorIndirectGlobalIdComparator
SuperArcVolumetricComparatorIndirectGlobalIdComparator(
this->UpVolume, superarcList, hierarchicalTree->RegularNodeGlobalIds, false);
this->UpVolume, superarcList, hierarchicalTreeRegularNodeGlobalIds, false);
vtkm::cont::Algorithm::Sort(actualSuperarcs,
SuperArcVolumetricComparatorIndirectGlobalIdComparator);
}
@ -373,15 +377,15 @@ void HierarchicalVolumetricBranchDecomposer<FieldType>::LocalBestUpDownByVolume(
{
auto permutedUpVolume =
vtkm::cont::make_ArrayHandlePermutation(actualSuperarcs, this->UpVolume);
this->Invoke(vtkm::worklet::contourtree_distributed::hierarchical_volumetric_branch_decomposer::
this->Invoke(vtkm::worklet::scalar_topology::hierarchical_volumetric_branch_decomposer::
LocalBestUpDownByVolumeWorklet<true>{ nActualSuperarcs },
actualSuperarcs, // input
superarcList, // input
permutedUpVolume, // input
hierarchicalTree->RegularNodeGlobalIds, // input
hierarchicalTree->Supernodes, // input
this->BestDownSupernode, // output
this->BestDownVolume // output
actualSuperarcs, // input
superarcList, // input
permutedUpVolume, // input
hierarchicalTreeRegularNodeGlobalIds, // input
hierarchicalTreeSupernodes, // input
this->BestDownSupernode, // output
this->BestDownVolume // output
);
}
#ifdef DEBUG_HIERARCHICAL_VOLUMETRIC_BRANCH_DECOMPOSER
@ -391,10 +395,10 @@ void HierarchicalVolumetricBranchDecomposer<FieldType>::LocalBestUpDownByVolume(
// II B 3. Repeat for lower vertex
{
vtkm::worklet::contourtree_distributed::hierarchical_volumetric_branch_decomposer::
vtkm::worklet::scalar_topology::hierarchical_volumetric_branch_decomposer::
SuperArcVolumetricComparatorIndirectGlobalIdComparator
SuperArcVolumetricComparatorIndirectGlobalIdComparator(
this->DownVolume, superarcList, hierarchicalTree->RegularNodeGlobalIds, true);
this->DownVolume, superarcList, hierarchicalTreeRegularNodeGlobalIds, true);
vtkm::cont::Algorithm::Sort(actualSuperarcs,
SuperArcVolumetricComparatorIndirectGlobalIdComparator);
}
@ -417,15 +421,15 @@ void HierarchicalVolumetricBranchDecomposer<FieldType>::LocalBestUpDownByVolume(
{
auto permutedDownVolume =
vtkm::cont::make_ArrayHandlePermutation(actualSuperarcs, this->DownVolume);
this->Invoke(vtkm::worklet::contourtree_distributed::hierarchical_volumetric_branch_decomposer::
this->Invoke(vtkm::worklet::scalar_topology::hierarchical_volumetric_branch_decomposer::
LocalBestUpDownByVolumeWorklet<false>{ nActualSuperarcs },
actualSuperarcs, // input
superarcList, // input
permutedDownVolume, // input
hierarchicalTree->RegularNodeGlobalIds, // input
hierarchicalTree->Supernodes, // input
this->BestUpSupernode, // output
this->BestUpVolume // output
actualSuperarcs, // input
superarcList, // input
permutedDownVolume, // input
hierarchicalTreeRegularNodeGlobalIds, // input
hierarchicalTreeSupernodes, // input
this->BestUpSupernode, // output
this->BestUpVolume // output
);
}
@ -435,32 +439,57 @@ void HierarchicalVolumetricBranchDecomposer<FieldType>::LocalBestUpDownByVolume(
#endif
} // LocalBestUpDownByVolume
template <typename FieldType>
void HierarchicalVolumetricBranchDecomposer<FieldType>::CollapseBranches(
const vtkm::worklet::contourtree_distributed::HierarchicalContourTree<FieldType>*
hierarchicalTree,
inline void HierarchicalVolumetricBranchDecomposer::CollapseBranches(
const vtkm::cont::DataSet& hierarchicalTreeDataSet,
vtkm::worklet::contourtree_augmented::IdArrayType& branchRoot)
{ // CollapseBranches
// Get required arrays for hierarchical tree form data set
auto hierarchicalTreeSupernodes = hierarchicalTreeDataSet.GetField("Supernodes")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
auto hierarchicalTreeSuperarcs = hierarchicalTreeDataSet.GetField("Superarcs")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
auto hierarchicalTreeRegularNodeGlobalIds =
hierarchicalTreeDataSet.GetField("RegularNodeGlobalIds")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
auto hierarchicalTreeRegularNodeSortOrder =
hierarchicalTreeDataSet.GetField("RegularNodeSortOrder")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
auto hierarchicalTreeRegular2Supernode = hierarchicalTreeDataSet.GetField("Regular2Supernode")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
auto hierarchicalTreeWhichRound = hierarchicalTreeDataSet.GetField("WhichRound")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
// initialise the superarcs to be their own branch roots
VTKM_LOG_S(vtkm::cont::LogLevel::Info,
"Initializing branch root with " << branchRoot.GetNumberOfValues() << " values.");
vtkm::cont::Algorithm::Copy(vtkm::cont::ArrayHandleIndex(branchRoot.GetNumberOfValues()),
branchRoot);
vtkm::cont::ArrayCopy(vtkm::cont::ArrayHandleIndex(branchRoot.GetNumberOfValues()), branchRoot);
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Convert to superarc ID.");
// For each supernode, convert the best up into a superarc ID
{
vtkm::worklet::contourtree_distributed::hierarchical_volumetric_branch_decomposer::
CollapseBranchesWorklet collapseBranchesWorklet;
auto findRegularByGlobal = hierarchicalTree->GetFindRegularByGlobal();
auto findSuperArcBetweenNodes = hierarchicalTree->GetFindSuperArcBetweenNodes();
this->Invoke(collapseBranchesWorklet, // the worklet
this->BestUpSupernode, // input
this->BestDownSupernode, // input
findRegularByGlobal, // input ExecutionObject
findSuperArcBetweenNodes, // input ExecutionObject
hierarchicalTree->Regular2Supernode, // input
hierarchicalTree->WhichRound, // input
vtkm::worklet::contourtree_distributed::FindRegularByGlobal findRegularByGlobal{
hierarchicalTreeRegularNodeSortOrder, hierarchicalTreeRegularNodeGlobalIds
};
vtkm::worklet::contourtree_distributed::FindSuperArcBetweenNodes findSuperArcBetweenNodes{
hierarchicalTreeSuperarcs
};
using vtkm::worklet::scalar_topology::hierarchical_volumetric_branch_decomposer::
CollapseBranchesWorklet;
this->Invoke(CollapseBranchesWorklet{}, // the worklet
this->BestUpSupernode, // input
this->BestDownSupernode, // input
findRegularByGlobal, // input ExecutionObject
findSuperArcBetweenNodes, // input ExecutionObject
hierarchicalTreeRegular2Supernode, // input
hierarchicalTreeWhichRound, // input
branchRoot);
}
@ -477,112 +506,43 @@ void HierarchicalVolumetricBranchDecomposer<FieldType>::CollapseBranches(
for (vtkm::Id iteration = 0; iteration < nLogSteps; iteration++)
{ // per iteration
// loop through the vertices, updating
vtkm::worklet::contourtree_distributed::hierarchical_volumetric_branch_decomposer::
CollapseBranchesPointerDoublingWorklet collapseBranchesPointerDoublingWorklet;
this->Invoke(collapseBranchesPointerDoublingWorklet, branchRoot);
using vtkm::worklet::scalar_topology::hierarchical_volumetric_branch_decomposer::
CollapseBranchesPointerDoublingWorklet;
this->Invoke(CollapseBranchesPointerDoublingWorklet{}, branchRoot);
} // per iteration
} // CollapseBranches
// routine to print branches
template <typename FieldType>
std::string HierarchicalVolumetricBranchDecomposer<FieldType>::PrintBranches(
const vtkm::worklet::contourtree_distributed::HierarchicalContourTree<FieldType>*
hierarchicalTree,
const vtkm::worklet::contourtree_augmented::IdArrayType& branchRoot)
{ // PrintBranches
// we want to dump out the branches as viewed by this rank.
// most of the processing will be external, so we keep this simple.
// For each end of the superarc, we print out value & global ID prefixed by global ID of the branch root
// The external processing will then sort them to construct segments (as usual) in the array
// then a post-process can find the first and last in each segment & print out the branch
// In order for the sort to work lexicographically, we need to print out in the following order:
// I Branch Root Global ID
// II Supernode Value
// III Supernode Global ID
std::stringstream resultStream;
// loop through the individual superarcs
auto hierarchicalTreeSuperarcsPortal = hierarchicalTree->Superarcs.ReadPortal();
auto hierarchicalTreeSupernodesPortal = hierarchicalTree->Supernodes.ReadPortal();
auto hierarchicalTreeRegularNodeGlobalIdsPortal =
hierarchicalTree->RegularNodeGlobalIds.ReadPortal();
auto hierarchicalTreeDataValuesPortal = hierarchicalTree->DataValues.ReadPortal();
auto branchRootPortal = branchRoot.ReadPortal();
// PrintBranches
// we want to dump out the branches as viewed by this rank.
// most of the processing will be external, so we keep this simple.
// For each end of the superarc, we print out value & global ID prefixed by global ID of the branch root
// The external processing will then sort them to construct segments (as usual) in the array
// then a post-process can find the first and last in each segment & print out the branch
// In order for the sort to work lexicographically, we need to print out in the following order:
// I Branch Root Global ID
// II Supernode Value
// III Supernode Global ID
for (vtkm::Id superarc = 0; superarc < hierarchicalTree->Superarcs.GetNumberOfValues();
superarc++)
{ // per superarc
// explicit test for root superarc / attachment points
if (vtkm::worklet::contourtree_augmented::NoSuchElement(
hierarchicalTreeSuperarcsPortal.Get(superarc)))
{
continue;
}
// now retrieve the branch root's global ID
vtkm::Id branchRootSuperId = branchRootPortal.Get(superarc);
vtkm::Id branchRootRegularId = hierarchicalTreeSupernodesPortal.Get(branchRootSuperId);
vtkm::Id branchRootGlobalId =
hierarchicalTreeRegularNodeGlobalIdsPortal.Get(branchRootRegularId);
// now retrieve the global ID & value for each end & output them
vtkm::Id superFromRegularId = hierarchicalTreeSupernodesPortal.Get(superarc);
vtkm::Id superFromGlobalId = hierarchicalTreeRegularNodeGlobalIdsPortal.Get(superFromRegularId);
FieldType superFromValue = hierarchicalTreeDataValuesPortal.Get(superFromRegularId);
resultStream << branchRootGlobalId << "\t" << superFromValue << "\t" << superFromGlobalId
<< std::endl;
// now retrieve the global ID & value for each end & output them
vtkm::Id superToRegularId = vtkm::worklet::contourtree_augmented::MaskedIndex(
hierarchicalTreeSuperarcsPortal.Get(superarc));
vtkm::Id superToGlobalId = hierarchicalTreeRegularNodeGlobalIdsPortal.Get(superToRegularId);
FieldType superToValue = hierarchicalTreeDataValuesPortal.Get(superToRegularId);
resultStream << branchRootGlobalId << "\t" << superToValue << "\t" << superToGlobalId
<< std::endl;
} // per superarc
return resultStream.str();
} // PrintBranches
// routine to print branches
template <typename FieldType>
std::string HierarchicalVolumetricBranchDecomposer<FieldType>::PrintBranches(
const vtkm::cont::DataSet& ds)
{ // PrintBranches
// we want to dump out the branches as viewed by this rank.
// most of the processing will be external, so we keep this simple.
// For each end of the superarc, we print out value & global ID prefixed by global ID of the branch root
// The external processing will then sort them to construct segments (as usual) in the array
// then a post-process can find the first and last in each segment & print out the branch
// In order for the sort to work lexicographically, we need to print out in the following order:
// I Branch Root Global ID
// II Supernode Value
// III Supernode Global ID
std::stringstream resultStream;
// loop through the individual superarcs
auto hierarchicalTreeSuperarcsAH =
ds.GetField("Superarcs").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
// Note the following is a template to be called via cast-and-call
template <typename IdArrayHandleType, typename DataValueArrayHandleType>
std::string HierarchicalVolumetricBranchDecomposer::PrintBranches(
const IdArrayHandleType& hierarchicalTreeSuperarcsAH,
const IdArrayHandleType& hierarchicalTreeSupernodesAH,
const IdArrayHandleType& hierarchicalTreeRegularNodeGlobalIdsAH,
const DataValueArrayHandleType& hierarchicalTreeDataValuesAH,
const IdArrayHandleType& branchRootAH)
{
auto hierarchicalTreeSuperarcsPortal = hierarchicalTreeSuperarcsAH.ReadPortal();
vtkm::Id nSuperarcs = hierarchicalTreeSuperarcsAH.GetNumberOfValues();
auto hierarchicalTreeSupernodesPortal = ds.GetField("Supernodes")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>()
.ReadPortal();
auto hierarchicalTreeSupernodesPortal = hierarchicalTreeSupernodesAH.ReadPortal();
auto hierarchicalTreeRegularNodeGlobalIdsPortal =
ds.GetField("RegularNodeGlobalIds")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>()
.ReadPortal();
auto hierarchicalTreeDataValuesPortal = ds.GetField("DataValues")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<FieldType>>()
.ReadPortal();
auto branchRootPortal = ds.GetField("BranchRoots")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>()
.ReadPortal();
hierarchicalTreeRegularNodeGlobalIdsAH.ReadPortal();
auto hierarchicalTreeDataValuesPortal = hierarchicalTreeDataValuesAH.ReadPortal();
auto branchRootPortal = branchRootAH.ReadPortal();
std::stringstream resultStream;
// loop through the individual superarcs
for (vtkm::Id superarc = 0; superarc < nSuperarcs; superarc++)
{ // per superarc
@ -602,7 +562,7 @@ std::string HierarchicalVolumetricBranchDecomposer<FieldType>::PrintBranches(
// now retrieve the global ID & value for each end & output them
vtkm::Id superFromRegularId = hierarchicalTreeSupernodesPortal.Get(superarc);
vtkm::Id superFromGlobalId = hierarchicalTreeRegularNodeGlobalIdsPortal.Get(superFromRegularId);
FieldType superFromValue = hierarchicalTreeDataValuesPortal.Get(superFromRegularId);
vtkm::Float64 superFromValue = hierarchicalTreeDataValuesPortal.Get(superFromRegularId);
resultStream << branchRootGlobalId << "\t" << superFromValue << "\t" << superFromGlobalId
<< std::endl;
@ -610,18 +570,51 @@ std::string HierarchicalVolumetricBranchDecomposer<FieldType>::PrintBranches(
vtkm::Id superToRegularId = vtkm::worklet::contourtree_augmented::MaskedIndex(
hierarchicalTreeSuperarcsPortal.Get(superarc));
vtkm::Id superToGlobalId = hierarchicalTreeRegularNodeGlobalIdsPortal.Get(superToRegularId);
FieldType superToValue = hierarchicalTreeDataValuesPortal.Get(superToRegularId);
vtkm::Float64 superToValue = hierarchicalTreeDataValuesPortal.Get(superToRegularId);
resultStream << branchRootGlobalId << "\t" << superToValue << "\t" << superToGlobalId
<< std::endl;
} // per superarc
return resultStream.str();
} // PrintBranches
inline std::string HierarchicalVolumetricBranchDecomposer::PrintBranches(
const vtkm::cont::DataSet& ds)
{
auto hierarchicalTreeSuperarcsAH =
ds.GetField("Superarcs").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
auto hierarchicalTreeSupernodesAH =
ds.GetField("Supernodes").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
auto hierarchicalTreeRegularNodeGlobalIdsAH =
ds.GetField("RegularNodeGlobalIds")
.GetData()
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
auto hierarchicalTreeDataValuesData = ds.GetField("DataValues").GetData();
auto branchRootAH =
ds.GetField("BranchRoots").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
std::string result;
hierarchicalTreeDataValuesData.CastAndCallForTypes<TypeListScalarAll, VTKM_DEFAULT_STORAGE_LIST>(
[&](const auto& hierarchicalTreeDataValuesAH) {
result = PrintBranches(hierarchicalTreeSuperarcsAH,
hierarchicalTreeSupernodesAH,
hierarchicalTreeRegularNodeGlobalIdsAH,
hierarchicalTreeDataValuesAH,
branchRootAH);
});
return result;
} // PrintBranches
// debug routine
template <typename FieldType>
std::string HierarchicalVolumetricBranchDecomposer<FieldType>::DebugPrint(std::string message,
const char* fileName,
long lineNum)
inline std::string HierarchicalVolumetricBranchDecomposer::DebugPrint(std::string message,
const char* fileName,
long lineNum)
{ // DebugPrint()
std::stringstream resultStream;
resultStream << "----------------------------------------" << std::endl;
@ -650,7 +643,7 @@ std::string HierarchicalVolumetricBranchDecomposer<FieldType>::DebugPrint(std::s
return resultStream.str();
} // DebugPrint()
} // namespace contourtree_distributed
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm

0
vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/CMakeLists.txt → vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/CMakeLists.txt
View File

4
vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/CollapseBranchesPointerDoublingWorklet.h → vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/CollapseBranchesPointerDoublingWorklet.h
View File

@ -53,7 +53,7 @@ namespace vtkm
{
namespace worklet
{
namespace contourtree_distributed
namespace scalar_topology
{
namespace hierarchical_volumetric_branch_decomposer
{
@ -86,7 +86,7 @@ public:
}; // CollapseBranchesPointerDoublingWorklet
} // namespace hierarchical_augmenter
} // namespace hierarchical_volumetric_branch_decomposer
} // namespace contourtree_distributed
} // namespace worklet
} // namespace vtkm

10
vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/CollapseBranchesWorklet.h → vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/CollapseBranchesWorklet.h
View File

@ -43,8 +43,8 @@
// Oliver Ruebel (LBNL)
//==============================================================================
#ifndef vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_collapse_branches_worklet_h
#define vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_collapse_branches_worklet_h
#ifndef vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_collapse_branches_worklet_h
#define vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_collapse_branches_worklet_h
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
@ -53,7 +53,7 @@ namespace vtkm
{
namespace worklet
{
namespace contourtree_distributed
namespace scalar_topology
{
namespace hierarchical_volumetric_branch_decomposer
{
@ -236,8 +236,8 @@ public:
}; // CollapseBranchesWorklet
} // namespace hierarchical_augmenter
} // namespace contourtree_distributed
} // namespace hierarchical_volumetric_branch_decomposer
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm

10
vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/FindBestSupernodeWorklet.h → vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/FindBestSupernodeWorklet.h
View File

@ -43,8 +43,8 @@
// Oliver Ruebel (LBNL)
//==============================================================================
#ifndef vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_combine_branch_decomposers_worklet_h
#define vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_combine_branch_decomposers_worklet_h
#ifndef vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_combine_branch_decomposers_worklet_h
#define vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_combine_branch_decomposers_worklet_h
#include <vtkm/worklet/WorkletMapField.h>
@ -52,7 +52,7 @@ namespace vtkm
{
namespace worklet
{
namespace contourtree_distributed
namespace scalar_topology
{
namespace hierarchical_volumetric_branch_decomposer
{
@ -89,8 +89,8 @@ public:
} // operator()()
}; // FindBestSupernodeWorklet
} // namespace hierarchical_augmenter
} // namespace contourtree_distributed
} // namespace hierarchical_volumetric_branch_decomposer
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm

10
vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeBestUpDownEdgeWorklet.h → vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeBestUpDownEdgeWorklet.h
View File

@ -43,8 +43,8 @@
// Oliver Ruebel (LBNL)
//==============================================================================
#ifndef vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_localbestupdownbyvolume_best_up_down_edge_worklet_h
#define vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_localbestupdownbyvolume_best_up_down_edge_worklet_h
#ifndef vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_localbestupdownbyvolume_best_up_down_edge_worklet_h
#define vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_localbestupdownbyvolume_best_up_down_edge_worklet_h
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
@ -53,7 +53,7 @@ namespace vtkm
{
namespace worklet
{
namespace contourtree_distributed
namespace scalar_topology
{
namespace hierarchical_volumetric_branch_decomposer
{
@ -146,8 +146,8 @@ private:
}; // LocalBestUpDownByVolumeBestUpDownEdgeWorklet
} // namespace hierarchical_augmenter
} // namespace contourtree_distributed
} // namespace hierarchical_volumetric_branch_decomposer
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm

10
vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeInitSuperarcListWorklet.h → vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeInitSuperarcListWorklet.h
View File

@ -43,8 +43,8 @@
// Oliver Ruebel (LBNL)
//==============================================================================
#ifndef vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_localbestupdownbyvolume_init_superarc_list_worklet_h
#define vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_localbestupdownbyvolume_init_superarc_list_worklet_h
#ifndef vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_localbestupdownbyvolume_init_superarc_list_worklet_h
#define vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_localbestupdownbyvolume_init_superarc_list_worklet_h
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
@ -53,7 +53,7 @@ namespace vtkm
{
namespace worklet
{
namespace contourtree_distributed
namespace scalar_topology
{
namespace hierarchical_volumetric_branch_decomposer
{
@ -96,8 +96,8 @@ public:
}; // LocalBestUpDownByVolumeInitSuperarcListWorklet
} // namespace hierarchical_augmenter
} // namespace contourtree_distributed
} // namespace hierarchical_volumetric_branch_decomposer
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm

10
vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeWorklet.h → vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeWorklet.h
View File

@ -43,8 +43,8 @@
// Oliver Ruebel (LBNL)
//==============================================================================
#ifndef vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_local_best_updown_by_volume_worklet_h
#define vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_local_best_updown_by_volume_worklet_h
#ifndef vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_local_best_updown_by_volume_worklet_h
#define vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_local_best_updown_by_volume_worklet_h
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
@ -53,7 +53,7 @@ namespace vtkm
{
namespace worklet
{
namespace contourtree_distributed
namespace scalar_topology
{
namespace hierarchical_volumetric_branch_decomposer
{
@ -221,8 +221,8 @@ private:
}; // LocalBestUpDownByVolumeWorklet
} // namespace hierarchical_augmenter
} // namespace contourtree_distributed
} // namespace hierarchical_volumetric_branch_decomposer
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm

8
vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/SuperArcVolumetricComparatorIndirectGlobalIdComparator.h → vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/SuperArcVolumetricComparatorIndirectGlobalIdComparator.h
View File

@ -60,8 +60,8 @@
//=======================================================================================
#ifndef vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_superarc_volumetric_comparator_indirect_globalid_comparator_h
#define vtk_m_worklet_contourtree_distributed_hierarchical_volumetric_branch_decomposer_superarc_volumetric_comparator_indirect_globalid_comparator_h
#ifndef vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_superarc_volumetric_comparator_indirect_globalid_comparator_h
#define vtk_m_worklet_scalar_topology_hierarchical_volumetric_branch_decomposer_superarc_volumetric_comparator_indirect_globalid_comparator_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ExecutionObjectBase.h>
@ -71,7 +71,7 @@ namespace vtkm
{
namespace worklet
{
namespace contourtree_distributed
namespace scalar_topology
{
namespace hierarchical_volumetric_branch_decomposer
{
@ -240,7 +240,7 @@ private:
}; // SuperArcVolumetricComparatorIndirectGlobalIdComparator
} // namespace hierarchical_volumetric_branch_decomposer
} // namespace contourtree_distributed
} // namespace scalar_topology
} // namespace worklet
} // namespace vtkm

1
vtkm/filter/testing/TestingContourTreeUniformDistributedFilter.h
View File

@ -293,7 +293,6 @@ inline vtkm::cont::PartitionedDataSet RunContourTreeDUniformDistributed(
!useMarchingCubes,
useMarchingCubes,
false, // no augmentationa
false, // no branch decmompostion
false, // no save dot
vtkm::cont::LogLevel::UserVerboseLast,
vtkm::cont::LogLevel::UserVerboseLast);

1
vtkm/worklet/contourtree_augmented/NotNoSuchElementPredicate.h
View File

@ -53,6 +53,7 @@
#ifndef vtk_m_worklet_contourtree_augmented_not_no_such_element_predicate_h
#define vtk_m_worklet_contourtree_augmented_not_no_such_element_predicate_h
#include <vtkm/Types.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm

4
vtkm/worklet/contourtree_distributed/BoundaryTree.h
View File

@ -125,7 +125,7 @@ public:
// prints the contents of the BRACT for comparison with sweep and merge
std::string BoundaryTree::Print()
inline std::string BoundaryTree::Print()
{ // Print
// Use string steam to record text so the user can print it however they like
std::stringstream resultStream;
@ -270,7 +270,7 @@ std::string BoundaryTree::PrintGlobalDot(
} //PrintGlobalDot
// debug routine
void BoundaryTree::PrintContent(std::ostream& outStream) const
inline void BoundaryTree::PrintContent(std::ostream& outStream) const
{
vtkm::worklet::contourtree_augmented::PrintHeader(this->VertexIndex.GetNumberOfValues(),
outStream);

4
vtkm/worklet/contourtree_distributed/CMakeLists.txt
View File

@ -11,15 +11,12 @@
set(headers
BoundaryTree.h
BoundaryTreeMaker.h
BranchDecompositionBlock.h
CombineHyperSweepBlockFunctor.h
ComputeDistributedBranchDecompositionFunctor.h
ComputeDistributedContourTreeFunctor.h
ContourTreeBlockData.h
DistributedContourTreeBlockData.h
HierarchicalAugmenter.h
HierarchicalAugmenterFunctor.h
HierarchicalVolumetricBranchDecomposer.h
HierarchicalContourTree.h
HierarchicalHyperSweeper.h
HyperSweepBlock.h
@ -39,4 +36,3 @@ add_subdirectory(tree_grafter)
add_subdirectory(hierarchical_contour_tree)
add_subdirectory(hierarchical_hyper_sweeper)
add_subdirectory(hierarchical_augmenter)
add_subdirectory(hierarchical_volumetric_branch_decomposer)

238
vtkm/worklet/contourtree_distributed/ComputeDistributedBranchDecompositionFunctor.h
View File

@ -1,238 +0,0 @@
//============================================================================
// 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__h
#define vtk_m_worklet_contourtree_distributed__h
#include <vtkm/Types.h>
#include <vtkm/worklet/contourtree_distributed/BranchDecompositionBlock.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_volumetric_branch_decomposer/FindBestSupernodeWorklet.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include <vtkm/thirdparty/diy/diy.h>
VTKM_THIRDPARTY_POST_INCLUDE
// clang-format on
#ifdef DEBUG_PRINT
#define DEBUG_PRINT_COMBINED_BLOCK_IDS
#endif
namespace vtkm
{
namespace worklet
{
namespace contourtree_distributed
{
template <typename ContourTreeDataFieldType>
struct ComputeDistributedBranchDecompositionFunctor
{
void operator()(
vtkm::worklet::contourtree_distributed::BranchDecompositionBlock<ContourTreeDataFieldType>* b,
const vtkmdiy::ReduceProxy& rp, // communication proxy
const vtkmdiy::RegularSwapPartners& // partners of the current block (unused)
) const
{
// Get our rank and DIY id
//const vtkm::Id rank = vtkm::cont::EnvironmentTracker::GetCommunicator().rank();
const auto selfid = rp.gid();
// Aliases to reduce verbosity
auto& branchDecomposer = b->HierarchicalVolumetricBranchDecomposer;
std::vector<int> incoming;
rp.incoming(incoming);
for (const int ingid : incoming)
{
// NOTE/IMPORTANT: In each round we should have only one swap partner (despite for-loop here).
// If that assumption does not hold, it will break things.
// NOTE/IMPORTANT: This assumption only holds if the number of blocks is a power of two.
// Otherwise, we may need to process more than one incoming block
if (ingid != selfid)
{
#ifdef DEBUG_PRINT_COMBINED_BLOCK_IDS
int incomingGlobalBlockId;
rp.dequeue(ingid, incomingGlobalBlockId);
VTKM_LOG_S(vtkm::cont::LogLevel::Info,
"Combining local block " << b->GlobalBlockId << " with incomoing block "
<< incomingGlobalBlockId);
#endif
// Receive data from swap partner
vtkm::cont::ArrayHandle<vtkm::Id> incomingBestUpVolume;
rp.dequeue(ingid, incomingBestUpVolume);
vtkm::cont::ArrayHandle<vtkm::Id> incomingBestUpSupernode;
rp.dequeue(ingid, incomingBestUpSupernode);
vtkm::cont::ArrayHandle<vtkm::Id> incomingBestDownVolume;
rp.dequeue(ingid, incomingBestDownVolume);
vtkm::cont::ArrayHandle<vtkm::Id> incomingBestDownSupernode;
rp.dequeue(ingid, incomingBestDownSupernode);
vtkm::Id prefixLength = vtkm::cont::ArrayGetValue(
0, b->HierarchicalContourTree.FirstSupernodePerIteration[rp.round() - 1]);
#ifdef DEBUG_PRINT
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Prefix length is " << prefixLength);
{
std::stringstream rs;
vtkm::worklet::contourtree_augmented::PrintHeader(
incomingBestUpSupernode.GetNumberOfValues(), rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"incomingBestUpSupernode", incomingBestUpSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"incomingBestDownSupernode", incomingBestDownSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"incomingBestUpVolume", incomingBestUpVolume, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"incomingBestDownVolume", incomingBestDownVolume, -1, rs);
VTKM_LOG_S(vtkm::cont::LogLevel::Info, rs.str());
}
#endif
// NOTE: We are processing input data from the previous round, hence, get
// first supernide per ieteration from previous round
// Create 'views' to restrict worklet to relevant portion of arrays
auto bestUpVolumeView =
make_ArrayHandleView(branchDecomposer.BestUpVolume, 0, prefixLength);
auto bestUpSupernodeView =
make_ArrayHandleView(branchDecomposer.BestUpSupernode, 0, prefixLength);
auto bestDownVolumeView =
make_ArrayHandleView(branchDecomposer.BestDownVolume, 0, prefixLength);
auto bestDownSupernodeView =
make_ArrayHandleView(branchDecomposer.BestDownSupernode, 0, prefixLength);
// Check if swap partner knows a better up /down and update
vtkm::cont::Invoker invoke;
invoke(vtkm::worklet::contourtree_distributed::hierarchical_volumetric_branch_decomposer::
FindBestSupernodeWorklet<true>{},
incomingBestUpVolume,
incomingBestUpSupernode,
bestUpVolumeView,
bestUpSupernodeView);
invoke(vtkm::worklet::contourtree_distributed::hierarchical_volumetric_branch_decomposer::
FindBestSupernodeWorklet<false>{},
incomingBestDownVolume,
incomingBestDownSupernode,
bestDownVolumeView,
bestDownSupernodeView);
#ifdef DEBUG_PRINT
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "After round " << rp.round() - 1);
{
std::stringstream rs;
vtkm::worklet::contourtree_augmented::PrintHeader(
branchDecomposer.BestUpSupernode.GetNumberOfValues(), rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestUpSupernode", branchDecomposer.BestUpSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestDownSupernode", branchDecomposer.BestDownSupernode, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestUpVolume", branchDecomposer.BestUpVolume, -1, rs);
vtkm::worklet::contourtree_augmented::PrintIndices(
"BestDownVolume", branchDecomposer.BestDownVolume, -1, rs);
VTKM_LOG_S(vtkm::cont::LogLevel::Info, rs.str());
}
#endif
}
}
for (int cc = 0; cc < rp.out_link().size(); ++cc)
{
auto target = rp.out_link().target(cc);
if (target.gid != selfid)
{
#ifdef DEBUG_PRINT_COMBINED_BLOCK_IDS
rp.enqueue(target, b->GlobalBlockId);
#endif
// Determine which portion of up/down volume/supernode to send
vtkm::Id prefixLength = vtkm::cont::ArrayGetValue(
0, b->HierarchicalContourTree.FirstSupernodePerIteration[rp.round()]);
// Create 'views' to restrict sending to relevant portion of arrays
auto bestUpVolumeView =
make_ArrayHandleView(branchDecomposer.BestUpVolume, 0, prefixLength);
auto bestUpSupernodeView =
make_ArrayHandleView(branchDecomposer.BestUpSupernode, 0, prefixLength);
auto bestDownVolumeView =
make_ArrayHandleView(branchDecomposer.BestDownVolume, 0, prefixLength);
auto bestDownSupernodeView =
make_ArrayHandleView(branchDecomposer.BestDownSupernode, 0, prefixLength);
// TODO/FIXME: Check if it is possible to send a portion of the arrays
// without copy. enqueue does not accept ArrayHandleView as input as it
// is not trivially copyable
vtkm::cont::ArrayHandle<vtkm::Id> sendBestUpVolume;
vtkm::cont::Algorithm::Copy(bestUpVolumeView, sendBestUpVolume);
vtkm::cont::ArrayHandle<vtkm::Id> sendBestUpSupernode;
vtkm::cont::Algorithm::Copy(bestUpSupernodeView, sendBestUpSupernode);
vtkm::cont::ArrayHandle<vtkm::Id> sendBestDownVolume;
vtkm::cont::Algorithm::Copy(bestDownVolumeView, sendBestDownVolume);
vtkm::cont::ArrayHandle<vtkm::Id> sendBestDownSupernode;
vtkm::cont::Algorithm::Copy(bestDownSupernodeView, sendBestDownSupernode);
rp.enqueue(target, sendBestUpVolume);
rp.enqueue(target, sendBestUpSupernode);
rp.enqueue(target, sendBestDownVolume);
rp.enqueue(target, sendBestDownSupernode);
}
}
}
};
} // namespace contourtree_distributed
} // namespace worklet
} // namespace vtkm
#endif

120
vtkm/worklet/contourtree_distributed/HierarchicalContourTree.h
View File

@ -71,6 +71,8 @@
#define VOLUME_PRINT_WIDTH 8
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayCopy.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
@ -162,6 +164,8 @@ public:
vtkm::worklet::contourtree_augmented::IdArrayType NumIterations;
/// vectors tracking the segments used in each iteration of the hypersweep
// TODO/FIXME: Consider using ArrayHandleGroupVecVariable instead of an STL vector
// of ArrayHandles. (Though that may be a bit tricky with dynamic resizing.)
std::vector<vtkm::worklet::contourtree_augmented::IdArrayType> FirstSupernodePerIteration;
std::vector<vtkm::worklet::contourtree_augmented::IdArrayType> FirstHypernodePerIteration;
@ -242,6 +246,20 @@ public:
const vtkm::worklet::contourtree_augmented::IdArrayType& intrinsicVolume,
const vtkm::worklet::contourtree_augmented::IdArrayType& dependentVolume);
// Helper function to convert an STL vector of VTK-m arrays into components and
// group arrays (for packing into a vtkm::cont::DataSet and using with an
// ArrayHandleGroupVecVariable for access)
// TODO/FIXME: Ultimately, we should get rid of the STL arrays and use an
// ArrayHandleGroupVecVariable in this class.
VTKM_CONT
static void ConvertSTLVecOfHandlesToVTKMComponentsAndOffsetsArray(
const std::vector<vtkm::worklet::contourtree_augmented::IdArrayType>& inputVec,
vtkm::worklet::contourtree_augmented::IdArrayType& outputComponents,
vtkm::cont::ArrayHandle<vtkm::Id>& outputOffsets);
VTKM_CONT
void AddToVTKMDataSet(vtkm::cont::DataSet& ds) const;
private:
/// Used internally to Invoke worklets
vtkm::cont::Invoker Invoke;
@ -946,9 +964,111 @@ std::string HierarchicalContourTree<FieldType>::DumpVolumes(
return outStream.str();
} // DumpVolumes()
template <typename FieldType>
void HierarchicalContourTree<FieldType>::ConvertSTLVecOfHandlesToVTKMComponentsAndOffsetsArray(
const std::vector<vtkm::worklet::contourtree_augmented::IdArrayType>& inputVec,
vtkm::worklet::contourtree_augmented::IdArrayType& outputComponents,
vtkm::cont::ArrayHandle<vtkm::Id>& outputOffsets)
{
// Compute num components vector
vtkm::cont::ArrayHandle<vtkm::IdComponent> numComponents;
numComponents.Allocate(inputVec.size());
auto numComponentsWritePortal = numComponents.WritePortal();
for (vtkm::Id i = 0; i < static_cast<vtkm::Id>(inputVec.size()); ++i)
{
numComponentsWritePortal.Set(i, inputVec[i].GetNumberOfValues());
}
VTKM_LOG_S(vtkm::cont::LogLevel::Info,
"ConvertSTLVecOfHandlesToVTKMComponentsAndOffsetsArray: Converting to offsets");
// Convert to offsets and store in output array
vtkm::Id componentsArraySize;
vtkm::cont::ConvertNumComponentsToOffsets(numComponents, outputOffsets, componentsArraySize);
// Copy data to components array
VTKM_LOG_S(vtkm::cont::LogLevel::Info,
"ConvertSTLVecOfHandlesToVTKMComponentsAndOffsetsArray: Copying");
auto outputOffsetsReadPortal = outputOffsets.ReadPortal();
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Allocating to " << componentsArraySize);
outputComponents.Allocate(componentsArraySize);
auto numComponentsReadPortal = numComponents.ReadPortal();
for (vtkm::Id i = 0; i < static_cast<vtkm::Id>(inputVec.size()); ++i)
{
VTKM_LOG_S(vtkm::cont::LogLevel::Info,
"Creating view from " << outputOffsetsReadPortal.Get(i) << " size "
<< numComponentsReadPortal.Get(i));
auto outputView = vtkm::cont::make_ArrayHandleView(
outputComponents, outputOffsetsReadPortal.Get(i), numComponentsReadPortal.Get(i));
vtkm::cont::ArrayCopy(inputVec[i], outputView);
}
VTKM_LOG_S(vtkm::cont::LogLevel::Info,
"ConvertSTLVecOfHandlesToVTKMComponentsAndOffsetsArray: Exit");
}
template <typename FieldType>
void HierarchicalContourTree<FieldType>::AddToVTKMDataSet(vtkm::cont::DataSet& ds) const
{
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "AddToVTKMDataSet");
// Create data set from output
vtkm::cont::Field regularNodeGlobalIdsField(
"RegularNodeGlobalIds", vtkm::cont::Field::Association::WholeMesh, this->RegularNodeGlobalIds);
ds.AddField(regularNodeGlobalIdsField);
vtkm::cont::Field dataValuesField(
"DataValues", vtkm::cont::Field::Association::WholeMesh, this->DataValues);
ds.AddField(dataValuesField);
vtkm::cont::Field regularNodeSortOrderField(
"RegularNodeSortOrder", vtkm::cont::Field::Association::WholeMesh, this->RegularNodeSortOrder);
ds.AddField(regularNodeSortOrderField);
vtkm::cont::Field regular2SupernodeField(
"Regular2Supernode", vtkm::cont::Field::Association::WholeMesh, this->Regular2Supernode);
ds.AddField(regular2SupernodeField);
vtkm::cont::Field superparentsField(
"Superparents", vtkm::cont::Field::Association::WholeMesh, this->Superparents);
ds.AddField(superparentsField);
vtkm::cont::Field supernodesField(
"Supernodes", vtkm::cont::Field::Association::WholeMesh, this->Supernodes);
ds.AddField(supernodesField);
vtkm::cont::Field superarcsField(
"Superarcs", vtkm::cont::Field::Association::WholeMesh, this->Superarcs);
ds.AddField(superarcsField);
vtkm::cont::Field hyperparentsField(
"Hyperparents", vtkm::cont::Field::Association::WholeMesh, this->Hyperparents);
ds.AddField(hyperparentsField);
vtkm::cont::Field super2HypernodeField(
"Super2Hypernode", vtkm::cont::Field::Association::WholeMesh, this->Super2Hypernode);
ds.AddField(super2HypernodeField);
vtkm::cont::Field whichRoundField(
"WhichRound", vtkm::cont::Field::Association::WholeMesh, this->WhichRound);
ds.AddField(whichRoundField);
vtkm::cont::Field whichIterationField(
"WhichIteration", vtkm::cont::Field::Association::WholeMesh, this->WhichIteration);
ds.AddField(whichIterationField);
// TODO/FIXME: See what other fields we need to add
VTKM_LOG_S(vtkm::cont::LogLevel::Info,
"Calling ConvertSTLVecOfHandlesToVTKMComponentsAndOffsetsArray");
vtkm::worklet::contourtree_augmented::IdArrayType firstSupernodePerIterationComponents;
vtkm::cont::ArrayHandle<vtkm::Id> firstSupernodePerIterationOffsets;
ConvertSTLVecOfHandlesToVTKMComponentsAndOffsetsArray(FirstSupernodePerIteration,
firstSupernodePerIterationComponents,
firstSupernodePerIterationOffsets);
vtkm::cont::Field firstSupernodePerIterationComponentsField(
"FirstSupernodePerIterationComponents",
vtkm::cont::Field::Association::WholeMesh,
firstSupernodePerIterationComponents);
ds.AddField(firstSupernodePerIterationComponentsField);
vtkm::cont::Field firstSupernodePerIterationOffsetsField(
"FirstSupernodePerIterationOffsets",
vtkm::cont::Field::Association::WholeMesh,
firstSupernodePerIterationOffsets);
ds.AddField(firstSupernodePerIterationOffsetsField);
// TODO/FIXME: It seems we may only need the counts for the first iteration, so check, which
// information we actually need.
}
} // namespace contourtree_distributed
} // namespace worklet
} // namespace vtkm
#endif