2017-07-20 19:11:12 +00:00
|
|
|
//============================================================================
|
|
|
|
// 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.
|
|
|
|
//
|
2017-09-20 21:33:44 +00:00
|
|
|
// Copyright 2015 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
|
2017-07-20 19:11:12 +00:00
|
|
|
// Copyright 2015 UT-Battelle, LLC.
|
|
|
|
// Copyright 2015 Los Alamos National Security.
|
|
|
|
//
|
2017-09-20 21:33:44 +00:00
|
|
|
// Under the terms of Contract DE-NA0003525 with NTESS,
|
2017-07-20 19:11:12 +00:00
|
|
|
// the U.S. Government retains certain rights in this software.
|
|
|
|
//
|
|
|
|
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
|
|
|
|
// Laboratory (LANL), the U.S. Government retains certain rights in
|
|
|
|
// this software.
|
|
|
|
//============================================================================
|
2017-08-01 22:01:02 +00:00
|
|
|
|
2017-07-20 19:11:12 +00:00
|
|
|
#include <vtkm/StaticAssert.h>
|
2017-12-14 01:31:36 +00:00
|
|
|
#include <vtkm/cont/ArrayCopy.h>
|
2017-07-20 19:11:12 +00:00
|
|
|
#include <vtkm/cont/ArrayHandle.h>
|
2017-12-21 01:18:22 +00:00
|
|
|
#include <vtkm/cont/AssignerMultiBlock.h>
|
2017-07-20 19:11:12 +00:00
|
|
|
#include <vtkm/cont/DataSet.h>
|
2017-12-21 01:18:22 +00:00
|
|
|
#include <vtkm/cont/DecomposerMultiBlock.h>
|
2017-07-20 19:11:12 +00:00
|
|
|
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
|
2017-08-18 20:28:33 +00:00
|
|
|
#include <vtkm/cont/DynamicArrayHandle.h>
|
2017-12-14 01:31:36 +00:00
|
|
|
#include <vtkm/cont/EnvironmentTracker.h>
|
2017-08-18 20:28:33 +00:00
|
|
|
#include <vtkm/cont/ErrorExecution.h>
|
|
|
|
#include <vtkm/cont/Field.h>
|
2017-07-20 19:11:12 +00:00
|
|
|
#include <vtkm/cont/MultiBlock.h>
|
2017-12-14 01:31:36 +00:00
|
|
|
|
|
|
|
#if defined(VTKM_ENABLE_MPI)
|
2018-01-03 19:37:54 +00:00
|
|
|
// clang-format off
|
|
|
|
#include <vtkm/thirdparty/diy/Configure.h>
|
|
|
|
#include VTKM_DIY(diy/decomposition.hpp)
|
|
|
|
#include VTKM_DIY(diy/master.hpp)
|
|
|
|
#include VTKM_DIY(diy/partners/all-reduce.hpp)
|
|
|
|
#include VTKM_DIY(diy/partners/swap.hpp)
|
|
|
|
#include VTKM_DIY(diy/reduce.hpp)
|
|
|
|
// clang-format on
|
2017-12-14 01:31:36 +00:00
|
|
|
|
|
|
|
namespace vtkm
|
|
|
|
{
|
|
|
|
namespace cont
|
|
|
|
{
|
|
|
|
namespace detail
|
|
|
|
{
|
|
|
|
template <typename PortalType>
|
|
|
|
VTKM_CONT std::vector<typename PortalType::ValueType> CopyArrayPortalToVector(
|
|
|
|
const PortalType& portal)
|
|
|
|
{
|
|
|
|
using ValueType = typename PortalType::ValueType;
|
|
|
|
std::vector<ValueType> result(portal.GetNumberOfValues());
|
|
|
|
vtkm::cont::ArrayPortalToIterators<PortalType> iterators(portal);
|
|
|
|
std::copy(iterators.GetBegin(), iterators.GetEnd(), result.begin());
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2017-12-21 01:18:22 +00:00
|
|
|
template <typename T>
|
|
|
|
const vtkm::cont::DataSet& GetBlock(const vtkm::cont::MultiBlock& mb, const T&);
|
2017-12-14 01:31:36 +00:00
|
|
|
|
|
|
|
template <>
|
2017-12-21 01:18:22 +00:00
|
|
|
const vtkm::cont::DataSet& GetBlock(const vtkm::cont::MultiBlock& mb,
|
|
|
|
const diy::Master::ProxyWithLink& cp)
|
2017-12-14 01:31:36 +00:00
|
|
|
{
|
2017-12-21 01:18:22 +00:00
|
|
|
const int lid = cp.master()->lid(cp.gid());
|
|
|
|
return mb.GetBlock(lid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-12-14 01:31:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2017-08-18 20:28:33 +00:00
|
|
|
namespace vtkm
|
|
|
|
{
|
|
|
|
namespace cont
|
|
|
|
{
|
2017-08-02 03:15:41 +00:00
|
|
|
|
|
|
|
VTKM_CONT
|
2017-08-18 20:28:33 +00:00
|
|
|
MultiBlock::MultiBlock(const vtkm::cont::DataSet& ds)
|
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
this->Blocks.insert(this->Blocks.end(), ds);
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
2017-08-02 20:17:31 +00:00
|
|
|
VTKM_CONT
|
2017-08-18 20:28:33 +00:00
|
|
|
MultiBlock::MultiBlock(const vtkm::cont::MultiBlock& src)
|
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
this->Blocks = src.GetBlocks();
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
2017-08-02 03:15:41 +00:00
|
|
|
VTKM_CONT
|
2017-08-18 20:28:33 +00:00
|
|
|
MultiBlock::MultiBlock(const std::vector<vtkm::cont::DataSet>& mblocks)
|
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
this->Blocks = mblocks;
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
MultiBlock::MultiBlock(vtkm::Id size)
|
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
this->Blocks.reserve(static_cast<std::size_t>(size));
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
2017-08-02 19:18:55 +00:00
|
|
|
VTKM_CONT
|
2017-08-02 20:17:31 +00:00
|
|
|
MultiBlock::MultiBlock()
|
2017-08-18 20:28:33 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-08-02 03:15:41 +00:00
|
|
|
VTKM_CONT
|
2017-08-18 20:28:33 +00:00
|
|
|
MultiBlock::~MultiBlock()
|
|
|
|
{
|
|
|
|
}
|
2017-08-02 03:15:41 +00:00
|
|
|
|
2017-08-02 02:16:00 +00:00
|
|
|
VTKM_CONT
|
2017-08-18 20:28:33 +00:00
|
|
|
MultiBlock& MultiBlock::operator=(const vtkm::cont::MultiBlock& src)
|
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
this->Blocks = src.GetBlocks();
|
2017-08-18 20:28:33 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2017-08-02 02:16:00 +00:00
|
|
|
VTKM_CONT
|
2017-08-18 20:28:33 +00:00
|
|
|
vtkm::cont::Field MultiBlock::GetField(const std::string& field_name, const int& block_index)
|
|
|
|
{
|
|
|
|
assert(block_index >= 0);
|
2017-12-06 01:06:19 +00:00
|
|
|
assert(static_cast<std::size_t>(block_index) < this->Blocks.size());
|
|
|
|
return this->Blocks[static_cast<std::size_t>(block_index)].GetField(field_name);
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
2017-08-02 02:16:00 +00:00
|
|
|
VTKM_CONT
|
2017-07-20 19:11:12 +00:00
|
|
|
vtkm::Id MultiBlock::GetNumberOfBlocks() const
|
2017-08-18 20:28:33 +00:00
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
return static_cast<vtkm::Id>(this->Blocks.size());
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
2017-12-14 01:31:36 +00:00
|
|
|
VTKM_CONT
|
|
|
|
vtkm::Id MultiBlock::GetGlobalNumberOfBlocks() const
|
|
|
|
{
|
|
|
|
#if defined(VTKM_ENABLE_MPI)
|
|
|
|
auto world = vtkm::cont::EnvironmentTracker::GetCommunicator();
|
|
|
|
const auto local_count = this->GetNumberOfBlocks();
|
|
|
|
|
|
|
|
diy::Master master(world, 1, -1);
|
|
|
|
int block_not_used = 1;
|
|
|
|
master.add(world.rank(), &block_not_used, new diy::Link());
|
|
|
|
// empty link since we're only using collectives.
|
|
|
|
master.foreach ([=](void*, const diy::Master::ProxyWithLink& cp) {
|
|
|
|
cp.all_reduce(local_count, std::plus<vtkm::Id>());
|
|
|
|
});
|
|
|
|
master.process_collectives();
|
|
|
|
vtkm::Id global_count = master.proxy(0).get<vtkm::Id>();
|
|
|
|
return global_count;
|
|
|
|
#else
|
|
|
|
return this->GetNumberOfBlocks();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2017-08-20 18:00:11 +00:00
|
|
|
VTKM_CONT
|
|
|
|
const vtkm::cont::DataSet& MultiBlock::GetBlock(vtkm::Id blockId) const
|
2017-08-18 20:28:33 +00:00
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
return this->Blocks[static_cast<std::size_t>(blockId)];
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
const std::vector<vtkm::cont::DataSet>& MultiBlock::GetBlocks() const
|
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
return this->Blocks;
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
2017-08-30 16:37:15 +00:00
|
|
|
|
2017-08-18 20:28:33 +00:00
|
|
|
VTKM_CONT
|
|
|
|
void MultiBlock::AddBlock(vtkm::cont::DataSet& ds)
|
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
this->Blocks.insert(this->Blocks.end(), ds);
|
2017-08-18 20:28:33 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MultiBlock::AddBlocks(std::vector<vtkm::cont::DataSet>& mblocks)
|
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
this->Blocks.insert(this->Blocks.end(), mblocks.begin(), mblocks.end());
|
2017-08-18 20:28:33 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
void MultiBlock::InsertBlock(vtkm::Id index, vtkm::cont::DataSet& ds)
|
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
if (index <= static_cast<vtkm::Id>(this->Blocks.size()))
|
|
|
|
this->Blocks.insert(this->Blocks.begin() + index, ds);
|
2017-08-18 20:28:33 +00:00
|
|
|
else
|
2017-08-24 14:50:14 +00:00
|
|
|
{
|
|
|
|
std::string msg = "invalid insert position\n ";
|
|
|
|
throw ErrorExecution(msg);
|
|
|
|
}
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
2017-08-24 14:50:14 +00:00
|
|
|
void MultiBlock::ReplaceBlock(vtkm::Id index, vtkm::cont::DataSet& ds)
|
2017-08-18 20:28:33 +00:00
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
if (index < static_cast<vtkm::Id>(this->Blocks.size()))
|
|
|
|
this->Blocks.at(static_cast<std::size_t>(index)) = ds;
|
2017-08-18 20:28:33 +00:00
|
|
|
else
|
2017-08-24 14:50:14 +00:00
|
|
|
{
|
|
|
|
std::string msg = "invalid replace position\n ";
|
|
|
|
throw ErrorExecution(msg);
|
|
|
|
}
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
2017-12-12 19:26:23 +00:00
|
|
|
VTKM_CONT vtkm::Bounds MultiBlock::GetBounds(vtkm::Id coordinate_system_index) const
|
2017-08-18 20:28:33 +00:00
|
|
|
{
|
2017-12-14 01:31:36 +00:00
|
|
|
#if defined(VTKM_ENABLE_MPI)
|
|
|
|
auto world = vtkm::cont::EnvironmentTracker::GetCommunicator();
|
2017-12-21 01:18:22 +00:00
|
|
|
diy::Master master(world,
|
|
|
|
1,
|
|
|
|
-1,
|
|
|
|
[]() -> void* { return new vtkm::Bounds(); },
|
|
|
|
[](void* ptr) { delete static_cast<vtkm::Bounds*>(ptr); });
|
2017-12-14 01:31:36 +00:00
|
|
|
|
2017-12-21 01:18:22 +00:00
|
|
|
vtkm::cont::AssignerMultiBlock assigner(*this);
|
2017-12-14 01:31:36 +00:00
|
|
|
|
2017-12-21 01:18:22 +00:00
|
|
|
// populate master with blocks from `this`.
|
|
|
|
diy::decompose(world.rank(), assigner, master);
|
2017-12-14 01:31:36 +00:00
|
|
|
|
2017-12-21 01:18:22 +00:00
|
|
|
auto self = (*this);
|
|
|
|
master.foreach ([&](vtkm::Bounds* data, const diy::Master::ProxyWithLink& cp) {
|
|
|
|
const vtkm::cont::DataSet& block = vtkm::cont::detail::GetBlock(self, cp);
|
|
|
|
try
|
|
|
|
{
|
|
|
|
vtkm::cont::CoordinateSystem coords = block.GetCoordinateSystem(coordinate_system_index);
|
2017-12-12 19:26:23 +00:00
|
|
|
*data = coords.GetBounds();
|
2017-12-21 01:18:22 +00:00
|
|
|
}
|
|
|
|
catch (const vtkm::cont::Error&)
|
|
|
|
{
|
|
|
|
}
|
2017-12-14 01:31:36 +00:00
|
|
|
});
|
|
|
|
|
2017-12-21 01:18:22 +00:00
|
|
|
vtkm::cont::DecomposerMultiBlock decomposer(assigner);
|
|
|
|
diy::RegularSwapPartners partners(decomposer, /*k=*/2);
|
|
|
|
|
|
|
|
auto callback =
|
|
|
|
[](vtkm::Bounds* data, const diy::ReduceProxy& srp, const diy::RegularSwapPartners&) {
|
|
|
|
// 1. dequeue.
|
|
|
|
std::vector<int> incoming;
|
|
|
|
srp.incoming(incoming);
|
|
|
|
vtkm::Bounds message;
|
|
|
|
for (const int gid : incoming)
|
|
|
|
{
|
|
|
|
srp.dequeue(gid, message);
|
|
|
|
data->Include(message);
|
|
|
|
}
|
|
|
|
// 2. enqueue
|
|
|
|
for (int cc = 0; cc < srp.out_link().size(); ++cc)
|
|
|
|
{
|
|
|
|
srp.enqueue(srp.out_link().target(cc), *data);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
diy::reduce(master, assigner, partners, callback);
|
|
|
|
if (master.size())
|
|
|
|
{
|
|
|
|
return (*master.block<vtkm::Bounds>(0));
|
|
|
|
}
|
|
|
|
return vtkm::Bounds();
|
2017-12-14 01:31:36 +00:00
|
|
|
|
|
|
|
#else
|
2017-08-18 20:28:33 +00:00
|
|
|
const vtkm::Id index = coordinate_system_index;
|
2017-12-06 01:06:19 +00:00
|
|
|
const size_t num_blocks = this->Blocks.size();
|
2017-08-18 20:28:33 +00:00
|
|
|
|
|
|
|
vtkm::Bounds bounds;
|
|
|
|
for (size_t i = 0; i < num_blocks; ++i)
|
2017-07-20 19:11:12 +00:00
|
|
|
{
|
2017-12-12 19:26:23 +00:00
|
|
|
vtkm::Bounds block_bounds = this->GetBlockBounds(i, index);
|
2017-08-18 20:28:33 +00:00
|
|
|
bounds.Include(block_bounds);
|
2017-07-20 19:11:12 +00:00
|
|
|
}
|
2017-08-18 20:28:33 +00:00
|
|
|
return bounds;
|
2017-12-14 01:31:36 +00:00
|
|
|
#endif
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT vtkm::Bounds MultiBlock::GetBlockBounds(const std::size_t& block_index,
|
2017-12-12 19:26:23 +00:00
|
|
|
vtkm::Id coordinate_system_index) const
|
2017-08-18 20:28:33 +00:00
|
|
|
{
|
|
|
|
const vtkm::Id index = coordinate_system_index;
|
|
|
|
vtkm::cont::CoordinateSystem coords;
|
|
|
|
try
|
2017-07-20 19:11:12 +00:00
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
coords = this->Blocks[block_index].GetCoordinateSystem(index);
|
2017-08-02 19:18:55 +00:00
|
|
|
}
|
2017-08-18 20:28:33 +00:00
|
|
|
catch (const vtkm::cont::Error& error)
|
|
|
|
{
|
|
|
|
std::stringstream msg;
|
|
|
|
msg << "GetBounds call failed. vtk-m error was encountered while "
|
|
|
|
<< "attempting to get coordinate system " << index << " from "
|
|
|
|
<< "block " << block_index << ". vtkm error message: " << error.GetMessage();
|
|
|
|
throw ErrorExecution(msg.str());
|
|
|
|
}
|
2017-12-12 19:26:23 +00:00
|
|
|
return coords.GetBounds();
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
2017-12-12 19:26:23 +00:00
|
|
|
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> MultiBlock::GetGlobalRange(const int& index) const
|
2017-08-18 20:28:33 +00:00
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
assert(this->Blocks.size() > 0);
|
|
|
|
vtkm::cont::Field field = this->Blocks.at(0).GetField(index);
|
2017-08-18 20:28:33 +00:00
|
|
|
std::string field_name = field.GetName();
|
2017-12-12 19:26:23 +00:00
|
|
|
return this->GetGlobalRange(field_name);
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> MultiBlock::GetGlobalRange(
|
2017-12-12 19:26:23 +00:00
|
|
|
const std::string& field_name) const
|
2017-08-18 20:28:33 +00:00
|
|
|
{
|
2017-12-14 01:31:36 +00:00
|
|
|
#if defined(VTKM_ENABLE_MPI)
|
2017-12-21 01:18:22 +00:00
|
|
|
using BlockMetaData = std::vector<vtkm::Range>;
|
2017-12-14 01:31:36 +00:00
|
|
|
|
2017-12-21 01:18:22 +00:00
|
|
|
auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
|
|
|
|
diy::Master master(comm,
|
|
|
|
1,
|
|
|
|
-1,
|
|
|
|
[]() -> void* { return new BlockMetaData(); },
|
|
|
|
[](void* ptr) { delete static_cast<BlockMetaData*>(ptr); });
|
|
|
|
|
|
|
|
vtkm::cont::AssignerMultiBlock assigner(*this);
|
2017-12-14 01:31:36 +00:00
|
|
|
|
2017-12-21 01:18:22 +00:00
|
|
|
diy::decompose(comm.rank(), assigner, master);
|
|
|
|
|
|
|
|
auto self = (*this);
|
|
|
|
master.foreach ([&](BlockMetaData* data, const diy::Master::ProxyWithLink& cp) {
|
|
|
|
const vtkm::cont::DataSet& block = vtkm::cont::detail::GetBlock(self, cp);
|
|
|
|
if (block.HasField(field_name))
|
2017-12-14 01:31:36 +00:00
|
|
|
{
|
2017-12-21 01:18:22 +00:00
|
|
|
auto field = block.GetField(field_name);
|
2017-12-12 19:26:23 +00:00
|
|
|
const vtkm::cont::ArrayHandle<vtkm::Range> range = field.GetRange();
|
2017-12-21 01:18:22 +00:00
|
|
|
*data = vtkm::cont::detail::CopyArrayPortalToVector(range.GetPortalConstControl());
|
2017-12-14 01:31:36 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2017-12-21 01:18:22 +00:00
|
|
|
vtkm::cont::DecomposerMultiBlock decomposer(assigner);
|
|
|
|
diy::RegularSwapPartners partners(decomposer, /*k=*/2);
|
|
|
|
auto callback =
|
|
|
|
[](BlockMetaData* data, const diy::ReduceProxy& srp, const diy::RegularSwapPartners&) {
|
|
|
|
std::vector<int> incoming;
|
|
|
|
srp.incoming(incoming);
|
2017-12-14 01:31:36 +00:00
|
|
|
|
2017-12-21 01:18:22 +00:00
|
|
|
// 1. dequeue
|
|
|
|
BlockMetaData message;
|
|
|
|
for (const int gid : incoming)
|
2017-12-14 01:31:36 +00:00
|
|
|
{
|
2017-12-21 01:18:22 +00:00
|
|
|
srp.dequeue(gid, message);
|
|
|
|
data->resize(std::max(data->size(), message.size()));
|
|
|
|
for (size_t cc = 0; cc < data->size(); ++cc)
|
|
|
|
{
|
|
|
|
(*data)[cc].Include(message[cc]);
|
|
|
|
}
|
2017-12-14 01:31:36 +00:00
|
|
|
}
|
2017-12-21 01:18:22 +00:00
|
|
|
// 2. enqueue
|
|
|
|
for (int cc = 0; cc < srp.out_link().size(); ++cc)
|
2017-12-14 01:31:36 +00:00
|
|
|
{
|
2017-12-21 01:18:22 +00:00
|
|
|
srp.enqueue(srp.out_link().target(cc), *data);
|
2017-12-14 01:31:36 +00:00
|
|
|
}
|
2017-12-21 01:18:22 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
diy::reduce(master, assigner, partners, callback);
|
|
|
|
|
|
|
|
BlockMetaData ranges;
|
|
|
|
if (master.size())
|
2017-12-14 01:31:36 +00:00
|
|
|
{
|
2017-12-21 01:18:22 +00:00
|
|
|
ranges = *(master.block<BlockMetaData>(0));
|
2017-12-14 01:31:36 +00:00
|
|
|
}
|
|
|
|
vtkm::cont::ArrayHandle<vtkm::Range> tmprange = vtkm::cont::make_ArrayHandle(ranges);
|
|
|
|
vtkm::cont::ArrayHandle<vtkm::Range> range;
|
|
|
|
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(ranges), range);
|
|
|
|
return range;
|
|
|
|
#else
|
2017-08-18 20:28:33 +00:00
|
|
|
bool valid_field = true;
|
2017-12-06 01:06:19 +00:00
|
|
|
const size_t num_blocks = this->Blocks.size();
|
2017-08-18 20:28:33 +00:00
|
|
|
|
|
|
|
vtkm::cont::ArrayHandle<vtkm::Range> range;
|
|
|
|
vtkm::Id num_components = 0;
|
|
|
|
|
|
|
|
for (size_t i = 0; i < num_blocks; ++i)
|
2017-07-20 19:11:12 +00:00
|
|
|
{
|
2017-12-06 01:06:19 +00:00
|
|
|
if (!this->Blocks[i].HasField(field_name))
|
2017-08-18 20:28:33 +00:00
|
|
|
{
|
|
|
|
valid_field = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-12-06 01:06:19 +00:00
|
|
|
const vtkm::cont::Field& field = this->Blocks[i].GetField(field_name);
|
2017-12-12 19:26:23 +00:00
|
|
|
vtkm::cont::ArrayHandle<vtkm::Range> sub_range = field.GetRange();
|
2017-07-20 19:11:12 +00:00
|
|
|
|
2017-08-18 20:28:33 +00:00
|
|
|
vtkm::cont::ArrayHandle<vtkm::Range>::PortalConstControl sub_range_control =
|
|
|
|
sub_range.GetPortalConstControl();
|
|
|
|
vtkm::cont::ArrayHandle<vtkm::Range>::PortalControl range_control = range.GetPortalControl();
|
2017-07-20 19:11:12 +00:00
|
|
|
|
2017-08-18 20:28:33 +00:00
|
|
|
if (i == 0)
|
2017-07-20 19:11:12 +00:00
|
|
|
{
|
2017-08-18 20:28:33 +00:00
|
|
|
num_components = sub_range_control.GetNumberOfValues();
|
|
|
|
range = sub_range;
|
|
|
|
continue;
|
|
|
|
}
|
2017-08-02 19:18:55 +00:00
|
|
|
|
2017-08-18 20:28:33 +00:00
|
|
|
vtkm::Id components = sub_range_control.GetNumberOfValues();
|
|
|
|
|
|
|
|
if (components != num_components)
|
|
|
|
{
|
|
|
|
std::stringstream msg;
|
|
|
|
msg << "GetRange call failed. The number of components (" << components << ") in field "
|
|
|
|
<< field_name << " from block " << i << " does not match the number of components "
|
|
|
|
<< "(" << num_components << ") in block 0";
|
|
|
|
throw ErrorExecution(msg.str());
|
2017-07-20 19:11:12 +00:00
|
|
|
}
|
|
|
|
|
2017-08-18 20:28:33 +00:00
|
|
|
for (vtkm::Id c = 0; c < components; ++c)
|
2017-07-20 19:11:12 +00:00
|
|
|
{
|
2017-08-18 20:28:33 +00:00
|
|
|
vtkm::Range s_range = sub_range_control.Get(c);
|
|
|
|
vtkm::Range c_range = range_control.Get(c);
|
|
|
|
c_range.Include(s_range);
|
|
|
|
range_control.Set(c, c_range);
|
2017-07-20 19:11:12 +00:00
|
|
|
}
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
2017-07-20 19:11:12 +00:00
|
|
|
|
2017-08-18 20:28:33 +00:00
|
|
|
if (!valid_field)
|
|
|
|
{
|
|
|
|
std::string msg = "GetRange call failed. ";
|
|
|
|
msg += " Field " + field_name + " did not exist in at least one block.";
|
|
|
|
throw ErrorExecution(msg);
|
2017-07-20 19:11:12 +00:00
|
|
|
}
|
2017-08-18 20:28:33 +00:00
|
|
|
|
|
|
|
return range;
|
2017-12-14 01:31:36 +00:00
|
|
|
#endif
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
|
|
|
|
2017-08-02 02:16:00 +00:00
|
|
|
VTKM_CONT
|
2017-08-18 20:28:33 +00:00
|
|
|
void MultiBlock::PrintSummary(std::ostream& stream) const
|
|
|
|
{
|
|
|
|
stream << "block "
|
|
|
|
<< "\n";
|
2017-07-20 19:11:12 +00:00
|
|
|
|
2017-12-06 01:06:19 +00:00
|
|
|
for (size_t block_index = 0; block_index < this->Blocks.size(); ++block_index)
|
2017-08-18 20:28:33 +00:00
|
|
|
{
|
|
|
|
stream << "block " << block_index << "\n";
|
2017-12-06 01:06:19 +00:00
|
|
|
this->Blocks[block_index].PrintSummary(stream);
|
2017-07-20 19:11:12 +00:00
|
|
|
}
|
|
|
|
}
|
2017-08-18 20:28:33 +00:00
|
|
|
}
|
2017-07-20 19:11:12 +00:00
|
|
|
} // namespace vtkm::cont
|