mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-09-19 02:25:42 +00:00
Add fields to particles.
This commit is contained in:
parent
c8bdb50a95
commit
9fefdf6e61
@ -114,6 +114,10 @@ public:
|
||||
, NumSteps(p.NumSteps)
|
||||
, Status(p.Status)
|
||||
, Time(p.Time)
|
||||
, NumIntegrations(p.NumIntegrations)
|
||||
, NumRounds(p.NumRounds)
|
||||
, NumCommunications(p.NumCommunications)
|
||||
, LifeTime(p.LifeTime)
|
||||
{
|
||||
}
|
||||
|
||||
@ -161,17 +165,25 @@ public:
|
||||
inline VTKM_CONT friend std::ostream& operator<<(std::ostream& out, const vtkm::Particle& p)
|
||||
{
|
||||
out << "v(" << p.Time << ") = " << p.Position << ", ID: " << p.ID
|
||||
<< ", NumSteps: " << p.NumSteps << ", Status: " << p.Status;
|
||||
<< ", NumSteps: " << p.NumSteps << ", Status: " << p.Status
|
||||
<< ", NumInt: " << p.NumIntegrations << ", NumRounds: " << p.NumRounds
|
||||
<< ", NumComm: " << p.NumCommunications << " LifeTime: " << p.LifeTime;
|
||||
return out;
|
||||
}
|
||||
|
||||
private:
|
||||
//private:
|
||||
public:
|
||||
vtkm::Vec3f Position;
|
||||
vtkm::Id ID = -1;
|
||||
vtkm::Id NumSteps = 0;
|
||||
vtkm::ParticleStatus Status;
|
||||
vtkm::FloatDefault Time = 0;
|
||||
|
||||
vtkm::Id NumIntegrations = 0;
|
||||
vtkm::Id NumRounds = 0;
|
||||
vtkm::Id NumCommunications = 0;
|
||||
vtkm::FloatDefault LifeTime = 0;
|
||||
|
||||
public:
|
||||
static size_t Sizeof()
|
||||
{
|
||||
@ -179,8 +191,9 @@ public:
|
||||
+ sizeof(vtkm::Id) // ID
|
||||
+ sizeof(vtkm::Id) // NumSteps
|
||||
+ sizeof(vtkm::UInt8) // Status
|
||||
+ sizeof(vtkm::FloatDefault); // Time
|
||||
|
||||
+ sizeof(vtkm::FloatDefault) // Time
|
||||
+ sizeof(vtkm::Id) * 3 //NumIntegrations, NumRounds, NumCommunications.
|
||||
+ sizeof(vtkm::FloatDefault); //LifeTime
|
||||
return sz;
|
||||
}
|
||||
};
|
||||
@ -293,7 +306,8 @@ public:
|
||||
return out;
|
||||
}
|
||||
|
||||
private:
|
||||
//private:
|
||||
public:
|
||||
vtkm::Vec3f Position;
|
||||
vtkm::Id ID = -1;
|
||||
vtkm::Id NumSteps = 0;
|
||||
@ -306,6 +320,11 @@ private:
|
||||
constexpr static vtkm::FloatDefault SPEED_OF_LIGHT =
|
||||
static_cast<vtkm::FloatDefault>(2.99792458e8);
|
||||
|
||||
vtkm::Id NumIntegrations = 0;
|
||||
vtkm::Id NumRounds = 0;
|
||||
vtkm::Id NumCommunications = 0;
|
||||
vtkm::FloatDefault LifeTime = 0;
|
||||
|
||||
friend struct mangled_diy_namespace::Serialization<vtkm::ChargedParticle>;
|
||||
|
||||
public:
|
||||
@ -341,6 +360,11 @@ public:
|
||||
vtkmdiy::save(bb, p.GetNumberOfSteps());
|
||||
vtkmdiy::save(bb, p.GetStatus());
|
||||
vtkmdiy::save(bb, p.GetTime());
|
||||
|
||||
vtkmdiy::save(bb, p.NumIntegrations);
|
||||
vtkmdiy::save(bb, p.NumRounds);
|
||||
vtkmdiy::save(bb, p.NumCommunications);
|
||||
vtkmdiy::save(bb, p.LifeTime);
|
||||
}
|
||||
|
||||
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::Particle& p)
|
||||
@ -364,6 +388,11 @@ public:
|
||||
vtkm::FloatDefault time;
|
||||
vtkmdiy::load(bb, time);
|
||||
p.SetTime(time);
|
||||
|
||||
vtkmdiy::load(bb, p.NumIntegrations);
|
||||
vtkmdiy::load(bb, p.NumRounds);
|
||||
vtkmdiy::load(bb, p.NumCommunications);
|
||||
vtkmdiy::load(bb, p.LifeTime);
|
||||
}
|
||||
};
|
||||
|
||||
@ -382,6 +411,11 @@ public:
|
||||
vtkmdiy::save(bb, e.Charge);
|
||||
vtkmdiy::save(bb, e.Weighting);
|
||||
vtkmdiy::save(bb, e.Momentum);
|
||||
|
||||
vtkmdiy::save(bb, e.NumIntegrations);
|
||||
vtkmdiy::save(bb, e.NumRounds);
|
||||
vtkmdiy::save(bb, e.NumCommunications);
|
||||
vtkmdiy::save(bb, e.LifeTime);
|
||||
}
|
||||
|
||||
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::ChargedParticle& e)
|
||||
@ -395,6 +429,11 @@ public:
|
||||
vtkmdiy::load(bb, e.Charge);
|
||||
vtkmdiy::load(bb, e.Weighting);
|
||||
vtkmdiy::load(bb, e.Momentum);
|
||||
|
||||
vtkmdiy::load(bb, e.NumIntegrations);
|
||||
vtkmdiy::load(bb, e.NumRounds);
|
||||
vtkmdiy::load(bb, e.NumCommunications);
|
||||
vtkmdiy::load(bb, e.LifeTime);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
@ -57,6 +57,18 @@ VTKM_ALWAYS_EXPORT inline void ParticleArrayCopy(
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outSteps,
|
||||
vtkm::cont::ArrayHandle<vtkm::ParticleStatus, vtkm::cont::StorageTagBasic>& outStatus,
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault, vtkm::cont::StorageTagBasic>& outTime);
|
||||
|
||||
template <typename ParticleType>
|
||||
VTKM_ALWAYS_EXPORT inline void ParticleArrayCopy(
|
||||
const std::vector<vtkm::cont::ArrayHandle<ParticleType, vtkm::cont::StorageTagBasic>>& inputs,
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f, vtkm::cont::StorageTagBasic>& outPos,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outIDs,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outSteps,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outNumInt,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outNumRounds,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outNumComm,
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault, vtkm::cont::StorageTagBasic>& outLifeTime);
|
||||
|
||||
}
|
||||
} // namespace vtkm::cont
|
||||
|
||||
|
@ -39,6 +39,48 @@ struct ExtractTerminatedFunctor
|
||||
bool operator()(const ParticleType& p) const { return p.GetStatus().CheckTerminate(); }
|
||||
};
|
||||
|
||||
template <typename ParticleType>
|
||||
struct ExtractIDFunctor
|
||||
{
|
||||
VTKM_EXEC_CONT
|
||||
vtkm::Id operator()(const ParticleType& p) const { return p.GetID(); }
|
||||
};
|
||||
|
||||
template <typename ParticleType>
|
||||
struct ExtractStepsFunctor
|
||||
{
|
||||
VTKM_EXEC_CONT
|
||||
vtkm::Id operator()(const ParticleType& p) const { return p.GetNumberOfSteps(); }
|
||||
};
|
||||
|
||||
template <typename ParticleType>
|
||||
struct ExtractNumIntFunctor
|
||||
{
|
||||
VTKM_EXEC_CONT
|
||||
vtkm::Id operator()(const ParticleType& p) const { return p.NumIntegrations; }
|
||||
};
|
||||
|
||||
template <typename ParticleType>
|
||||
struct ExtractNumRoundsFunctor
|
||||
{
|
||||
VTKM_EXEC_CONT
|
||||
vtkm::Id operator()(const ParticleType& p) const { return p.NumRounds; }
|
||||
};
|
||||
|
||||
template <typename ParticleType>
|
||||
struct ExtractNumCommFunctor
|
||||
{
|
||||
VTKM_EXEC_CONT
|
||||
vtkm::Id operator()(const ParticleType& p) const { return p.NumCommunications; }
|
||||
};
|
||||
|
||||
template <typename ParticleType>
|
||||
struct ExtractLifeTimeFunctor
|
||||
{
|
||||
VTKM_EXEC_CONT
|
||||
vtkm::FloatDefault operator()(const ParticleType& p) const { return p.LifeTime; }
|
||||
};
|
||||
|
||||
template <typename ParticleType>
|
||||
struct CopyParticleAllWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
@ -130,6 +172,61 @@ VTKM_ALWAYS_EXPORT inline void ParticleArrayCopy(
|
||||
|
||||
invoke(worklet, inP, outPos, outID, outSteps, outStatus, outTime);
|
||||
}
|
||||
|
||||
template <typename ParticleType>
|
||||
VTKM_ALWAYS_EXPORT inline void ParticleArrayCopy(
|
||||
const std::vector<vtkm::cont::ArrayHandle<ParticleType, vtkm::cont::StorageTagBasic>>& inputs,
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f, vtkm::cont::StorageTagBasic>& outPos,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outIDs,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outSteps,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outNumInt,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outNumRounds,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>& outNumComm,
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault, vtkm::cont::StorageTagBasic>& outLifeTime)
|
||||
{
|
||||
vtkm::Id numParticles = 0;
|
||||
for (const auto& v : inputs)
|
||||
numParticles += v.GetNumberOfValues();
|
||||
|
||||
outPos.Allocate(numParticles);
|
||||
outIDs.Allocate(numParticles);
|
||||
outSteps.Allocate(numParticles);
|
||||
outNumInt.Allocate(numParticles);
|
||||
outNumRounds.Allocate(numParticles);
|
||||
outNumComm.Allocate(numParticles);
|
||||
outLifeTime.Allocate(numParticles);
|
||||
|
||||
vtkm::Id idx = 0;
|
||||
for (const auto& v : inputs)
|
||||
{
|
||||
auto posTrn =
|
||||
vtkm::cont::make_ArrayHandleTransform(v, detail::ExtractPositionFunctor<ParticleType>());
|
||||
auto idsTrn =
|
||||
vtkm::cont::make_ArrayHandleTransform(v, detail::ExtractIDFunctor<ParticleType>());
|
||||
auto stepsTrn =
|
||||
vtkm::cont::make_ArrayHandleTransform(v, detail::ExtractStepsFunctor<ParticleType>());
|
||||
auto numIntTrn =
|
||||
vtkm::cont::make_ArrayHandleTransform(v, detail::ExtractNumIntFunctor<ParticleType>());
|
||||
auto numRoundsTrn =
|
||||
vtkm::cont::make_ArrayHandleTransform(v, detail::ExtractNumRoundsFunctor<ParticleType>());
|
||||
auto numCommTrn =
|
||||
vtkm::cont::make_ArrayHandleTransform(v, detail::ExtractNumCommFunctor<ParticleType>());
|
||||
auto numLifeTimeTrn =
|
||||
vtkm::cont::make_ArrayHandleTransform(v, detail::ExtractLifeTimeFunctor<ParticleType>());
|
||||
|
||||
vtkm::Id n = posTrn.GetNumberOfValues();
|
||||
vtkm::cont::Algorithm::CopySubRange(posTrn, 0, n, outPos, idx);
|
||||
vtkm::cont::Algorithm::CopySubRange(stepsTrn, 0, n, outSteps, idx);
|
||||
vtkm::cont::Algorithm::CopySubRange(idsTrn, 0, n, outIDs, idx);
|
||||
vtkm::cont::Algorithm::CopySubRange(numIntTrn, 0, n, outNumInt, idx);
|
||||
vtkm::cont::Algorithm::CopySubRange(numCommTrn, 0, n, outNumComm, idx);
|
||||
vtkm::cont::Algorithm::CopySubRange(numRoundsTrn, 0, n, outNumRounds, idx);
|
||||
vtkm::cont::Algorithm::CopySubRange(numLifeTimeTrn, 0, n, outLifeTime, idx);
|
||||
idx += n;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
} // namespace vtkm::cont
|
||||
|
||||
|
@ -96,6 +96,15 @@ public:
|
||||
vtkm::Id nLocal = static_cast<vtkm::Id>(this->Active.size() + this->Inactive.size());
|
||||
this->ComputeTotalNumParticles(nLocal);
|
||||
|
||||
//DRP: Set global time;
|
||||
#ifdef VTKM_ENABLE_MPI
|
||||
MPI_Comm mpiComm = vtkmdiy::mpi::mpi_cast(this->Comm.handle());
|
||||
MPI_Barrier(mpiComm);
|
||||
this->StartTime = MPI_Wtime();
|
||||
for (auto& block : this->Blocks)
|
||||
block.StartTime = this->StartTime;
|
||||
#endif
|
||||
|
||||
messenger.Log << "Begin" << std::endl;
|
||||
while (this->TotalNumTerminatedParticles < this->TotalNumParticles)
|
||||
{
|
||||
@ -104,6 +113,9 @@ public:
|
||||
vtkm::Id numTerm = 0, blockId = -1;
|
||||
if (this->GetActiveParticles(v, blockId))
|
||||
{
|
||||
for (auto& p : v)
|
||||
p.NumIntegrations++;
|
||||
|
||||
messenger.Log << " Advect " << v.size() << " in block " << blockId << std::endl;
|
||||
//make this a pointer to avoid the copy?
|
||||
auto& block = this->GetDataSet(blockId);
|
||||
@ -122,6 +134,24 @@ public:
|
||||
throw vtkm::cont::ErrorFilterExecution("Particle count error");
|
||||
}
|
||||
messenger.Log << "Done" << std::endl;
|
||||
|
||||
//DRP
|
||||
//Print out particle fluxes
|
||||
if (this->Rank == 0)
|
||||
{
|
||||
std::cout << "==================================" << std::endl;
|
||||
std::cout << "Rank: " << this->Rank << std::endl;
|
||||
std::cout << "ParticleFlux: " << this->Rank << std::endl;
|
||||
for (const auto& block : this->Blocks)
|
||||
{
|
||||
std::cout << " Block_ID: " << block.GetID() << std::endl;
|
||||
for (const auto& it : block.ParticleFlux)
|
||||
{
|
||||
std::cout << " " << it.first << " :: " << it.second << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
MPI_Barrier(mpiComm);
|
||||
}
|
||||
|
||||
|
||||
@ -203,6 +233,9 @@ public:
|
||||
|
||||
messenger.Log << " Communicate: AI= " << this->Active.size() << " " << this->Inactive.size()
|
||||
<< " localTerm= " << numLocalTerminations << " Block= " << block << std::endl;
|
||||
for (auto& p : this->Inactive)
|
||||
p.NumCommunications++;
|
||||
|
||||
messenger.Exchange(this->Inactive,
|
||||
this->ParticleBlockIDsMap,
|
||||
numLocalTerminations,
|
||||
@ -295,6 +328,9 @@ public:
|
||||
vtkm::FloatDefault StepSize;
|
||||
vtkm::Id TotalNumParticles = 0;
|
||||
vtkm::Id TotalNumTerminatedParticles = 0;
|
||||
|
||||
//DRP
|
||||
vtkm::FloatDefault StartTime = 0.0;
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -106,7 +106,6 @@ public:
|
||||
template <typename ParticleType>
|
||||
VTKM_CONT bool GetOutput(vtkm::cont::DataSet& ds) const;
|
||||
|
||||
|
||||
protected:
|
||||
template <typename ParticleType, template <typename> class ResultType>
|
||||
VTKM_CONT void UpdateResult(const ResultType<ParticleType>& result,
|
||||
@ -124,7 +123,7 @@ protected:
|
||||
|
||||
template <typename ParticleType>
|
||||
VTKM_CONT inline void ClassifyParticles(const vtkm::cont::ArrayHandle<ParticleType>& particles,
|
||||
DSIHelperInfo<ParticleType>& dsiInfo) const;
|
||||
DSIHelperInfo<ParticleType>& dsiInfo); //DRPconst;
|
||||
|
||||
//Data members.
|
||||
vtkm::cont::Variant<VelocityFieldNameType, ElectroMagneticFieldNameType> FieldName;
|
||||
@ -139,13 +138,19 @@ protected:
|
||||
vtkm::Id Rank;
|
||||
bool CopySeedArray = false;
|
||||
std::vector<RType> Results;
|
||||
|
||||
//DRP
|
||||
public:
|
||||
vtkm::FloatDefault StartTime = 0.0;
|
||||
// key=blockId, value = number of particles
|
||||
std::map<vtkm::Id, vtkm::Id> ParticleFlux;
|
||||
};
|
||||
|
||||
template <typename Derived>
|
||||
template <typename ParticleType>
|
||||
VTKM_CONT inline void DataSetIntegrator<Derived>::ClassifyParticles(
|
||||
const vtkm::cont::ArrayHandle<ParticleType>& particles,
|
||||
DSIHelperInfo<ParticleType>& dsiInfo) const
|
||||
DSIHelperInfo<ParticleType>& dsiInfo) //DRP const
|
||||
{
|
||||
dsiInfo.A.clear();
|
||||
dsiInfo.I.clear();
|
||||
@ -161,10 +166,13 @@ VTKM_CONT inline void DataSetIntegrator<Derived>::ClassifyParticles(
|
||||
{
|
||||
auto p = portal.Get(i);
|
||||
|
||||
bool particleTerminates = false;
|
||||
if (p.GetStatus().CheckTerminate())
|
||||
{
|
||||
dsiInfo.TermIdx.emplace_back(i);
|
||||
dsiInfo.TermID.emplace_back(p.GetID());
|
||||
//DRP
|
||||
particleTerminates = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -187,6 +195,8 @@ VTKM_CONT inline void DataSetIntegrator<Derived>::ClassifyParticles(
|
||||
p.GetStatus().SetTerminate();
|
||||
dsiInfo.TermIdx.emplace_back(i);
|
||||
dsiInfo.TermID.emplace_back(p.GetID());
|
||||
//DRP
|
||||
particleTerminates = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -206,6 +216,15 @@ VTKM_CONT inline void DataSetIntegrator<Derived>::ClassifyParticles(
|
||||
}
|
||||
}
|
||||
|
||||
//Record particle flux
|
||||
#ifdef VTKM_ENABLE_MPI
|
||||
// if (this->ParticleFlux.find(newIDs[0]) == this->ParticleFlux.end())
|
||||
// this->ParticleFlux[newIDs[0]] = 0;
|
||||
//auto it = this->ParticleFlux.find(newIDs[0]);
|
||||
this->ParticleFlux[newIDs[0]]++;
|
||||
//it->second++;
|
||||
#endif
|
||||
|
||||
int dstRank = dsiInfo.BoundsMap.FindRank(newIDs[0]);
|
||||
if (dstRank == this->Rank)
|
||||
{
|
||||
@ -218,6 +237,12 @@ VTKM_CONT inline void DataSetIntegrator<Derived>::ClassifyParticles(
|
||||
dsiInfo.IdMapI[p.GetID()] = newIDs;
|
||||
}
|
||||
}
|
||||
#ifdef VTKM_ENABLE_MPI
|
||||
//DRP
|
||||
if (particleTerminates)
|
||||
p.LifeTime = MPI_Wtime() - this->StartTime;
|
||||
#endif
|
||||
|
||||
portal.Set(i, p);
|
||||
}
|
||||
}
|
||||
@ -272,8 +297,18 @@ VTKM_CONT inline bool DataSetIntegrator<Derived>::GetOutput(vtkm::cont::DataSet&
|
||||
for (const auto& vres : this->Results)
|
||||
allParticles.emplace_back(vres.template Get<ResType>().Particles);
|
||||
|
||||
std::cout << "GetOutput() " << std::endl;
|
||||
std::cout << " " << allParticles[0].ReadPortal().Get(0) << std::endl;
|
||||
|
||||
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> ids, steps, numInt, numRounds, numComm;
|
||||
vtkm::cont::ArrayHandle<vtkm::FloatDefault> lifeTime;
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Vec3f> pts;
|
||||
vtkm::cont::ParticleArrayCopy(allParticles, pts);
|
||||
//vtkm::cont::ParticleArrayCopy(allParticles, pts);
|
||||
vtkm::cont::ParticleArrayCopy(
|
||||
allParticles, pts, ids, steps, numInt, numRounds, numComm, lifeTime);
|
||||
|
||||
vtkm::Id numPoints = pts.GetNumberOfValues();
|
||||
if (numPoints > 0)
|
||||
@ -288,6 +323,13 @@ VTKM_CONT inline bool DataSetIntegrator<Derived>::GetOutput(vtkm::cont::DataSet&
|
||||
vtkm::cont::ArrayCopy(conn, connectivity);
|
||||
cells.Fill(numPoints, vtkm::CELL_SHAPE_VERTEX, 1, connectivity);
|
||||
ds.SetCellSet(cells);
|
||||
|
||||
ds.AddCellField("IDs", ids);
|
||||
ds.AddCellField("NumSteps", steps);
|
||||
ds.AddCellField("NumIntegrations", numInt);
|
||||
ds.AddCellField("NumRounds", numRounds);
|
||||
ds.AddCellField("NumComm", numComm);
|
||||
ds.AddCellField("lifeTime", lifeTime);
|
||||
}
|
||||
}
|
||||
else if (this->IsStreamlineResult())
|
||||
|
@ -15,6 +15,7 @@
|
||||
#include <vtkm/filter/flow/internal/BoundsMap.h>
|
||||
#include <vtkm/filter/flow/internal/Messenger.h>
|
||||
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
|
||||
#include <vtkm/worklet/WorkletMapField.h>
|
||||
|
||||
#include <list>
|
||||
#include <map>
|
||||
@ -30,6 +31,17 @@ namespace flow
|
||||
namespace internal
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <typename ParticleType>
|
||||
struct UpdatePreCommunicationWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
using ControlSignature = void(FieldInOut inParticle);
|
||||
|
||||
VTKM_EXEC void operator()(ParticleType& particle) const { particle.NumCommunications++; }
|
||||
};
|
||||
}
|
||||
|
||||
template <typename ParticleType>
|
||||
class VTKM_FILTER_FLOW_EXPORT ParticleMessenger : public vtkm::filter::flow::internal::Messenger
|
||||
{
|
||||
@ -201,6 +213,10 @@ void ParticleMessenger<ParticleType>::Exchange(
|
||||
outData, outBlockIDsMap, numLocalTerm, inData, inDataBlockIDsMap, blockAndWait);
|
||||
|
||||
#ifdef VTKM_ENABLE_MPI
|
||||
auto outArrayHandle = vtkm::cont::make_ArrayHandle(outData, vtkm::CopyFlag::Off);
|
||||
vtkm::cont::Invoker invoke;
|
||||
//detail::UpdatePreCommunicationWorklet<ParticleType> worklet;
|
||||
invoke(detail::UpdatePreCommunicationWorklet<ParticleType>{}, outArrayHandle);
|
||||
|
||||
//dstRank, vector of (particles,blockIDs)
|
||||
std::unordered_map<int, std::vector<ParticleCommType>> sendData;
|
||||
|
@ -414,6 +414,9 @@ void TestPartitionedDataSet(vtkm::Id nPerRank, bool useGhost, FilterType fType,
|
||||
{
|
||||
VTKM_TEST_ASSERT(out.GetNumberOfPartitions() == 1, "Wrong number of partitions in output");
|
||||
ValidateOutput(out.GetPartition(0), numSeeds, xMaxRanges[xMaxRanges.size() - 1], fType);
|
||||
|
||||
vtkm::Id n = out.GetNumberOfPartitions();
|
||||
out.GetPartition(n - 1).PrintSummary(std::cout);
|
||||
}
|
||||
else
|
||||
VTKM_TEST_ASSERT(out.GetNumberOfPartitions() == 0, "Wrong number of partitions in output");
|
||||
@ -444,7 +447,8 @@ void TestStreamlineFiltersMPI()
|
||||
//filterTypes = {filterTypes[1]};
|
||||
//flags = {false};
|
||||
|
||||
//TestPartitionedDataSet(1, false, PARTICLE_ADVECTION, true);
|
||||
TestPartitionedDataSet(1, false, PARTICLE_ADVECTION, false);
|
||||
return;
|
||||
|
||||
auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
|
||||
for (int n = 1; n < 3; n++)
|
||||
|
Loading…
Reference in New Issue
Block a user