Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 10:35:42 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Merge branch 'static-dataset-builder-methods' into 'master'

Browse Source 
Improvements to data set builds

Some improvements to data set builders to make them easier to use. The main changes are making most of the methods static so that the class does not have to be instantiated and to accept DynamicArrayHandle for fields.

See merge request !325
This commit is contained in:
Kenneth Moreland 2016-01-21 17:21:59 -05:00
commit 51ef8f470c
10 changed files with 232 additions and 305 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
vtkm/cont/DataSetBuilderExplicit.h
View File

@ -35,6 +35,8 @@ namespace cont {
class DataSetBuilderExplicit
{
template<typename T>
VTKM_CONT_EXPORT
static
void CopyInto(const std::vector<T>& input,
vtkm::cont::ArrayHandle<T>& output )
{
@ -52,6 +54,7 @@ public:
//Zoo explicit cell
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const std::vector<T> &xVals,
const std::vector<T> &yVals,
@ -63,13 +66,14 @@ public:
const std::string &cellNm="cells")
{
std::vector<T> zVals(xVals.size(),0);
return Create(xVals,yVals,zVals,
shapes,numIndices,connectivity,
dimensionality, coordsNm,cellNm);
return DataSetBuilderExplicit::Create(xVals,yVals,zVals,
shapes,numIndices,connectivity,
dimensionality, coordsNm,cellNm);
}
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const std::vector<T> &xVals,
const std::vector<T> &yVals,
@ -83,6 +87,7 @@ public:
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const vtkm::cont::ArrayHandle<T> &xVals,
const vtkm::cont::ArrayHandle<T> &yVals,
@ -94,14 +99,16 @@ public:
const std::string &coordsNm="coords",
const std::string &cellNm="cells")
{
return BuildDataSet(xVals,yVals,zVals,
shapes,numIndices,connectivity,
dimensionality, coordsNm,cellNm);
return DataSetBuilderExplicit::BuildDataSet(
xVals,yVals,zVals,
shapes,numIndices,connectivity,
dimensionality, coordsNm,cellNm);
}
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const std::vector<vtkm::Vec<T,3> > &coords,
const std::vector<vtkm::UInt8> &shapes,
@ -113,6 +120,7 @@ public:
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const vtkm::cont::ArrayHandle<vtkm::Vec<T,3> > &coords,
const vtkm::cont::ArrayHandle<vtkm::UInt8> &shapes,
@ -122,12 +130,18 @@ public:
const std::string &coordsNm="coords",
const std::string &cellNm="cells")
{
return BuildDataSet(coords, shapes, numIndices, connectivity,
dimensionality, coordsNm, cellNm);
return DataSetBuilderExplicit::BuildDataSet(coords,
shapes,
numIndices,
connectivity,
dimensionality,
coordsNm,
cellNm);
}
template<typename T, typename CellShapeTag>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const std::vector<vtkm::Vec<T,3> > &coords,
CellShapeTag tag,
@ -137,6 +151,7 @@ public:
template<typename T, typename CellShapeTag>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const vtkm::cont::ArrayHandle<vtkm::Vec<T,3> > &coords,
CellShapeTag tag,
@ -144,11 +159,16 @@ public:
const std::string &coordsNm="coords",
const std::string &cellNm="cells")
{
return BuildDataSet(coords, tag, connectivity, coordsNm, cellNm);
return DataSetBuilderExplicit::BuildDataSet(coords,
tag,
connectivity,
coordsNm,
cellNm);
}
private:
template<typename T>
static
vtkm::cont::DataSet
BuildDataSet(const vtkm::cont::ArrayHandle<T> &X,
const vtkm::cont::ArrayHandle<T> &Y,
@ -162,6 +182,7 @@ private:
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
BuildDataSet(const vtkm::cont::ArrayHandle<vtkm::Vec<T,3> > &coords,
const vtkm::cont::ArrayHandle<vtkm::UInt8> &shapes,
@ -173,6 +194,7 @@ private:
template<typename T, typename CellShapeTag>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
BuildDataSet(const vtkm::cont::ArrayHandle<vtkm::Vec<T,3> > &coords,
CellShapeTag tag,
@ -198,31 +220,33 @@ DataSetBuilderExplicit::Create(const std::vector<T> &xVals,
xVals.size() > 0);
vtkm::cont::ArrayHandle<T> Xc, Yc, Zc;
this->CopyInto(xVals, Xc);
this->CopyInto(yVals, Yc);
this->CopyInto(zVals, Zc);
DataSetBuilderExplicit::CopyInto(xVals, Xc);
DataSetBuilderExplicit::CopyInto(yVals, Yc);
DataSetBuilderExplicit::CopyInto(zVals, Zc);
vtkm::cont::ArrayHandle<vtkm::UInt8> Sc;
vtkm::cont::ArrayHandle<vtkm::IdComponent> Nc;
vtkm::cont::ArrayHandle<vtkm::Id> Cc;
this->CopyInto(shapes, Sc);
this->CopyInto(numIndices, Nc);
this->CopyInto(connectivity, Cc);
DataSetBuilderExplicit::CopyInto(shapes, Sc);
DataSetBuilderExplicit::CopyInto(numIndices, Nc);
DataSetBuilderExplicit::CopyInto(connectivity, Cc);
return BuildDataSet(Xc,Yc,Zc, Sc,Nc,Cc, dimensionality, coordsNm, cellNm);
return DataSetBuilderExplicit::BuildDataSet(
Xc,Yc,Zc, Sc,Nc,Cc, dimensionality, coordsNm, cellNm);
}
template<typename T>
vtkm::cont::DataSet
DataSetBuilderExplicit::BuildDataSet(const vtkm::cont::ArrayHandle<T> &X,
const vtkm::cont::ArrayHandle<T> &Y,
const vtkm::cont::ArrayHandle<T> &Z,
const vtkm::cont::ArrayHandle<vtkm::UInt8> &shapes,
const vtkm::cont::ArrayHandle<vtkm::IdComponent> &numIndices,
const vtkm::cont::ArrayHandle<vtkm::Id> &connectivity,
int dimensionality,
const std::string &coordsNm,
const std::string &cellNm)
DataSetBuilderExplicit::BuildDataSet(
const vtkm::cont::ArrayHandle<T> &X,
const vtkm::cont::ArrayHandle<T> &Y,
const vtkm::cont::ArrayHandle<T> &Z,
const vtkm::cont::ArrayHandle<vtkm::UInt8> &shapes,
const vtkm::cont::ArrayHandle<vtkm::IdComponent> &numIndices,
const vtkm::cont::ArrayHandle<vtkm::Id> &connectivity,
int dimensionality,
const std::string &coordsNm,
const std::string &cellNm)
{
VTKM_ASSERT_CONT(X.GetNumberOfValues() == Y.GetNumberOfValues() &&
Y.GetNumberOfValues() == Z.GetNumberOfValues() &&
@ -253,16 +277,17 @@ DataSetBuilderExplicit::Create(const std::vector<vtkm::Vec<T,3> > &coords,
const std::string &cellNm)
{
vtkm::cont::ArrayHandle<Vec<T,3> > coordsArray;
CopyInto(coords, coordsArray);
DataSetBuilderExplicit::CopyInto(coords, coordsArray);
vtkm::cont::ArrayHandle<vtkm::UInt8> Sc;
vtkm::cont::ArrayHandle<vtkm::IdComponent> Nc;
vtkm::cont::ArrayHandle<vtkm::Id> Cc;
this->CopyInto(shapes, Sc);
this->CopyInto(numIndices, Nc);
this->CopyInto(connectivity, Cc);
DataSetBuilderExplicit::CopyInto(shapes, Sc);
DataSetBuilderExplicit::CopyInto(numIndices, Nc);
DataSetBuilderExplicit::CopyInto(connectivity, Cc);
return Create(coordsArray, Sc, Nc, Cc, dimensionality, coordsNm, cellNm);
return DataSetBuilderExplicit::Create(
coordsArray, Sc, Nc, Cc, dimensionality, coordsNm, cellNm);
}
template<typename T>
@ -298,12 +323,12 @@ DataSetBuilderExplicit::Create(const std::vector<vtkm::Vec<T,3> > &coords,
const std::string &cellNm)
{
vtkm::cont::ArrayHandle<Vec<T,3> > coordsArray;
this->CopyInto(coords, coordsArray);
DataSetBuilderExplicit::CopyInto(coords, coordsArray);
vtkm::cont::ArrayHandle<vtkm::Id> Cc;
this->CopyInto(connectivity, Cc);
DataSetBuilderExplicit::CopyInto(connectivity, Cc);
return Create(coordsArray, tag, Cc, coordsNm, cellNm);
return DataSetBuilderExplicit::Create(coordsArray, tag, Cc, coordsNm, cellNm);
}
template<typename T, typename CellShapeTag>

61
vtkm/cont/DataSetBuilderRectilinear.h
View File

@ -32,6 +32,8 @@ namespace cont {
class DataSetBuilderRectilinear
{
template<typename T, typename U>
VTKM_CONT_EXPORT
static
void CopyInto(const std::vector<T>& input,
vtkm::cont::ArrayHandle<U>& output )
{
@ -41,6 +43,8 @@ class DataSetBuilderRectilinear
}
template<typename T, typename U>
VTKM_CONT_EXPORT
static
void CopyInto(const vtkm::cont::ArrayHandle<T>& input,
vtkm::cont::ArrayHandle<U>& output )
{
@ -51,6 +55,8 @@ class DataSetBuilderRectilinear
}
template<typename T, typename U>
VTKM_CONT_EXPORT
static
void CopyInto(const T* input, vtkm::Id len,
vtkm::cont::ArrayHandle<U>& output )
{
@ -65,45 +71,52 @@ public:
//2D grids.
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(vtkm::Id nx, vtkm::Id ny,
T *xvals, T *yvals,
std::string coordNm="coords", std::string cellNm="cells")
{
T zvals = 0;
return Create(2, nx,ny, 1, xvals, yvals, &zvals, coordNm, cellNm);
return DataSetBuilderRectilinear::Create(
2, nx,ny, 1, xvals, yvals, &zvals, coordNm, cellNm);
}
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(int dim, vtkm::Id nx, vtkm::Id ny, vtkm::Id nz,
T *xvals, T *yvals, T *zvals,
std::string coordNm, std::string cellNm)
{
VTKM_ASSERT_CONT(nx>1 && ny>1 &&
((dim==2 && nz==1)||(dim==3 && nz>=1)));
((dim==2 && nz==1)||(dim==3 && nz>=1)));
vtkm::cont::ArrayHandle<vtkm::FloatDefault> Xc, Yc, Zc;
CopyInto(xvals,nx,Xc);
CopyInto(yvals,ny,Yc);
CopyInto(zvals,nz,Zc);
DataSetBuilderRectilinear::CopyInto(xvals,nx,Xc);
DataSetBuilderRectilinear::CopyInto(yvals,ny,Yc);
DataSetBuilderRectilinear::CopyInto(zvals,nz,Zc);
return BuildDataSet(dim, Xc,Yc,Zc, coordNm, cellNm);
return DataSetBuilderRectilinear::BuildDataSet(
dim, Xc,Yc,Zc, coordNm, cellNm);
}
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const std::vector<T> &xvals, const std::vector<T> &yvals,
std::string coordNm="coords", std::string cellNm="cells")
{
std::vector<T> zvals(1,0);
return BuildDataSet(2, xvals,yvals,zvals, coordNm,cellNm);
return DataSetBuilderRectilinear::BuildDataSet(
2, xvals,yvals,zvals, coordNm,cellNm);
}
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const vtkm::cont::ArrayHandle<T> &xvals,
const vtkm::cont::ArrayHandle<T> &yvals,
@ -114,33 +127,39 @@ public:
vtkm::cont::ArrayHandle<T> zvals;
zvals.Allocate(1);
zvals.GetPortalControl().Set(0,0.0);
return BuildDataSet(2, xvals,yvals,zvals, coordNm, cellNm);
return DataSetBuilderRectilinear::BuildDataSet(
2, xvals,yvals,zvals, coordNm, cellNm);
}
//3D grids.
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(vtkm::Id nx, vtkm::Id ny, vtkm::Id nz,
T *xvals, T *yvals, T *zvals,
std::string coordNm="coords", std::string cellNm="cells")
{
return Create(3, nx,ny,nz, xvals, yvals, zvals, coordNm, cellNm);
return DataSetBuilderRectilinear::Create(
3, nx,ny,nz, xvals, yvals, zvals, coordNm, cellNm);
}
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const std::vector<T> &xvals,
const std::vector<T> &yvals,
const std::vector<T> &zvals,
std::string coordNm="coords", std::string cellNm="cells")
{
return BuildDataSet(3, xvals, yvals, zvals, coordNm, cellNm);
return DataSetBuilderRectilinear::BuildDataSet(
3, xvals, yvals, zvals, coordNm, cellNm);
}
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const vtkm::cont::ArrayHandle<T> &xvals,
const vtkm::cont::ArrayHandle<T> &yvals,
@ -150,12 +169,14 @@ public:
VTKM_ASSERT_CONT(xvals.GetNumberOfValues()>1 &&
yvals.GetNumberOfValues()>1 &&
zvals.GetNumberOfValues()>1);
return BuildDataSet(3, xvals,yvals,zvals, coordNm, cellNm);
return DataSetBuilderRectilinear::BuildDataSet(
3, xvals,yvals,zvals, coordNm, cellNm);
}
private:
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
BuildDataSet(int dim,
const std::vector<T> &xvals,
@ -164,18 +185,20 @@ private:
std::string coordNm, std::string cellNm)
{
VTKM_ASSERT_CONT(xvals.size()>1 && yvals.size()>1 &&
((dim==2 && zvals.size()==1)||(dim==3 && zvals.size()>=1)));
((dim==2 && zvals.size()==1)||(dim==3 && zvals.size()>=1)));
vtkm::cont::ArrayHandle<vtkm::FloatDefault> Xc, Yc, Zc;
this->CopyInto(xvals, Xc);
this->CopyInto(yvals, Yc);
this->CopyInto(zvals, Zc);
DataSetBuilderRectilinear::CopyInto(xvals, Xc);
DataSetBuilderRectilinear::CopyInto(yvals, Yc);
DataSetBuilderRectilinear::CopyInto(zvals, Zc);
return BuildDataSet(dim, Xc,Yc,Zc, coordNm, cellNm);
return DataSetBuilderRectilinear::BuildDataSet(
dim, Xc,Yc,Zc, coordNm, cellNm);
}
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
BuildDataSet(int dim,
const vtkm::cont::ArrayHandle<T> &X,
@ -192,9 +215,9 @@ private:
vtkm::cont::ArrayHandle<vtkm::FloatDefault> > coords;
vtkm::cont::ArrayHandle<vtkm::FloatDefault> Xc, Yc, Zc;
this->CopyInto(X, Xc);
this->CopyInto(Y, Yc);
this->CopyInto(Z, Zc);
DataSetBuilderRectilinear::CopyInto(X, Xc);
DataSetBuilderRectilinear::CopyInto(Y, Yc);
DataSetBuilderRectilinear::CopyInto(Z, Zc);
coords = vtkm::cont::make_ArrayHandleCartesianProduct(Xc,Yc,Zc);
vtkm::cont::CoordinateSystem cs(coordNm, 1, coords);

23
vtkm/cont/DataSetBuilderUniform.h
View File

@ -35,36 +35,41 @@ public:
//2D uniform grids.
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const vtkm::Id2 &dimensions,
const vtkm::Vec<vtkm::FloatDefault,2> &origin = vtkm::Vec<vtkm::FloatDefault,2>(0.0f),
const vtkm::Vec<vtkm::FloatDefault,2> &spacing = vtkm::Vec<vtkm::FloatDefault,2>(1.0f),
std::string coordNm="coords", std::string cellNm="cells")
{
return CreateDS(2,
dimensions[0],dimensions[1],1, origin[0],origin[1],0.0f,
spacing[0],spacing[1],1.0f,
coordNm, cellNm);
return DataSetBuilderUniform::CreateDS(2,
dimensions[0],dimensions[1],1,
origin[0],origin[1],0.0f,
spacing[0],spacing[1],1.0f,
coordNm, cellNm);
}
//3D uniform grids.
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
Create(const vtkm::Id3 &dimensions,
const vtkm::Vec<vtkm::FloatDefault,3> &origin = vtkm::Vec<vtkm::FloatDefault,3>(0.0f),
const vtkm::Vec<vtkm::FloatDefault,3> &spacing = vtkm::Vec<vtkm::FloatDefault,3>(1.0f),
std::string coordNm="coords", std::string cellNm="cells")
{
return CreateDS(3,
dimensions[0],dimensions[1],dimensions[2],
origin[0],origin[1],origin[2],
spacing[0],spacing[1],spacing[2],
coordNm, cellNm);
return DataSetBuilderUniform::CreateDS(
3,
dimensions[0],dimensions[1],dimensions[2],
origin[0],origin[1],origin[2],
spacing[0],spacing[1],spacing[2],
coordNm, cellNm);
}
private:
template<typename T>
VTKM_CONT_EXPORT
static
vtkm::cont::DataSet
CreateDS(int dim, vtkm::Id nx, vtkm::Id ny, vtkm::Id nz,
T originX, T originY, T originZ,

63
vtkm/cont/DataSetFieldAdd.h
View File

@ -34,11 +34,22 @@ public:
DataSetFieldAdd() {}
//Point centered fields.
template <typename T, typename Storage>
VTKM_CONT_EXPORT
static
void AddPointField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
vtkm::cont::ArrayHandle<T, Storage> &field)
const vtkm::cont::DynamicArrayHandle &field)
{
dataSet.AddField(Field(fieldName, 1, vtkm::cont::Field::ASSOC_POINTS,
field));
}
template <typename T, typename Storage>
VTKM_CONT_EXPORT
static
void AddPointField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
const vtkm::cont::ArrayHandle<T, Storage> &field)
{
dataSet.AddField(Field(fieldName, 1, vtkm::cont::Field::ASSOC_POINTS,
field));
@ -46,6 +57,7 @@ public:
template<typename T>
VTKM_CONT_EXPORT
static
void AddPointField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
const std::vector<T> &field)
@ -53,9 +65,10 @@ public:
dataSet.AddField(Field(fieldName, 1, vtkm::cont::Field::ASSOC_POINTS,
field));
}
template<typename T>
VTKM_CONT_EXPORT
static
void AddPointField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
const T *field, const vtkm::Id &n)
@ -65,11 +78,23 @@ public:
}
//Cell centered field
template <typename T, typename Storage>
VTKM_CONT_EXPORT
static
void AddCellField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
vtkm::cont::ArrayHandle<T, Storage> &field,
const vtkm::cont::DynamicArrayHandle &field,
const std::string &cellSetName)
{
dataSet.AddField(Field(fieldName, 1, vtkm::cont::Field::ASSOC_CELL_SET,
cellSetName, field));
}
template <typename T, typename Storage>
VTKM_CONT_EXPORT
static
void AddCellField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
const vtkm::cont::ArrayHandle<T, Storage> &field,
const std::string &cellSetName)
{
dataSet.AddField(Field(fieldName, 1, vtkm::cont::Field::ASSOC_CELL_SET,
@ -78,6 +103,7 @@ public:
template<typename T>
VTKM_CONT_EXPORT
static
void AddCellField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
const std::vector<T> &field,
@ -86,9 +112,10 @@ public:
dataSet.AddField(Field(fieldName, 1, vtkm::cont::Field::ASSOC_CELL_SET,
cellSetName, field));
}
template<typename T>
VTKM_CONT_EXPORT
static
void AddCellField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
const T *field, const vtkm::Id &n,
@ -98,19 +125,32 @@ public:
cellSetName, field, n));
}
template <typename T, typename Storage>
VTKM_CONT_EXPORT
static
void AddCellField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
vtkm::cont::ArrayHandle<T, Storage> &field,
const vtkm::cont::DynamicArrayHandle &field,
vtkm::Id cellSetIndex = 0)
{
std::string cellSetName =
dataSet.GetCellSet(cellSetIndex).GetCellSet().GetName();
this->AddCellField(dataSet, fieldName, field, cellSetName);
DataSetFieldAdd::AddCellField(dataSet, fieldName, field, cellSetName);
}
template <typename T, typename Storage>
VTKM_CONT_EXPORT
static
void AddCellField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
const vtkm::cont::ArrayHandle<T, Storage> &field,
vtkm::Id cellSetIndex = 0)
{
std::string cellSetName =
dataSet.GetCellSet(cellSetIndex).GetCellSet().GetName();
DataSetFieldAdd::AddCellField(dataSet, fieldName, field, cellSetName);
}
template<typename T>
VTKM_CONT_EXPORT
static
void AddCellField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
const std::vector<T> &field,
@ -118,11 +158,12 @@ public:
{
std::string cellSetName =
dataSet.GetCellSet(cellSetIndex).GetCellSet().GetName();
this->AddCellField(dataSet, fieldName, field, cellSetName);
DataSetFieldAdd::AddCellField(dataSet, fieldName, field, cellSetName);
}
template<typename T>
VTKM_CONT_EXPORT
static
void AddCellField(vtkm::cont::DataSet &dataSet,
const std::string &fieldName,
const T *field, const vtkm::Id &n,
@ -130,7 +171,7 @@ public:
{
std::string cellSetName =
dataSet.GetCellSet(cellSetIndex).GetCellSet().GetName();
this->AddCellField(dataSet, fieldName, field, n, cellSetName);
DataSetFieldAdd::AddCellField(dataSet, fieldName, field, n, cellSetName);
}

78
vtkm/cont/Field.h
View File

@ -158,10 +158,10 @@ private:
// Special implementation for regular point coordinates, which are easy
// to determine.
void operator()(vtkm::cont::ArrayHandle<
void operator()(const vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault,3>,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag>
array)
&array)
{
vtkm::internal::ArrayPortalUniformPointCoordinates portal =
array.GetPortalConstControl();
@ -327,32 +327,13 @@ public:
this->CopyData(data, nvals);
}
template<typename T>
VTKM_CONT_EXPORT
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
T)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Data(vtkm::cont::ArrayHandle<T>()),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
}
/// constructors for cell set associations
VTKM_CONT_EXPORT
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
const std::string& cellSetName,
vtkm::cont::DynamicArrayHandle &data)
const vtkm::cont::DynamicArrayHandle &data)
: Name(name),
Order(order),
Association(association),
@ -371,7 +352,7 @@ public:
vtkm::IdComponent order,
AssociationEnum association,
const std::string& cellSetName,
vtkm::cont::ArrayHandle<T, Storage> &data)
const vtkm::cont::ArrayHandle<T, Storage> &data)
: Name(name),
Order(order),
Association(association),
@ -423,32 +404,13 @@ public:
this->CopyData(data, nvals);
}
template<typename T>
VTKM_CONT_EXPORT
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
const std::string& cellSetName,
T)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Data(vtkm::cont::ArrayHandle<T>()),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->Association == ASSOC_CELL_SET);
}
/// constructors for logical dimension associations
VTKM_CONT_EXPORT
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
vtkm::IdComponent logicalDim,
vtkm::cont::DynamicArrayHandle &data)
const vtkm::cont::DynamicArrayHandle &data)
: Name(name),
Order(order),
Association(association),
@ -467,7 +429,7 @@ public:
vtkm::IdComponent order,
AssociationEnum association,
vtkm::IdComponent logicalDim,
vtkm::cont::ArrayHandle<T, Storage> &data)
const vtkm::cont::ArrayHandle<T, Storage> &data)
: Name(name),
Order(order),
Association(association),
@ -515,25 +477,6 @@ public:
CopyData(data, nvals);
}
template<typename T>
VTKM_CONT_EXPORT
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
vtkm::IdComponent logicalDim,
T)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(),
AssocLogicalDim(logicalDim),
Data(vtkm::cont::ArrayHandle<T>()),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->Association == ASSOC_LOGICAL_DIM);
}
VTKM_CONT_EXPORT
Field()
: Name(),
@ -659,7 +602,14 @@ public:
template <typename T>
VTKM_CONT_EXPORT
void SetData(vtkm::cont::ArrayHandle<T> &newdata)
void SetData(const vtkm::cont::ArrayHandle<T> &newdata)
{
this->Data = newdata;
this->ModifiedFlag = true;
}
VTKM_CONT_EXPORT
void SetData(const vtkm::cont::DynamicArrayHandle &newdata)
{
this->Data = newdata;
this->ModifiedFlag = true;

3
vtkm/cont/testing/UnitTestDataSetPermutation.cxx
View File

@ -84,8 +84,7 @@ inline vtkm::cont::DataSet make_SingleTypeDataSet()
const int nVerts = 5;
vtkm::Float32 vars[nVerts] = {10.1f, 20.1f, 30.2f, 40.2f, 50.3f};
vtkm::cont::DataSetFieldAdd fieldAdder;
fieldAdder.AddPointField(ds, "pointvar", vars, nVerts);
vtkm::cont::DataSetFieldAdd::AddPointField(ds, "pointvar", vars, nVerts);
return ds;
}

60
vtkm/worklet/testing/UnitTestCellAverage.cxx
View File

@ -37,26 +37,20 @@ void TestCellAverageUniform3D()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
vtkm::cont::Field result("avgvals",
1,
vtkm::cont::Field::ASSOC_CELL_SET,
std::string("cells"),
vtkm::Float32());
vtkm::cont::ArrayHandle<vtkm::Float32> result;
vtkm::worklet::DispatcherMapTopology<vtkm::worklet::CellAverage> dispatcher;
dispatcher.Invoke(dataSet.GetField("pointvar").GetData(),
dataSet.GetCellSet(),
result.GetData());
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetData().CopyTo(resultArrayHandle);
result);
vtkm::Float32 expected[4] = { 60.1875f, 70.2125f, 120.3375f, 130.3625f };
for (int i = 0; i < 4; ++i)
{
VTKM_TEST_ASSERT(test_equal(resultArrayHandle.GetPortalConstControl().Get(i),
expected[i]), "Wrong result for CellAverage worklet on 3D uniform data");
}
{
VTKM_TEST_ASSERT(
test_equal(result.GetPortalConstControl().Get(i), expected[i]),
"Wrong result for CellAverage worklet on 3D uniform data");
}
}
void TestCellAverageUniform2D()
@ -66,26 +60,20 @@ void TestCellAverageUniform2D()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
vtkm::cont::Field result("avgvals",
1,
vtkm::cont::Field::ASSOC_CELL_SET,
std::string("cells"),
vtkm::Float32());
vtkm::cont::ArrayHandle<vtkm::Float32> result;
vtkm::worklet::DispatcherMapTopology<vtkm::worklet::CellAverage> dispatcher;
dispatcher.Invoke(dataSet.GetField("pointvar").GetData(),
dataSet.GetCellSet(),
result.GetData());
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetData().CopyTo(resultArrayHandle);
result);
vtkm::Float32 expected[2] = { 30.1f, 40.1f };
for (int i = 0; i < 2; ++i)
{
VTKM_TEST_ASSERT(test_equal(resultArrayHandle.GetPortalConstControl().Get(i),
expected[i]), "Wrong result for CellAverage worklet on 2D uniform data");
}
{
VTKM_TEST_ASSERT(
test_equal(result.GetPortalConstControl().Get(i), expected[i]),
"Wrong result for CellAverage worklet on 2D uniform data");
}
}
void TestCellAverageExplicit()
@ -95,26 +83,20 @@ void TestCellAverageExplicit()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet0();
vtkm::cont::Field result("avgvals",
1,
vtkm::cont::Field::ASSOC_CELL_SET,
std::string("cells"),
vtkm::Float32());
vtkm::cont::ArrayHandle<vtkm::Float32> result;
vtkm::worklet::DispatcherMapTopology<vtkm::worklet::CellAverage> dispatcher;
dispatcher.Invoke(dataSet.GetField("pointvar").GetData(),
dataSet.GetCellSet(),
result.GetData());
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetData().CopyTo(resultArrayHandle);
result);
vtkm::Float32 expected[2] = { 20.1333f, 35.2f };
for (int i = 0; i < 2; ++i)
{
VTKM_TEST_ASSERT(test_equal(resultArrayHandle.GetPortalConstControl().Get(i),
expected[i]), "Wrong result for CellAverage worklet on 3D explicit data");
}
{
VTKM_TEST_ASSERT(
test_equal(result.GetPortalConstControl().Get(i), expected[i]),
"Wrong result for CellAverage worklet on 3D explicit data");
}
}

14
vtkm/worklet/testing/UnitTestPointElevation.cxx
View File

@ -81,8 +81,7 @@ void TestPointElevation()
vtkm::cont::DataSet dataSet = MakePointElevationTestDataSet();
dataSet.AddField(vtkm::cont::Field("elevation", 1, vtkm::cont::Field::ASSOC_POINTS,
vtkm::Float32()));
vtkm::cont::ArrayHandle<vtkm::Float32> result;
vtkm::worklet::PointElevation pointElevationWorklet;
pointElevationWorklet.SetLowPoint(vtkm::make_Vec<vtkm::Float64>(0.0, 0.0, 0.0));
@ -92,18 +91,17 @@ void TestPointElevation()
vtkm::worklet::DispatcherMapField<vtkm::worklet::PointElevation>
dispatcher(pointElevationWorklet);
dispatcher.Invoke(dataSet.GetCoordinateSystem().GetData(),
dataSet.GetField("elevation").GetData());
result);
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32,3> > coordinates;
dataSet.GetCoordinateSystem().GetData().CopyTo(coordinates);
vtkm::cont::ArrayHandle<vtkm::Float32> result;
dataSet.GetField("elevation").GetData().CopyTo(result);
for (vtkm::Id i = 0; i < result.GetNumberOfValues(); ++i)
{
VTKM_TEST_ASSERT(test_equal(coordinates.GetPortalConstControl().Get(i)[1] * 2.0,
result.GetPortalConstControl().Get(i)),
"Wrong result for PointElevation worklet");
VTKM_TEST_ASSERT(
test_equal(coordinates.GetPortalConstControl().Get(i)[1] * 2.0,
result.GetPortalConstControl().Get(i)),
"Wrong result for PointElevation worklet");
}
}

73
vtkm/worklet/testing/UnitTestWorkletMapTopologyExplicit.cxx
View File

@ -150,35 +150,19 @@ TestMaxPointOrCell()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet0();
//Run a worklet to populate a cell centered field.
//Here, we're filling it with test values.
vtkm::cont::Field f("outcellvar",
0,
vtkm::cont::Field::ASSOC_CELL_SET,
std::string("cells"),
vtkm::Float32());
dataSet.AddField(f);
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 3,
"Incorrect number of fields");
vtkm::cont::ArrayHandle<vtkm::Float32> result;
vtkm::worklet::DispatcherMapTopology< ::test_explicit::MaxPointOrCellValue >
dispatcher;
dispatcher.Invoke(dataSet.GetField("cellvar").GetData(),
dataSet.GetField("pointvar").GetData(),
dataSet.GetCellSet(0),
dataSet.GetField("outcellvar").GetData());
result);
//Make sure we got the right answer.
vtkm::cont::ArrayHandle<vtkm::Float32> res;
dataSet.GetField("outcellvar").GetData().CopyTo(res);
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(0), 100.1f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(0), 100.1f),
"Wrong result for PointToCellMax worklet");
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(1), 100.2f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(1), 100.2f),
"Wrong result for PointToCellMax worklet");
}
@ -190,34 +174,17 @@ TestAvgPointToCell()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet0();
//Run a worklet to populate a cell centered field.
//Here, we're filling it with test values.
vtkm::cont::Field f("outcellvar",
0,
vtkm::cont::Field::ASSOC_CELL_SET,
std::string("cells"),
vtkm::Float32());
dataSet.AddField(f);
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 3,
"Incorrect number of fields");
vtkm::cont::ArrayHandle<vtkm::Float32> result;
vtkm::worklet::DispatcherMapTopology< ::test_explicit::AveragePointToCellValue > dispatcher;
dispatcher.Invoke(dataSet.GetField("pointvar").GetData(),
dataSet.GetCellSet(),
dataSet.GetField("outcellvar").GetData());
result);
//make sure we got the right answer.
vtkm::cont::ArrayHandle<vtkm::Float32> res;
dataSet.GetField("outcellvar").GetData().CopyTo(res);
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(0), 20.1333f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(0), 20.1333f),
"Wrong result for PointToCellAverage worklet");
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(1), 35.2f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(1), 35.2f),
"Wrong result for PointToCellAverage worklet");
}
@ -229,34 +196,18 @@ TestAvgCellToPoint()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet1();
//Run a worklet to populate a point centered field.
//Here, we're filling it with test values.
vtkm::cont::Field f("outpointvar",
1,
vtkm::cont::Field::ASSOC_POINTS,
vtkm::Float32());
dataSet.AddField(f);
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 3,
"Incorrect number of fields");
vtkm::cont::ArrayHandle<vtkm::Float32> result;
vtkm::worklet::DispatcherMapTopology< ::test_explicit::AverageCellToPointValue > dispatcher;
dispatcher.Invoke(dataSet.GetField("cellvar").GetData(),
dataSet.GetCellSet(),
dataSet.GetField("outpointvar").GetData());
result);
//make sure we got the right answer.
vtkm::cont::ArrayHandle<vtkm::Float32> res;
dataSet.GetField("outpointvar").GetData().CopyTo(res);
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(0), 100.1f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(0), 100.1f),
"Wrong result for CellToPointAverage worklet");
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(1), 100.15f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(1), 100.15f),
"Wrong result for CellToPointAverage worklet");
}

71
vtkm/worklet/testing/UnitTestWorkletMapTopologyUniform.cxx
View File

@ -178,21 +178,8 @@ TestMaxPointOrCell()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
//Run a worklet to populate a cell centered field.
//Here, we're filling it with test values.
vtkm::cont::Field f("outcellvar",
1,
vtkm::cont::Field::ASSOC_CELL_SET,
std::string("cells"),
vtkm::Float32());
vtkm::cont::ArrayHandle<vtkm::Float32> result;
dataSet.AddField(f);
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfCellSets(), 1),
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfFields(), 3),
"Incorrect number of fields");
vtkm::worklet::DispatcherMapTopology< ::test_uniform::MaxPointOrCellValue > dispatcher;
dispatcher.Invoke(dataSet.GetField("cellvar").GetData(),
dataSet.GetField("pointvar").GetData(),
@ -202,15 +189,13 @@ TestMaxPointOrCell()
// part more flexible.
dataSet.GetCellSet(0).ResetCellSetList(
vtkm::cont::CellSetListTagStructured2D()),
dataSet.GetField("outcellvar").GetData());
result);
//make sure we got the right answer.
vtkm::cont::ArrayHandle<vtkm::Float32> res;
dataSet.GetField("outcellvar").GetData().CopyTo(res);
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(0), 100.1f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(0), 100.1f),
"Wrong result for MaxPointOrCell worklet");
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(1), 200.1f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(1), 200.1f),
"Wrong result for MaxPointOrCell worklet");
}
@ -221,21 +206,8 @@ TestAvgPointToCell()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
//Run a worklet to populate a cell centered field.
//Here, we're filling it with test values.
vtkm::cont::Field f("outcellvar",
0,
vtkm::cont::Field::ASSOC_CELL_SET,
std::string("cells"),
vtkm::Float32());
vtkm::cont::ArrayHandle<vtkm::Float32> result;
dataSet.AddField(f);
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfCellSets(), 1),
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfFields(), 3),
"Incorrect number of fields");
vtkm::worklet::DispatcherMapTopology< ::test_uniform::AveragePointToCellValue > dispatcher;
dispatcher.Invoke(dataSet.GetField("pointvar").GetData(),
// We know that the cell set is a structured 2D grid and
@ -244,15 +216,12 @@ TestAvgPointToCell()
// part more flexible.
dataSet.GetCellSet(0).ResetCellSetList(
vtkm::cont::CellSetListTagStructured2D()),
dataSet.GetField("outcellvar").GetData());
result);
//make sure we got the right answer.
vtkm::cont::ArrayHandle<vtkm::Float32> res;
dataSet.GetField("outcellvar").GetData().CopyTo(res);
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(0), 30.1f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(0), 30.1f),
"Wrong result for PointToCellAverage worklet");
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(1), 40.1f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(1), 40.1f),
"Wrong result for PointToCellAverage worklet");
}
@ -264,20 +233,7 @@ TestAvgCellToPoint()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
//Run a worklet to populate a point centered field.
//Here, we're filling it with test values.
vtkm::cont::Field f("outpointvar",
1,
vtkm::cont::Field::ASSOC_POINTS,
vtkm::Float32());
dataSet.AddField(f);
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfCellSets(), 1),
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfFields(), 3),
"Incorrect number of fields");
vtkm::cont::ArrayHandle<vtkm::Float32> result;
vtkm::worklet::DispatcherMapTopology< ::test_uniform::AverageCellToPointValue > dispatcher;
dispatcher.Invoke(dataSet.GetField("cellvar").GetData(),
@ -287,15 +243,12 @@ TestAvgCellToPoint()
// part more flexible.
dataSet.GetCellSet(0).ResetCellSetList(
vtkm::cont::CellSetListTagStructured2D()),
dataSet.GetField("outpointvar").GetData());
result);
//make sure we got the right answer.
vtkm::cont::ArrayHandle<vtkm::Float32> res;
dataSet.GetField("outpointvar").GetData().CopyTo(res);
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(0), 100.1f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(0), 100.1f),
"Wrong result for CellToPointAverage worklet");
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(1), 150.1f),
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(1), 150.1f),
"Wrong result for CellToPointAverage worklet");
}