Shuenhoy/vtk-m2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move PA tests into Streamline

Browse Source
This commit is contained in:
Dave Pugmire 2020-11-02 16:25:38 -05:00
parent 2a916ebc0f
commit 467ad88d06
4 changed files with 167 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vtkm/filter/testing/CMakeLists.txt
View File

@ -46,7 +46,6 @@ set(unit_tests
UnitTestMeshQualityFilter.cxx
UnitTestNDEntropyFilter.cxx
UnitTestNDHistogramFilter.cxx
UnitTestParticleAdvectionFilter.cxx
UnitTestPartitionedDataSetFilters.cxx
UnitTestPartitionedDataSetHistogramFilter.cxx
UnitTestPointAverageFilter.cxx
@ -80,7 +79,6 @@ vtkm_unit_tests(
# if MPI is enabled.
if (VTKm_ENABLE_MPI)
set(mpi_unit_tests
UnitTestParticleAdvectionFilterMPI.cxx
UnitTestParticleMessengerMPI.cxx
UnitTestStreamlineFilterMPI.cxx
)

4
vtkm/filter/testing/UnitTestParticleAdvectionFilter.cxx
View File

@ -149,10 +149,6 @@ void TestPartitionedDataSet()
ds.AddPointField(fieldName, vecField);
}
std::cout << "RUN ON: " << std::endl << std::endl;
pds.PrintSummary(std::cout);
std::cout << std::endl << std::endl << std::endl << std::endl;
vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1),

168
vtkm/filter/testing/UnitTestStreamlineFilter.cxx
View File

@ -10,6 +10,7 @@
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/ParticleAdvection.h>
#include <vtkm/filter/Pathline.h>
#include <vtkm/filter/Streamline.h>
#include <vtkm/io/VTKDataSetReader.h>
@ -28,6 +29,14 @@ vtkm::cont::ArrayHandle<vtkm::Vec3f> CreateConstantVectorField(vtkm::Id num, con
return vecField;
}
void AddVectorFields(vtkm::cont::PartitionedDataSet& pds,
const std::string& fieldName,
const vtkm::Vec3f& vec)
{
for (auto& ds : pds)
ds.AddPointField(fieldName, CreateConstantVectorField(ds.GetNumberOfPoints(), vec));
}
void TestStreamline()
{
const vtkm::Id3 dims(5, 5, 5);
@ -115,17 +124,141 @@ void TestPathline()
}
}
void TestPartitionedDataSet(vtkm::Id num, bool useGhost, bool useSL)
{
vtkm::Id numDims = 5;
vtkm::FloatDefault x0 = 0;
vtkm::FloatDefault x1 = x0 + static_cast<vtkm::FloatDefault>(numDims - 1);
vtkm::FloatDefault dx = x1 - x0;
vtkm::FloatDefault y0 = 0, y1 = numDims - 1, z0 = 0, z1 = numDims - 1;
if (useGhost)
{
numDims = numDims + 2; //add 1 extra on each side
x0 = x0 - 1;
x1 = x1 + 1;
dx = x1 - x0 - 2;
y0 = y0 - 1;
y1 = y1 + 1;
z0 = z0 - 1;
z1 = z1 + 1;
}
std::vector<vtkm::Bounds> bounds;
for (vtkm::Id i = 0; i < num; i++)
{
bounds.push_back(vtkm::Bounds(x0, x1, y0, y1, z0, z1));
x0 += dx;
x1 += dx;
}
std::vector<vtkm::cont::PartitionedDataSet> allPDs;
const vtkm::Id3 dims(numDims, numDims, numDims);
allPDs = vtkm::worklet::testing::CreateAllDataSets(bounds, dims, useGhost);
vtkm::Vec3f vecX(1, 0, 0);
std::string fieldName = "vec";
for (auto& pds : allPDs)
{
AddVectorFields(pds, fieldName, vecX);
vtkm::cont::ArrayHandle<vtkm::Particle> seedArray;
seedArray = vtkm::cont::make_ArrayHandle({ vtkm::Particle(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Particle(vtkm::Vec3f(.2f, 2.0f, .2f), 1) });
vtkm::Id numSeeds = seedArray.GetNumberOfValues();
if (useSL)
{
vtkm::filter::Streamline streamline;
streamline.SetStepSize(0.1f);
streamline.SetNumberOfSteps(100000);
streamline.SetSeeds(seedArray);
streamline.SetActiveField(fieldName);
auto out = streamline.Execute(pds);
for (vtkm::Id i = 0; i < num; i++)
{
auto inputDS = pds.GetPartition(i);
auto outputDS = out.GetPartition(i);
VTKM_TEST_ASSERT(outputDS.GetNumberOfCoordinateSystems() == 1,
"Wrong number of coordinate systems in the output dataset");
vtkm::cont::DynamicCellSet dcells = outputDS.GetCellSet();
VTKM_TEST_ASSERT(dcells.GetNumberOfCells() == numSeeds, "Wrong number of cells");
auto coords = outputDS.GetCoordinateSystem().GetDataAsMultiplexer();
auto ptPortal = coords.ReadPortal();
vtkm::cont::CellSetExplicit<> explicitCells;
VTKM_TEST_ASSERT(dcells.IsType<vtkm::cont::CellSetExplicit<>>(), "Wrong cell type.");
explicitCells = dcells.Cast<vtkm::cont::CellSetExplicit<>>();
vtkm::FloatDefault xMax = bounds[static_cast<std::size_t>(i)].X.Max;
if (useGhost)
xMax = xMax - 1;
vtkm::Range xMaxRange(xMax, xMax + static_cast<vtkm::FloatDefault>(.5));
for (vtkm::Id j = 0; j < numSeeds; j++)
{
vtkm::cont::ArrayHandle<vtkm::Id> indices;
explicitCells.GetIndices(j, indices);
vtkm::Id nPts = indices.GetNumberOfValues();
auto iPortal = indices.ReadPortal();
vtkm::Vec3f lastPt = ptPortal.Get(iPortal.Get(nPts - 1));
VTKM_TEST_ASSERT(xMaxRange.Contains(lastPt[0]), "Wrong end point for seed");
}
}
}
else
{
vtkm::filter::ParticleAdvection particleAdvection;
particleAdvection.SetStepSize(0.1f);
particleAdvection.SetNumberOfSteps(100000);
particleAdvection.SetSeeds(seedArray);
particleAdvection.SetActiveField(fieldName);
auto out = particleAdvection.Execute(pds);
VTKM_TEST_ASSERT(out.GetNumberOfPartitions() == 1, "Wrong number of partitions in output");
auto ds = out.GetPartition(0);
//Validate the result is correct.
VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1,
"Wrong number of coordinate systems in the output dataset");
vtkm::FloatDefault xMax = bounds[bounds.size() - 1].X.Max;
if (useGhost)
xMax = xMax - 1;
vtkm::Range xMaxRange(xMax, xMax + static_cast<vtkm::FloatDefault>(.5));
auto coords = ds.GetCoordinateSystem().GetDataAsMultiplexer();
VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == numSeeds, "Wrong number of coordinates");
auto ptPortal = coords.ReadPortal();
for (vtkm::Id i = 0; i < numSeeds; i++)
VTKM_TEST_ASSERT(xMaxRange.Contains(ptPortal.Get(i)[0]), "Wrong end point for seed");
vtkm::cont::DynamicCellSet dcells = ds.GetCellSet();
VTKM_TEST_ASSERT(dcells.GetNumberOfCells() == numSeeds, "Wrong number of cells");
}
}
}
void TestStreamlineFile(const std::string& fname,
const std::vector<vtkm::Vec3f>& pts,
vtkm::FloatDefault stepSize,
vtkm::Id maxSteps,
const std::vector<vtkm::Vec3f>& endPts)
const std::vector<vtkm::Vec3f>& endPts,
bool useSL)
{
vtkm::io::VTKDataSetReader reader(fname);
vtkm::cont::DataSet ds;
try
{
ds = reader.ReadDataSet();
VTKM_TEST_ASSERT(ds.HasField("vec"));
}
catch (vtkm::io::ErrorIO& e)
{
@ -143,14 +276,25 @@ void TestStreamlineFile(const std::string& fname,
seeds.push_back(vtkm::Particle(pts[static_cast<std::size_t>(i)], i));
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off);
vtkm::cont::DataSet output;
if (useSL)
{
vtkm::filter::Streamline streamline;
streamline.SetStepSize(stepSize);
streamline.SetNumberOfSteps(maxSteps);
streamline.SetSeeds(seedArray);
VTKM_TEST_ASSERT(ds.HasField("vec"));
streamline.SetActiveField("vec");
auto output = streamline.Execute(ds);
output = streamline.Execute(ds);
}
else
{
vtkm::filter::ParticleAdvection particleAdvection;
particleAdvection.SetStepSize(stepSize);
particleAdvection.SetNumberOfSteps(maxSteps);
particleAdvection.SetSeeds(seedArray);
particleAdvection.SetActiveField("vec");
output = particleAdvection.Execute(ds);
}
auto coords = output.GetCoordinateSystem().GetDataAsMultiplexer();
vtkm::cont::DynamicCellSet dcells = output.GetCellSet();
@ -175,6 +319,14 @@ void TestStreamlineFile(const std::string& fname,
void TestStreamlineFilters()
{
std::vector<bool> flags = { true, false };
for (int n = 1; n < 3; n++)
{
for (auto useGhost : flags)
for (auto useSL : flags)
TestPartitionedDataSet(n, useGhost, useSL);
}
TestStreamline();
TestPathline();
@ -189,7 +341,9 @@ void TestStreamlineFilters()
fusionEndPts.push_back(vtkm::Vec3f(0.7004770041f, 0.63193398714f, 0.64524400234f));
vtkm::FloatDefault fusionStep = 0.005f;
std::string fusionFile = vtkm::cont::testing::Testing::DataPath("rectilinear/fusion.vtk");
TestStreamlineFile(fusionFile, fusionPts, fusionStep, 1000, fusionEndPts);
for (auto useSL : flags)
TestStreamlineFile(fusionFile, fusionPts, fusionStep, 1000, fusionEndPts, useSL);
//Fishtank test.
std::vector<vtkm::Vec3f> fishPts, fishEndPts;
@ -202,7 +356,9 @@ void TestStreamlineFilters()
fishEndPts.push_back(vtkm::Vec3f(0.8347796798f, 0.1276152730f, 0.4985143244f));
vtkm::FloatDefault fishStep = 0.001f;
std::string fishFile = vtkm::cont::testing::Testing::DataPath("rectilinear/fishtank.vtk");
TestStreamlineFile(fishFile, fishPts, fishStep, 100, fishEndPts);
for (auto useSL : flags)
TestStreamlineFile(fishFile, fishPts, fishStep, 100, fishEndPts, useSL);
}
}

1
vtkm/worklet/testing/GenerateTestDataSets.h
View File

@ -11,7 +11,6 @@
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DataSetBuilderRectilinear.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/filter/CleanGrid.h>
#include <vtkm/filter/GhostCellClassify.h>
namespace vtkm