mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-09-19 18:45:43 +00:00
ed43dad6ca
Previously, DynamicArrayHandle and DynamicCellSet had slightly different interfaces to their CastTo feature. It was a bit confusing and not all that easy to use. This change simplifies and unifies them by making each class have a single CopyTo method that takes a reference to a cast object (an ArrayHandle or CellSet, respectively) and fills that object with the data contained if the cast is successfull. This interface gets around having to declare strange types. Each object also has a Cast method that has to have a template parameter specified and returns a reference of that type (if possible). In addition, the old behavior is preserved for DynamicArrayHandle (but not DynamicCellSet). To avoid confusion, the name of that cast method is CastToTypeStorage. However, the method was chaned to not take parameters to make it consistent with the other Cast method. Also, the IsType methods have been modified to reflect changes in cast/copy. IsType now no longer takes arguments. However, an alternate IsSameType does the same thing but does take an argument.
440 lines
17 KiB
C++
440 lines
17 KiB
C++
//============================================================================
|
|
// 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 2014 Sandia Corporation.
|
|
// Copyright 2014 UT-Battelle, LLC.
|
|
// Copyright 2014 Los Alamos National Security.
|
|
//
|
|
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
|
|
// 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.
|
|
//============================================================================
|
|
|
|
#ifndef vtk_m_worklet_StreamLineUniformGrid_h
|
|
#define vtk_m_worklet_StreamLineUniformGrid_h
|
|
|
|
#include <vtkm/cont/DeviceAdapter.h>
|
|
#include <vtkm/cont/ArrayHandle.h>
|
|
#include <vtkm/cont/ArrayHandleCounting.h>
|
|
#include <vtkm/cont/DataSet.h>
|
|
#include <vtkm/cont/CellSetStructured.h>
|
|
#include <vtkm/cont/CellSetExplicit.h>
|
|
#include <vtkm/cont/Field.h>
|
|
|
|
#include <vtkm/worklet/DispatcherMapField.h>
|
|
#include <vtkm/worklet/ScatterUniform.h>
|
|
#include <vtkm/worklet/WorkletMapField.h>
|
|
|
|
#include <vtkm/exec/ExecutionWholeArray.h>
|
|
|
|
namespace vtkm {
|
|
|
|
// Take this out when defined in CellShape.h
|
|
const vtkm::UInt8 CELL_SHAPE_POLY_LINE = 4;
|
|
|
|
namespace worklet {
|
|
|
|
namespace internal {
|
|
|
|
enum StreamLineMode
|
|
{
|
|
FORWARD = 0,
|
|
BACKWARD = 1,
|
|
BOTH = 2
|
|
};
|
|
|
|
// Trilinear interpolation to calculate vector data at position
|
|
template <typename FieldType, typename PortalType>
|
|
VTKM_EXEC_EXPORT
|
|
vtkm::Vec<FieldType, 3> VecDataAtPos(
|
|
vtkm::Vec<FieldType, 3> pos,
|
|
const vtkm::Id3 &vdims,
|
|
const vtkm::Id &planesize,
|
|
const vtkm::Id &rowsize,
|
|
const PortalType &vecdata)
|
|
{
|
|
// Adjust initial position to be within bounding box of grid
|
|
for (vtkm::IdComponent d = 0; d < 3; d++)
|
|
{
|
|
if (pos[d] < 0.0f)
|
|
pos[d] = 0.0f;
|
|
if (pos[d] > static_cast<FieldType>(vdims[d] - 1))
|
|
pos[d] = static_cast<FieldType>(vdims[d] - 1);
|
|
}
|
|
|
|
// Set the eight corner indices with no wraparound
|
|
vtkm::Id3 idx000, idx001, idx010, idx011, idx100, idx101, idx110, idx111;
|
|
idx000[0] = static_cast<vtkm::Id>(floor(pos[0]));
|
|
idx000[1] = static_cast<vtkm::Id>(floor(pos[1]));
|
|
idx000[2] = static_cast<vtkm::Id>(floor(pos[2]));
|
|
|
|
idx001 = idx000; idx001[0] = (idx001[0] + 1) <= vdims[0] - 1 ? idx001[0] + 1 : vdims[0] - 1;
|
|
idx010 = idx000; idx010[1] = (idx010[1] + 1) <= vdims[1] - 1 ? idx010[1] + 1 : vdims[1] - 1;
|
|
idx011 = idx010; idx011[0] = (idx011[0] + 1) <= vdims[0] - 1 ? idx011[0] + 1 : vdims[0] - 1;
|
|
idx100 = idx000; idx100[2] = (idx100[2] + 1) <= vdims[2] - 1 ? idx100[2] + 1 : vdims[2] - 1;
|
|
idx101 = idx100; idx101[0] = (idx101[0] + 1) <= vdims[0] - 1 ? idx101[0] + 1 : vdims[0] - 1;
|
|
idx110 = idx100; idx110[1] = (idx110[1] + 1) <= vdims[1] - 1 ? idx110[1] + 1 : vdims[1] - 1;
|
|
idx111 = idx110; idx111[0] = (idx111[0] + 1) <= vdims[0] - 1 ? idx111[0] + 1 : vdims[0] - 1;
|
|
|
|
// Get the vecdata at the eight corners
|
|
vtkm::Vec<FieldType, 3> v000, v001, v010, v011, v100, v101, v110, v111;
|
|
v000 = vecdata.Get(idx000[2] * planesize + idx000[1] * rowsize + idx000[0]);
|
|
v001 = vecdata.Get(idx001[2] * planesize + idx001[1] * rowsize + idx001[0]);
|
|
v010 = vecdata.Get(idx010[2] * planesize + idx010[1] * rowsize + idx010[0]);
|
|
v011 = vecdata.Get(idx011[2] * planesize + idx011[1] * rowsize + idx011[0]);
|
|
v100 = vecdata.Get(idx100[2] * planesize + idx100[1] * rowsize + idx100[0]);
|
|
v101 = vecdata.Get(idx101[2] * planesize + idx101[1] * rowsize + idx101[0]);
|
|
v110 = vecdata.Get(idx110[2] * planesize + idx110[1] * rowsize + idx110[0]);
|
|
v111 = vecdata.Get(idx111[2] * planesize + idx111[1] * rowsize + idx111[0]);
|
|
|
|
// Interpolation in X
|
|
vtkm::Vec<FieldType, 3> v00, v01, v10, v11;
|
|
FieldType a = pos[0] - static_cast<FieldType>(floor(pos[0]));
|
|
v00[0] = (1.0f - a) * v000[0] + a * v001[0];
|
|
v00[1] = (1.0f - a) * v000[1] + a * v001[1];
|
|
v00[2] = (1.0f - a) * v000[2] + a * v001[2];
|
|
|
|
v01[0] = (1.0f - a) * v010[0] + a * v011[0];
|
|
v01[1] = (1.0f - a) * v010[1] + a * v011[1];
|
|
v01[2] = (1.0f - a) * v010[2] + a * v011[2];
|
|
|
|
v10[0] = (1.0f - a) * v100[0] + a * v101[0];
|
|
v10[1] = (1.0f - a) * v100[1] + a * v101[1];
|
|
v10[2] = (1.0f - a) * v100[2] + a * v101[2];
|
|
|
|
v11[0] = (1.0f - a) * v110[0] + a * v111[0];
|
|
v11[1] = (1.0f - a) * v110[1] + a * v111[1];
|
|
v11[2] = (1.0f - a) * v110[2] + a * v111[2];
|
|
|
|
// Interpolation in Y
|
|
vtkm::Vec<FieldType, 3> v0, v1;
|
|
a = pos[1] - static_cast<FieldType>(floor(pos[1]));
|
|
v0[0] = (1.0f - a) * v00[0] + a * v01[0];
|
|
v0[1] = (1.0f - a) * v00[1] + a * v01[1];
|
|
v0[2] = (1.0f - a) * v00[2] + a * v01[2];
|
|
|
|
v1[0] = (1.0f - a) * v10[0] + a * v11[0];
|
|
v1[1] = (1.0f - a) * v10[1] + a * v11[1];
|
|
v1[2] = (1.0f - a) * v10[2] + a * v11[2];
|
|
|
|
// Interpolation in Z
|
|
vtkm::Vec<FieldType, 3> v;
|
|
a = pos[2] - static_cast<FieldType>(floor(pos[2]));
|
|
v[0] = (1.0f - a) * v0[0] + v1[0];
|
|
v[1] = (1.0f - a) * v0[1] + v1[1];
|
|
v[2] = (1.0f - a) * v0[2] + v1[2];
|
|
return v;
|
|
}
|
|
}
|
|
|
|
/// \brief Compute the streamline
|
|
template <typename FieldType, typename DeviceAdapter>
|
|
class StreamLineFilterUniformGrid
|
|
{
|
|
public:
|
|
struct IsUnity
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT bool operator()(const T &x) const
|
|
{
|
|
return x == T(1);
|
|
}
|
|
};
|
|
|
|
typedef vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3> > FieldHandle;
|
|
typedef typename FieldHandle::template ExecutionTypes<DeviceAdapter>::PortalConst FieldPortalConstType;
|
|
|
|
class MakeStreamLines : public vtkm::worklet::WorkletMapField
|
|
{
|
|
public:
|
|
typedef void ControlSignature(FieldIn<IdType> seedId,
|
|
FieldIn<> position,
|
|
ExecObject numIndices,
|
|
ExecObject validPoint,
|
|
ExecObject streamLines);
|
|
typedef void ExecutionSignature(_1, _2, _3, _4, _5, VisitIndex);
|
|
typedef _1 InputDomain;
|
|
|
|
typedef vtkm::worklet::ScatterUniform ScatterType;
|
|
VTKM_CONT_EXPORT
|
|
ScatterType GetScatter() const
|
|
{
|
|
return ScatterType(2);
|
|
}
|
|
|
|
FieldPortalConstType field;
|
|
const vtkm::Id3 vdims;
|
|
const vtkm::Id maxsteps;
|
|
const FieldType timestep;
|
|
const vtkm::Id planesize;
|
|
const vtkm::Id rowsize;
|
|
const vtkm::Id streammode;
|
|
|
|
VTKM_CONT_EXPORT
|
|
MakeStreamLines(const FieldType tStep,
|
|
const vtkm::Id sMode,
|
|
const vtkm::Id nSteps,
|
|
const vtkm::Id3 dims,
|
|
FieldPortalConstType fieldArray) :
|
|
field(fieldArray),
|
|
vdims(dims),
|
|
maxsteps(nSteps),
|
|
timestep(tStep),
|
|
planesize(dims[0] * dims[1]),
|
|
rowsize(dims[0]),
|
|
streammode(sMode)
|
|
{
|
|
}
|
|
|
|
VTKM_EXEC_EXPORT
|
|
void operator()(vtkm::Id &seedId,
|
|
vtkm::Vec<FieldType, 3> &seedPos,
|
|
vtkm::exec::ExecutionWholeArray<vtkm::IdComponent> &numIndices,
|
|
vtkm::exec::ExecutionWholeArray<vtkm::IdComponent> &validPoint,
|
|
vtkm::exec::ExecutionWholeArray<vtkm::Vec<FieldType, 3> > &slLists,
|
|
vtkm::IdComponent visitIndex) const
|
|
{
|
|
// Set initial offset into the output streams array
|
|
vtkm::Vec<FieldType, 3> pos = seedPos;
|
|
vtkm::Vec<FieldType, 3> pre_pos = seedPos;
|
|
|
|
// Forward tracing
|
|
if (visitIndex == 0 &&
|
|
(streammode == vtkm::worklet::internal::FORWARD ||
|
|
streammode == vtkm::worklet::internal::BOTH))
|
|
{
|
|
vtkm::Id index = (seedId * 2) * maxsteps;
|
|
bool done = false;
|
|
vtkm::Id step = 0;
|
|
validPoint.Set(index, 1);
|
|
slLists.Set(index++, pos);
|
|
|
|
while (done != true && step < maxsteps)
|
|
{
|
|
vtkm::Vec<FieldType, 3> vdata, adata, bdata, cdata, ddata;
|
|
vdata = internal::VecDataAtPos<FieldType, FieldPortalConstType>
|
|
(pos, vdims, planesize, rowsize, field);
|
|
for (vtkm::IdComponent d = 0; d < 3; d++)
|
|
{
|
|
adata[d] = timestep * vdata[d];
|
|
pos[d] += adata[d] / 2.0f;
|
|
}
|
|
|
|
vdata = internal::VecDataAtPos<FieldType, FieldPortalConstType>
|
|
(pos, vdims, planesize, rowsize, field);
|
|
for (vtkm::IdComponent d = 0; d < 3; d++)
|
|
{
|
|
bdata[d] = timestep * vdata[d];
|
|
pos[d] += bdata[d] / 2.0f;
|
|
}
|
|
|
|
vdata = internal::VecDataAtPos<FieldType, FieldPortalConstType>
|
|
(pos, vdims, planesize, rowsize, field);
|
|
for (vtkm::IdComponent d = 0; d < 3; d++)
|
|
{
|
|
cdata[d] = timestep * vdata[d];
|
|
pos[d] += cdata[d] / 2.0f;
|
|
}
|
|
|
|
vdata = internal::VecDataAtPos<FieldType, FieldPortalConstType>
|
|
(pos, vdims, planesize, rowsize, field);
|
|
for (vtkm::IdComponent d = 0; d < 3; d++)
|
|
{
|
|
ddata[d] = timestep * vdata[d];
|
|
pos[d] += (adata[d] + (2.0f * bdata[d]) + (2.0f * cdata[d]) + ddata[d]) / 6.0f;
|
|
}
|
|
|
|
if (pos[0] < 0.0f || pos[0] > vdims[0] ||
|
|
pos[1] < 0.0f || pos[1] > vdims[1] ||
|
|
pos[2] < 0.0f || pos[2] > vdims[2])
|
|
{
|
|
pos = pre_pos;
|
|
done = true;
|
|
} else {
|
|
validPoint.Set(index, 1);
|
|
slLists.Set(index++, pos);
|
|
pre_pos = pos;
|
|
}
|
|
step++;
|
|
}
|
|
numIndices.Set(seedId * 2, static_cast<vtkm::IdComponent>(step));
|
|
}
|
|
|
|
// Backward tracing
|
|
if (visitIndex == 1 &&
|
|
(streammode == vtkm::worklet::internal::BACKWARD ||
|
|
streammode == vtkm::worklet::internal::BOTH))
|
|
{
|
|
vtkm::Id index = (seedId * 2 + 1) * maxsteps;
|
|
bool done = false;
|
|
vtkm::Id step = 0;
|
|
validPoint.Set(index, 1);
|
|
slLists.Set(index++, pos);
|
|
|
|
while (done != true && step < maxsteps)
|
|
{
|
|
vtkm::Vec<FieldType, 3> vdata, adata, bdata, cdata, ddata;
|
|
vdata = internal::VecDataAtPos<FieldType, FieldPortalConstType>
|
|
(pos, vdims, planesize, rowsize, field);
|
|
for (vtkm::IdComponent d = 0; d < 3; d++)
|
|
{
|
|
adata[d] = timestep * (0.0f - vdata[d]);
|
|
pos[d] += adata[d] / 2.0f;
|
|
}
|
|
|
|
vdata = internal::VecDataAtPos<FieldType, FieldPortalConstType>
|
|
(pos, vdims, planesize, rowsize, field);
|
|
for (vtkm::IdComponent d = 0; d < 3; d++)
|
|
{
|
|
bdata[d] = timestep * (0.0f - vdata[d]);
|
|
pos[d] += bdata[d] / 2.0f;
|
|
}
|
|
|
|
vdata = internal::VecDataAtPos<FieldType, FieldPortalConstType>
|
|
(pos, vdims, planesize, rowsize, field);
|
|
for (vtkm::IdComponent d = 0; d < 3; d++)
|
|
{
|
|
cdata[d] = timestep * (0.0f - vdata[d]);
|
|
pos[d] += cdata[d] / 2.0f;
|
|
}
|
|
|
|
vdata = internal::VecDataAtPos<FieldType, FieldPortalConstType>
|
|
(pos, vdims, planesize, rowsize, field);
|
|
for (vtkm::IdComponent d = 0; d < 3; d++)
|
|
{
|
|
ddata[d] = timestep * (0.0f - vdata[d]);
|
|
pos[d] += (adata[d] + (2.0f * bdata[d]) + (2.0f * cdata[d]) + ddata[d]) / 6.0f;
|
|
}
|
|
|
|
if (pos[0] < 0.0f || pos[0] > vdims[0] ||
|
|
pos[1] < 0.0f || pos[1] > vdims[1] ||
|
|
pos[2] < 0.0f || pos[2] > vdims[2])
|
|
{
|
|
pos = pre_pos;
|
|
done = true;
|
|
} else {
|
|
validPoint.Set(index, 1);
|
|
slLists.Set(index++, pos);
|
|
pre_pos = pos;
|
|
}
|
|
step++;
|
|
}
|
|
numIndices.Set((seedId * 2) + 1, static_cast<vtkm::IdComponent>(step));
|
|
}
|
|
}
|
|
};
|
|
|
|
StreamLineFilterUniformGrid()
|
|
{
|
|
}
|
|
|
|
vtkm::cont::DataSet Run(const vtkm::cont::DataSet &InDataSet,
|
|
vtkm::Id streamMode,
|
|
vtkm::Id numSeeds,
|
|
vtkm::Id maxSteps,
|
|
FieldType timeStep)
|
|
{
|
|
typedef typename vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter> DeviceAlgorithm;
|
|
|
|
// Get information from input dataset
|
|
vtkm::cont::CellSetStructured<3> inCellSet;
|
|
InDataSet.GetCellSet(0).CopyTo(inCellSet);
|
|
vtkm::Id3 vdims= inCellSet.GetSchedulingRange(vtkm::TopologyElementTagPoint());
|
|
|
|
vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3> > fieldArray;
|
|
InDataSet.GetField("vecData").GetData().CopyTo(fieldArray);
|
|
|
|
// Generate random seeds for starting streamlines
|
|
std::vector<vtkm::Vec<FieldType, 3> > seeds;
|
|
for (vtkm::Id i = 0; i < numSeeds; i++)
|
|
{
|
|
vtkm::Vec<FieldType, 3> seed;
|
|
seed[0] = static_cast<FieldType>(rand() % vdims[0]);
|
|
seed[1] = static_cast<FieldType>(rand() % vdims[1]);
|
|
seed[2] = static_cast<FieldType>(rand() % vdims[2]);
|
|
seeds.push_back(seed);
|
|
}
|
|
vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3> > seedPosArray =
|
|
vtkm::cont::make_ArrayHandle(&seeds[0], numSeeds);
|
|
vtkm::cont::ArrayHandleCounting<vtkm::Id> seedIdArray(0, 1, numSeeds);
|
|
|
|
// Number of streams * number of steps * [forward, backward]
|
|
vtkm::Id numCells = numSeeds * 2;
|
|
vtkm::Id maxConnectivityLen = numCells * maxSteps;
|
|
|
|
// Stream array at max size will be filled with stream coordinates
|
|
vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3> > streamArray;
|
|
streamArray.Allocate(maxConnectivityLen);
|
|
|
|
// NumIndices per polyline cell filled in by MakeStreamLines
|
|
vtkm::cont::ArrayHandle<vtkm::IdComponent> numIndices;
|
|
numIndices.Allocate(numCells);
|
|
|
|
// All cells are polylines
|
|
vtkm::cont::ArrayHandle<vtkm::UInt8> cellTypes;
|
|
cellTypes.Allocate(numCells);
|
|
vtkm::cont::ArrayHandleConstant<vtkm::UInt8> polyLineShape(vtkm::CELL_SHAPE_POLY_LINE, numCells);
|
|
DeviceAlgorithm::Copy(polyLineShape, cellTypes);
|
|
|
|
// Possible maxSteps points but if less use stencil
|
|
vtkm::cont::ArrayHandle<vtkm::IdComponent> validPoint;
|
|
vtkm::cont::ArrayHandleConstant<vtkm::Id> zeros(0, maxConnectivityLen);
|
|
validPoint.Allocate(maxConnectivityLen);
|
|
DeviceAlgorithm::Copy(zeros, validPoint);
|
|
|
|
// Worklet to make the streamlines
|
|
MakeStreamLines makeStreamLines(timeStep,
|
|
streamMode,
|
|
maxSteps,
|
|
vdims,
|
|
fieldArray.PrepareForInput(DeviceAdapter()));
|
|
typedef typename vtkm::worklet::DispatcherMapField<MakeStreamLines> MakeStreamLinesDispatcher;
|
|
MakeStreamLinesDispatcher makeStreamLinesDispatcher(makeStreamLines);
|
|
makeStreamLinesDispatcher.Invoke(
|
|
seedIdArray,
|
|
seedPosArray,
|
|
vtkm::exec::ExecutionWholeArray<vtkm::IdComponent>(numIndices, numCells),
|
|
vtkm::exec::ExecutionWholeArray<vtkm::IdComponent>(validPoint, maxConnectivityLen),
|
|
vtkm::exec::ExecutionWholeArray<vtkm::Vec<FieldType, 3> >(streamArray, maxConnectivityLen));
|
|
|
|
// Size of connectivity based on size of returned streamlines
|
|
vtkm::cont::ArrayHandle<vtkm::IdComponent> numIndicesOut;
|
|
vtkm::IdComponent connectivityLen = DeviceAlgorithm::ScanExclusive(numIndices, numIndicesOut);
|
|
|
|
// Connectivity is sequential
|
|
vtkm::cont::ArrayHandleCounting<vtkm::Id> connCount(0, 1, connectivityLen);
|
|
vtkm::cont::ArrayHandle<vtkm::Id> connectivity;
|
|
DeviceAlgorithm::Copy(connCount, connectivity);
|
|
|
|
// Compact the stream array so it only has valid points
|
|
vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3> > coordinates;
|
|
DeviceAlgorithm::StreamCompact(streamArray,
|
|
validPoint,
|
|
coordinates,
|
|
IsUnity());
|
|
|
|
// Create the output data set
|
|
vtkm::cont::DataSet OutDataSet;
|
|
vtkm::cont::CellSetExplicit<> outCellSet;
|
|
|
|
outCellSet.Fill(cellTypes, numIndices, connectivity);
|
|
OutDataSet.AddCellSet(outCellSet);
|
|
OutDataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", 0, coordinates));
|
|
|
|
return OutDataSet;
|
|
}
|
|
};
|
|
|
|
}
|
|
}
|
|
|
|
#endif // vtk_m_worklet_StreamLineUniformGrid_h
|