Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 21:33:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Conform DataSet classes to coding practices better

Browse Source 
The most common changes were making class members uppercase and spelled
out, adding "this->" whenever a class member is used, and declare
functions and members with export macros. Also fixed some uses of int
(instead of vtkm::Id or something similar) and a bit of indentation. I
also sprinkled some const goodness over the code.

It should be noted that I had about a week delay between first making
these changes and checking them in. In the mean time Sujin also made
some similar changes, so there might be some repetative changes.
This commit is contained in:
Kenneth Moreland 2015-07-12 18:05:47 +02:00
parent cc43ac349e
commit 19db32f084
11 changed files with 556 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
vtkm/RegularStructure.h
View File

@ -36,21 +36,26 @@ public:
VTKM_EXEC_CONT_EXPORT
void SetNodeDimension(vtkm::Vec<vtkm::Id,1> dims)
{
nodeDim = dims;
this->NodeDimensions = dims;
}
VTKM_EXEC_CONT_EXPORT
vtkm::Vec<vtkm::Id,1> GetNodeDimensions() const { return nodeDim; }
vtkm::Vec<vtkm::Id,1> GetNodeDimensions() const
{ return this->NodeDimensions;
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetSchedulingDimensions() const {return GetNumberOfCells();}
vtkm::Id GetSchedulingDimensions() const
{
return this->GetNumberOfCells();
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfNodes() const {return nodeDim[0];}
vtkm::Id GetNumberOfNodes() const {return this->NodeDimensions[0];}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfElements() const {return GetNumberOfCells();}
vtkm::Id GetNumberOfElements() const {return this->GetNumberOfCells();}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfCells() const {return nodeDim[0]-1;}
vtkm::Id GetNumberOfCells() const {return this->NodeDimensions[0]-1;}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfIndices() const {return 2;}
VTKM_EXEC_CONT_EXPORT
@ -74,19 +79,19 @@ public:
vtkm::IdComponent idx = 0;
if (index > 0)
ids[idx++] = index-1;
if (index < nodeDim[0]-1)
if (index < this->NodeDimensions[0]-1)
ids[idx++] = index;
}
virtual void PrintSummary(std::ostream &out)
virtual void PrintSummary(std::ostream &out) const
{
out<<" RegularConnectivity<1> ";
out<<"nodeDim["<<nodeDim[0]<<"] ";
out<<"this->NodeDimensions["<<this->NodeDimensions[0]<<"] ";
out<<"\n";
}
private:
vtkm::Vec<vtkm::Id,1> nodeDim;
vtkm::Vec<vtkm::Id,1> NodeDimensions;
};
//2 D specialization.
@ -97,28 +102,34 @@ public:
VTKM_EXEC_CONT_EXPORT
void SetNodeDimension(vtkm::Vec<vtkm::Id,2> dims)
{
nodeDims = dims;
cellDims = dims - vtkm::Id2(1);
this->NodeDimensions = dims;
this->CellDimensions = dims - vtkm::Id2(1);
}
VTKM_EXEC_CONT_EXPORT
vtkm::Vec<vtkm::Id,2> GetNodeDimensions() const { return nodeDims; }
vtkm::Vec<vtkm::Id,2> GetNodeDimensions() const { return this->NodeDimensions; }
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfNodes() const {return vtkm::internal::VecProduct<2>()(nodeDims);}
vtkm::Id GetNumberOfNodes() const
{
return vtkm::internal::VecProduct<2>()(this->NodeDimensions);
}
//returns an id2 to signal what kind of scheduling to use
VTKM_EXEC_CONT_EXPORT
vtkm::Id2 GetSchedulingDimensions() const {return cellDims;}
vtkm::Id2 GetSchedulingDimensions() const {return this->CellDimensions;}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfElements() const {return GetNumberOfCells();}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfCells() const {return vtkm::internal::VecProduct<2>()(cellDims);}
vtkm::Id GetNumberOfCells() const
{
return vtkm::internal::VecProduct<2>()(this->CellDimensions);
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfIndices() const {return 4;}
vtkm::Id GetNumberOfIndices() const { return 4; }
VTKM_EXEC_CONT_EXPORT
vtkm::CellType GetElementShapeType() const {return VTKM_PIXEL;}
vtkm::CellType GetElementShapeType() const { return VTKM_PIXEL; }
template <int IdsLength>
VTKM_EXEC_CONT_EXPORT
@ -129,9 +140,9 @@ public:
vtkm::Id i, j;
CalculateLogicalNodeIndices(index, i, j);
ids[0] = j*nodeDims[0] + i;
ids[0] = j*this->NodeDimensions[0] + i;
ids[1] = ids[0] + 1;
ids[2] = ids[0] + nodeDims[0];
ids[2] = ids[0] + this->NodeDimensions[0];
ids[3] = ids[2] + 1;
}
@ -145,39 +156,47 @@ public:
vtkm::Id i, j;
vtkm::IdComponent idx = 0;
CalculateLogicalNodeIndices(index, i, j);
if (i > 0 && j > 0)
ids[idx++] = CalculateCellIndex(i-1, j-1);
if (i < nodeDims[0]-1 && j > 0)
ids[idx++] = CalculateCellIndex(i , j-1);
if (i > 0 && j < nodeDims[1]-1)
ids[idx++] = CalculateCellIndex(i-1, j );
if (i < nodeDims[0]-1 && j < nodeDims[1]-1)
ids[idx++] = CalculateCellIndex(i , j );
if ((i > 0) && (j > 0))
{
ids[idx++] = this->CalculateCellIndex(i-1, j-1);
}
if ((i < this->NodeDimensions[0]-1) && (j > 0))
{
ids[idx++] = this->CalculateCellIndex(i , j-1);
}
if ((i > 0) && (j < this->NodeDimensions[1]-1))
{
ids[idx++] = this->CalculateCellIndex(i-1, j );
}
if ((i < this->NodeDimensions[0]-1) && (j < this->NodeDimensions[1]-1))
{
ids[idx++] = this->CalculateCellIndex(i , j );
}
}
virtual void PrintSummary(std::ostream &out)
virtual void PrintSummary(std::ostream &out) const
{
out<<" RegularConnectivity<2> ";
out<<"cellDim["<<cellDims[0]<<" "<<cellDims[1]<<"] ";
out<<"nodeDim["<<nodeDims[0]<<" "<<nodeDims[1]<<"] ";
out<<"\n";
out<<"cellDim["<<this->CellDimensions[0]<<" "<<this->CellDimensions[1]<<"] ";
out<<"nodeDim["<<this->NodeDimensions[0]<<" "<<this->NodeDimensions[1]<<"] ";
out<<std::endl;
}
private:
vtkm::Id2 cellDims;
vtkm::Id2 nodeDims;
vtkm::Id2 CellDimensions;
vtkm::Id2 NodeDimensions;
private:
VTKM_EXEC_CONT_EXPORT
void CalculateLogicalNodeIndices(vtkm::Id index, vtkm::Id &i, vtkm::Id &j) const
{
i = index % cellDims[0];
j = index / cellDims[0];
i = index % this->CellDimensions[0];
j = index / this->CellDimensions[0];
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id CalculateCellIndex(vtkm::Id i, vtkm::Id j) const
{
return j*cellDims[0] + i;
return j*this->CellDimensions[0] + i;
}
};
@ -189,27 +208,36 @@ public:
VTKM_EXEC_CONT_EXPORT
void SetNodeDimension(vtkm::Vec<vtkm::Id,3> dims)
{
nodeDims = dims;
cellDims = dims - vtkm::Id3(1);
this->NodeDimensions = dims;
this->CellDimensions = dims - vtkm::Id3(1);
}
VTKM_EXEC_CONT_EXPORT
vtkm::Vec<vtkm::Id,3> GetNodeDimensions() const { return nodeDims; }
vtkm::Vec<vtkm::Id,3> GetNodeDimensions() const
{
return this->NodeDimensions;
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfNodes() const {return vtkm::internal::VecProduct<3>()(nodeDims);}
vtkm::Id GetNumberOfNodes() const
{
return vtkm::internal::VecProduct<3>()(this->NodeDimensions);
}
//returns an id3 to signal what kind of scheduling to use
VTKM_EXEC_CONT_EXPORT
vtkm::Id3 GetSchedulingDimensions() const { return cellDims;}
vtkm::Id3 GetSchedulingDimensions() const { return this->CellDimensions;}
vtkm::Id GetNumberOfElements() const {return GetNumberOfCells();}
vtkm::Id GetNumberOfElements() const { return this->GetNumberOfCells(); }
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfCells() const {return vtkm::internal::VecProduct<3>()(cellDims);}
vtkm::Id GetNumberOfCells() const
{
return vtkm::internal::VecProduct<3>()(this->CellDimensions);
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfIndices() const {return 8;}
vtkm::Id GetNumberOfIndices() const { return 8; }
VTKM_EXEC_CONT_EXPORT
vtkm::CellType GetElementShapeType() const {return VTKM_VOXEL;}
vtkm::CellType GetElementShapeType() const { return VTKM_VOXEL; }
template <int IdsLength>
VTKM_EXEC_CONT_EXPORT
@ -217,19 +245,19 @@ public:
{
BOOST_STATIC_ASSERT(IdsLength >= 8);
vtkm::Id cellDims01 = cellDims[0] * cellDims[1];
vtkm::Id cellDims01 = this->CellDimensions[0] * this->CellDimensions[1];
vtkm::Id k = index / cellDims01;
vtkm::Id indexij = index % cellDims01;
vtkm::Id j = indexij / cellDims[0];
vtkm::Id i = indexij % cellDims[0];
vtkm::Id j = indexij / this->CellDimensions[0];
vtkm::Id i = indexij % this->CellDimensions[0];
ids[0] = (k * nodeDims[1] + j) * nodeDims[0] + i;
ids[0] = (k * this->NodeDimensions[1] + j) * this->NodeDimensions[0] + i;
ids[1] = ids[0] + 1;
ids[2] = ids[0] + nodeDims[0];
ids[2] = ids[0] + this->NodeDimensions[0];
ids[3] = ids[2] + 1;
ids[4] = ids[0] + nodeDims[0]*nodeDims[1];
ids[4] = ids[0] + this->NodeDimensions[0]*this->NodeDimensions[1];
ids[5] = ids[4] + 1;
ids[6] = ids[4] + nodeDims[0];
ids[6] = ids[4] + this->NodeDimensions[0];
ids[7] = ids[6] + 1;
}
@ -245,53 +273,77 @@ public:
vtkm::IdComponent idx=0;
CalculateLogicalNodeIndices(index, i, j, k);
if (i > 0 && j > 0 && k > 0)
ids[idx++] = CalculateCellIndex(i-1, j-1, k-1);
if (i < nodeDims[0]-1 && j > 0 && k > 0)
ids[idx++] = CalculateCellIndex(i , j-1, k-1);
if (i > 0 && j < nodeDims[1]-1 && k > 0)
ids[idx++] = CalculateCellIndex(i-1, j , k-1);
if (i < nodeDims[0]-1 && j < nodeDims[1]-1 && k > 0)
ids[idx++] = CalculateCellIndex(i , j , k-1);
if ((i > 0) && (j > 0) && (k > 0))
{
ids[idx++] = this->CalculateCellIndex(i-1, j-1, k-1);
}
if ((i < this->NodeDimensions[0]-1) && (j > 0) && (k > 0))
{
ids[idx++] = this->CalculateCellIndex(i , j-1, k-1);
}
if ((i > 0) && (j < this->NodeDimensions[1]-1) && (k > 0))
{
ids[idx++] = this->CalculateCellIndex(i-1, j , k-1);
}
if ((i < this->NodeDimensions[0]-1) &&
(j < this->NodeDimensions[1]-1) &&
(k > 0))
{
ids[idx++] = this->CalculateCellIndex(i , j , k-1);
}
if (i > 0 && j > 0 && k < nodeDims[2]-1)
ids[idx++] = CalculateCellIndex(i-1, j-1, k);
if (i < nodeDims[0]-1 && j > 0 && k < nodeDims[2]-1)
ids[idx++] = CalculateCellIndex(i , j-1, k);
if (i > 0 && j < nodeDims[1]-1 && k < nodeDims[2]-1)
ids[idx++] = CalculateCellIndex(i-1, j , k);
if (i < nodeDims[0]-1 && j < nodeDims[1]-1 && k < nodeDims[2]-1)
ids[idx++] = CalculateCellIndex(i , j , k);
if ((i > 0) && (j > 0) && (k < this->NodeDimensions[2]-1))
{
ids[idx++] = this->CalculateCellIndex(i-1, j-1, k);
}
if ((i < this->NodeDimensions[0]-1) &&
(j > 0) &&
(k < this->NodeDimensions[2]-1))
{
ids[idx++] = this->CalculateCellIndex(i , j-1, k);
}
if ((i > 0) &&
(j < this->NodeDimensions[1]-1) &&
(k < this->NodeDimensions[2]-1))
{
ids[idx++] = this->CalculateCellIndex(i-1, j , k);
}
if ((i < this->NodeDimensions[0]-1) &&
(j < this->NodeDimensions[1]-1) &&
(k < this->NodeDimensions[2]-1))
{
ids[idx++] = this->CalculateCellIndex(i , j , k);
}
}
virtual void PrintSummary(std::ostream &out)
virtual void PrintSummary(std::ostream &out) const
{
out<<" RegularConnectivity<3> ";
out<<"cellDim["<<cellDims[0]<<" "<<cellDims[1]<<" "<<cellDims[2]<<"] ";
out<<"nodeDim["<<nodeDims[0]<<" "<<nodeDims[1]<<" "<<nodeDims[2]<<"] ";
out<<"\n";
out<<"cellDim["<<this->CellDimensions[0]<<" "<<this->CellDimensions[1]<<" "<<this->CellDimensions[2]<<"] ";
out<<"nodeDim["<<this->NodeDimensions[0]<<" "<<this->NodeDimensions[1]<<" "<<this->NodeDimensions[2]<<"] ";
out<<std::endl;
}
private:
vtkm::Id3 cellDims;
vtkm::Id3 nodeDims;
vtkm::Id3 CellDimensions;
vtkm::Id3 NodeDimensions;
private:
VTKM_EXEC_CONT_EXPORT
void CalculateLogicalNodeIndices(vtkm::Id index, vtkm::Id &i, vtkm::Id &j, vtkm::Id &k) const
{
vtkm::Id nodeDims01 = nodeDims[0] * nodeDims[1];
vtkm::Id nodeDims01 = this->NodeDimensions[0] * this->NodeDimensions[1];
k = index / nodeDims01;
vtkm::Id indexij = index % nodeDims01;
j = indexij / nodeDims[0];
i = indexij % nodeDims[0];
j = indexij / this->NodeDimensions[0];
i = indexij % this->NodeDimensions[0];
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id CalculateCellIndex(vtkm::Id i, vtkm::Id j, vtkm::Id k) const
{
return (k * cellDims[1] + j) * cellDims[0] + i;
return (k * this->CellDimensions[1] + j) * this->CellDimensions[0] + i;
}
};

27
vtkm/cont/CellSet.h
View File

@ -33,8 +33,9 @@ namespace cont {
class CellSet
{
public:
CellSet(const std::string &n, vtkm::Id d)
: name(n), dimensionality(d), logicalStructure()
VTKM_CONT_EXPORT
CellSet(const std::string &name, vtkm::IdComponent dimensionality)
: Name(name), Dimensionality(dimensionality), LogicalStructure()
{
}
@ -42,33 +43,33 @@ public:
{
}
virtual std::string GetName()
virtual std::string GetName() const
{
return name;
return this->Name;
}
virtual vtkm::Id GetDimensionality()
virtual vtkm::IdComponent GetDimensionality() const
{
return dimensionality;
return this->Dimensionality;
}
virtual vtkm::Id GetNumCells() = 0;
virtual vtkm::Id GetNumCells() const = 0;
virtual vtkm::Id GetNumFaces()
virtual vtkm::Id GetNumFaces() const
{
return 0;
}
virtual vtkm::Id GetNumEdges()
virtual vtkm::Id GetNumEdges() const
{
return 0;
}
virtual void PrintSummary(std::ostream&) = 0;
virtual void PrintSummary(std::ostream&) const = 0;
protected:
std::string name;
vtkm::Id dimensionality;
vtkm::cont::LogicalStructure logicalStructure;
std::string Name;
vtkm::IdComponent Dimensionality;
vtkm::cont::LogicalStructure LogicalStructure;
};
}

20
vtkm/cont/CellSetExplicit.h
View File

@ -37,29 +37,31 @@ public:
ConnectivityStorageTag
> ExplicitConnectivityType;
CellSetExplicit(const std::string &n, vtkm::Id d)
: CellSet(n,d)
VTKM_CONT_EXPORT
CellSetExplicit(const std::string &name, vtkm::IdComponent dimensionality)
: CellSet(name, dimensionality)
{
}
virtual vtkm::Id GetNumCells()
virtual vtkm::Id GetNumCells() const
{
return nodesOfCellsConnectivity.GetNumberOfElements();
return this->NodesOfCellsConnectivity.GetNumberOfElements();
}
ExplicitConnectivityType &GetNodeToCellConnectivity()
{
return nodesOfCellsConnectivity;
return this->NodesOfCellsConnectivity;
}
virtual void PrintSummary(std::ostream &out)
virtual void PrintSummary(std::ostream &out) const
{
out<<" ExplicitCellSet: "<<name<<" dim= "<<dimensionality<<std::endl;
nodesOfCellsConnectivity.PrintSummary(out);
out << " ExplicitCellSet: " << this->Name
<< " dim= " << this->Dimensionality << std::endl;
this->NodesOfCellsConnectivity.PrintSummary(out);
}
public:
ExplicitConnectivityType nodesOfCellsConnectivity;
ExplicitConnectivityType NodesOfCellsConnectivity;
};
}

28
vtkm/cont/CellSetStructured.h
View File

@ -35,43 +35,47 @@ class CellSetStructured : public CellSet
public:
static const int Dimension=DIMENSION;
CellSetStructured(const std::string &n)
: CellSet(n,Dimension)
VTKM_CONT_EXPORT
CellSetStructured(const std::string &name)
: CellSet(name,Dimension)
{
}
virtual vtkm::Id GetNumCells()
virtual vtkm::Id GetNumCells() const
{
return structure.GetNumberOfCells();
return this->Structure.GetNumberOfCells();
}
VTKM_CONT_EXPORT
vtkm::RegularConnectivity<vtkm::cont::NODE,vtkm::cont::CELL,Dimension>
GetNodeToCellConnectivity()
GetNodeToCellConnectivity() const
{
typedef vtkm::RegularConnectivity<vtkm::cont::NODE,
vtkm::cont::CELL,
Dimension> NodeToCellConnectivity;
return NodeToCellConnectivity(structure);
return NodeToCellConnectivity(this->Structure);
}
VTKM_CONT_EXPORT
vtkm::RegularConnectivity<vtkm::cont::CELL,vtkm::cont::NODE,Dimension>
GetCellToNodeConnectivity()
GetCellToNodeConnectivity() const
{
typedef vtkm::RegularConnectivity<vtkm::cont::CELL,
vtkm::cont::NODE,
Dimension> CellToNodeConnectivity;
return CellToNodeConnectivity(structure);
return CellToNodeConnectivity(this->Structure);
}
virtual void PrintSummary(std::ostream &out)
virtual void PrintSummary(std::ostream &out) const
{
out<<" StructuredCellSet: "<<name<<" dim= "<<dimensionality<<std::endl;
structure.PrintSummary(out);
out << " StructuredCellSet: " << this->GetName()
<< " dim= " << this->GetDimensionality() << std::endl;
this->Structure.PrintSummary(out);
}
public:
vtkm::RegularStructure<Dimension> structure;
vtkm::RegularStructure<Dimension> Structure;
};

82
vtkm/cont/CoordinateSystem.h
View File

@ -30,52 +30,60 @@ namespace cont {
class CoordinateSystem
{
public:
struct CoordinateAxis
public:
struct CoordinateAxis
{
std::string FieldName;
vtkm::IdComponent FieldComponent;
VTKM_CONT_EXPORT
CoordinateAxis(const std::string &name,
vtkm::IdComponent componentIndex = 0)
: FieldName(name), FieldComponent(componentIndex)
{
std::string FieldName;
vtkm::IdComponent FieldComponent;
CoordinateAxis(const std::string &n,
vtkm::IdComponent c = 0)
: FieldName(n), FieldComponent(c)
{
}
};
CoordinateSystem(std::string nx,
std::string ny,
std::string nz)
{
axes.push_back(CoordinateAxis(nx));
axes.push_back(CoordinateAxis(ny));
axes.push_back(CoordinateAxis(nz));
}
};
CoordinateSystem(std::string nx,
std::string ny)
{
axes.push_back(CoordinateAxis(nx));
axes.push_back(CoordinateAxis(ny));
}
VTKM_CONT_EXPORT
CoordinateSystem(std::string nx,
std::string ny,
std::string nz)
{
this->Axes.push_back(CoordinateAxis(nx));
this->Axes.push_back(CoordinateAxis(ny));
this->Axes.push_back(CoordinateAxis(nz));
}
CoordinateSystem(std::string nx)
{
axes.push_back(CoordinateAxis(nx));
}
VTKM_CONT_EXPORT
CoordinateSystem(std::string nx,
std::string ny)
{
this->Axes.push_back(CoordinateAxis(nx));
this->Axes.push_back(CoordinateAxis(ny));
}
void PrintSummary(std::ostream &out)
VTKM_CONT_EXPORT
CoordinateSystem(std::string nx)
{
this->Axes.push_back(CoordinateAxis(nx));
}
VTKM_CONT_EXPORT
void PrintSummary(std::ostream &out) const
{
out<<" {";
for (std::size_t i = 0; i < this->Axes.size(); i++)
{
out<<" {";
for (std::size_t i = 0; i < axes.size(); i++)
{
out<<axes[i].FieldName<<"["<<axes[i].FieldComponent<<"]";
if (i < axes.size()-1) out<<", ";
}
out<<"}\n";
out<<this->Axes[i].FieldName<<"["<<this->Axes[i].FieldComponent<<"]";
if (i < this->Axes.size()-1)
{
out<<", ";
}
}
out<<"}\n";
}
private:
std::vector<CoordinateAxis> axes;
std::vector<CoordinateAxis> Axes;
};
} // namespace cont

68
vtkm/cont/DataSet.h
View File

@ -38,81 +38,93 @@
namespace vtkm {
namespace cont {
class CellSet;
class DataSet
{
public:
VTKM_CONT_EXPORT
DataSet()
{
}
void AddField(Field f)
VTKM_CONT_EXPORT
void AddField(Field field)
{
Fields.push_back(f);
this->Fields.push_back(field);
}
vtkm::cont::Field &GetField(vtkm::Id index)
VTKM_CONT_EXPORT
const vtkm::cont::Field &GetField(vtkm::Id index) const
{
VTKM_ASSERT_CONT(index >= 0 && index <= static_cast<vtkm::Id>(Fields.size()));
return Fields[static_cast<std::size_t>(index)];
VTKM_ASSERT_CONT((index >= 0) &&
(index <= static_cast<vtkm::Id>(this->Fields.size())));
return this->Fields[static_cast<std::size_t>(index)];
}
vtkm::cont::Field &GetField(const std::string &n)
VTKM_CONT_EXPORT
const vtkm::cont::Field &GetField(const std::string &name) const
{
for (unsigned int i=0; i<Fields.size(); ++i)
for (std::size_t i=0; i < this->Fields.size(); ++i)
{
if (Fields[i].GetName() == n)
return Fields[i];
if (this->Fields[i].GetName() == name)
{
return this->Fields[i];
}
}
throw vtkm::cont::ErrorControlBadValue("No field with requested name");
}
boost::shared_ptr<vtkm::cont::CellSet> GetCellSet(vtkm::Id index=0)
VTKM_CONT_EXPORT
boost::shared_ptr<vtkm::cont::CellSet> GetCellSet(vtkm::Id index=0) const
{
VTKM_ASSERT_CONT(index >= 0 && index <= static_cast<vtkm::Id>(CellSets.size()));
return CellSets[static_cast<std::size_t>(index)];
VTKM_ASSERT_CONT((index >= 0) &&
(index <= static_cast<vtkm::Id>(this->CellSets.size())));
return this->CellSets[static_cast<std::size_t>(index)];
}
VTKM_CONT_EXPORT
void AddCoordinateSystem(vtkm::cont::CoordinateSystem cs)
{
CoordSystems.push_back(cs);
this->CoordSystems.push_back(cs);
}
VTKM_CONT_EXPORT
void AddCellSet(boost::shared_ptr<vtkm::cont::CellSet> cs)
{
CellSets.push_back(cs);
this->CellSets.push_back(cs);
}
vtkm::Id GetNumberOfCellSets()
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfCellSets() const
{
return static_cast<vtkm::Id>(this->CellSets.size());
}
vtkm::Id GetNumberOfFields()
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfFields() const
{
return static_cast<vtkm::Id>(this->Fields.size());
}
void PrintSummary(std::ostream &out)
VTKM_CONT_EXPORT
void PrintSummary(std::ostream &out) const
{
out<<"DataSet:\n";
out<<" CoordSystems["<<CoordSystems.size()<<"]\n";
for (std::size_t i = 0; i < CoordSystems.size(); i++)
out<<" CoordSystems["<<this->CoordSystems.size()<<"]\n";
for (std::size_t i = 0; i < this->CoordSystems.size(); i++)
{
CoordSystems[i].PrintSummary(out);
this->CoordSystems[i].PrintSummary(out);
}
out<<" CellSets["<<GetNumberOfCellSets()<<"]\n";
for (vtkm::Id i = 0; i < GetNumberOfCellSets(); i++)
out<<" CellSets["<<this->GetNumberOfCellSets()<<"]\n";
for (vtkm::Id i = 0; i < this->GetNumberOfCellSets(); i++)
{
GetCellSet(i)->PrintSummary(out);
this->GetCellSet(i)->PrintSummary(out);
}
out<<" Fields["<<GetNumberOfFields()<<"]\n";
for (vtkm::Id i = 0; i < GetNumberOfFields(); i++)
out<<" Fields["<<this->GetNumberOfFields()<<"]\n";
for (vtkm::Id i = 0; i < this->GetNumberOfFields(); i++)
{
GetField(i).PrintSummary(out);
this->GetField(i).PrintSummary(out);
}
}

114
vtkm/cont/ExplicitConnectivity.h
View File

@ -40,66 +40,72 @@ public:
VTKM_CONT_EXPORT
ExplicitConnectivity()
{
NumShapes = 0;
ConnectivityLength = 0;
this->NumShapes = 0;
this->ConnectivityLength = 0;
}
VTKM_CONT_EXPORT
vtkm::Id GetSchedulingDimensions() const
{
return Shapes.GetNumberOfValues();
return this->Shapes.GetNumberOfValues();
}
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfElements() const
{
return Shapes.GetNumberOfValues();
return this->Shapes.GetNumberOfValues();
}
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfIndices(vtkm::Id index)
vtkm::Id GetNumberOfIndices(vtkm::Id index) const
{
return NumIndices.GetPortalControl().Get(index);
return this->NumIndices.GetPortalControl().Get(index);
}
VTKM_CONT_EXPORT
vtkm::Id GetElementShapeType(vtkm::Id index)
vtkm::Id GetElementShapeType(vtkm::Id index) const
{
return Shapes.GetPortalControl().Get(index);
return this->Shapes.GetPortalControl().Get(index);
}
template <vtkm::IdComponent ItemTupleLength>
VTKM_CONT_EXPORT
void GetIndices(vtkm::Id index, vtkm::Vec<vtkm::Id,ItemTupleLength> &ids)
void GetIndices(vtkm::Id index,
vtkm::Vec<vtkm::Id,ItemTupleLength> &ids) const
{
vtkm::Id n = GetNumberOfIndices(index);
vtkm::Id start = MapCellToConnectivityIndex.GetPortalControl().Get(index);
for (vtkm::IdComponent i=0; i<n && i<ItemTupleLength; i++)
ids[i] = Connectivity.GetPortalControl().Get(start+i);
vtkm::Id numIndices = this->GetNumberOfIndices(index);
vtkm::Id start =
this->MapCellToConnectivityIndex.GetPortalControl().Get(index);
for (vtkm::IdComponent i=0; i<numIndices && i<ItemTupleLength; i++)
ids[i] = this->Connectivity.GetPortalControl().Get(start+i);
}
/// First method to add cells -- one at a time.
VTKM_CONT_EXPORT
void PrepareToAddCells(vtkm::Id numShapes, vtkm::Id connectivityMaxLen)
{
Shapes.Allocate(numShapes);
NumIndices.Allocate(numShapes);
Connectivity.Allocate(connectivityMaxLen);
MapCellToConnectivityIndex.Allocate(numShapes);
NumShapes = 0;
ConnectivityLength = 0;
this->Shapes.Allocate(numShapes);
this->NumIndices.Allocate(numShapes);
this->Connectivity.Allocate(connectivityMaxLen);
this->MapCellToConnectivityIndex.Allocate(numShapes);
this->NumShapes = 0;
this->ConnectivityLength = 0;
}
template <vtkm::IdComponent ItemTupleLength>
VTKM_CONT_EXPORT
void AddCell(vtkm::CellType cellType, int numVertices,
const vtkm::Vec<vtkm::Id,ItemTupleLength> &ids)
void AddCell(vtkm::CellType cellType,
int numVertices,
const vtkm::Vec<vtkm::Id,ItemTupleLength> &ids)
{
Shapes.GetPortalControl().Set(NumShapes, cellType);
NumIndices.GetPortalControl().Set(NumShapes, numVertices);
for (int i=0; i < numVertices; ++i)
Connectivity.GetPortalControl().Set(ConnectivityLength+i,ids[i]);
MapCellToConnectivityIndex.GetPortalControl().Set(NumShapes,
ConnectivityLength);
NumShapes++;
ConnectivityLength += numVertices;
this->Shapes.GetPortalControl().Set(this->NumShapes, cellType);
this->NumIndices.GetPortalControl().Set(this->NumShapes, numVertices);
for (vtkm::IdComponent i=0; i < numVertices; ++i)
{
this->Connectivity.GetPortalControl().Set(
this->ConnectivityLength+i,ids[i]);
}
this->MapCellToConnectivityIndex.GetPortalControl().Set(
this->NumShapes, this->ConnectivityLength);
this->NumShapes++;
this->ConnectivityLength += numVertices;
}
VTKM_CONT_EXPORT
@ -132,12 +138,12 @@ public:
this->ConnectivityLength = this->Connectivity.GetNumberOfValues();
// allocate and build reverse index
MapCellToConnectivityIndex.Allocate(NumShapes);
this->MapCellToConnectivityIndex.Allocate(NumShapes);
vtkm::Id counter = 0;
for (vtkm::Id i=0; i<NumShapes; ++i)
for (vtkm::Id i=0; i<this->NumShapes; ++i)
{
MapCellToConnectivityIndex.GetPortalControl().Set(i, counter);
counter += NumIndices.GetPortalControl().Get(i);
this->MapCellToConnectivityIndex.GetPortalControl().Set(i, counter);
counter += this->NumIndices.GetPortalControl().Get(i);
}
}
@ -156,11 +162,11 @@ public:
this->ConnectivityLength = this->Connectivity.GetNumberOfValues();
// allocate and build reverse index
MapCellToConnectivityIndex.Allocate(this->NumShapes);
this->MapCellToConnectivityIndex.Allocate(this->NumShapes);
vtkm::Id counter = 0;
for (vtkm::Id i=0; i<this->NumShapes; ++i)
{
MapCellToConnectivityIndex.GetPortalControl().Set(i, counter);
this->MapCellToConnectivityIndex.GetPortalControl().Set(i, counter);
counter += this->NumIndices.GetPortalConstControl().Get(i);
}
}
@ -197,24 +203,38 @@ public:
}
VTKM_CONT_EXPORT
virtual void PrintSummary(std::ostream &out)
virtual void PrintSummary(std::ostream &out) const
{
out<<" ExplicitConnectivity: #shapes= "<<NumShapes<<" #connectivity= "<<ConnectivityLength<<"\n";
out<<" Shapes: ";
out << " ExplicitConnectivity: #shapes= " << this->NumShapes
<< " #connectivity= " << ConnectivityLength << std::endl;
out <<" Shapes: ";
printSummary_ArrayHandle(Shapes, out);
out<<"\n";
out<<" NumIndices: ";
out << std::endl;
out << " NumIndices: ";
printSummary_ArrayHandle(NumIndices, out);
out<<"\n";
out<<" Connectivity: ";
out << std::endl;
out << " Connectivity: ";
printSummary_ArrayHandle(Connectivity, out);
out<<"\n";
out << std::endl;
}
vtkm::cont::ArrayHandle<vtkm::Id, ShapeStorageTag> &GetShapesArray() { return Shapes; }
vtkm::cont::ArrayHandle<vtkm::Id, ShapeStorageTag> &GetNumIndicesArray() { return NumIndices; }
vtkm::cont::ArrayHandle<vtkm::Id, ShapeStorageTag> &GetConnectivityArray() { return Connectivity; }
vtkm::cont::ArrayHandle<vtkm::Id, ShapeStorageTag> &GetCellToConnectivityIndexArray() { return MapCellToConnectivityIndex; }
VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<vtkm::Id, ShapeStorageTag> &
GetShapesArray() const { return this->Shapes; }
VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<vtkm::Id, ShapeStorageTag> &
GetNumIndicesArray() const { return this->NumIndices; }
VTKM_CONT_EXPORT
const vtkm::cont::ArrayHandle<vtkm::Id, ShapeStorageTag> &
GetConnectivityArray() const { return this->Connectivity; }
VTKM_CONT_EXPORT
const vtkm::cont::ArrayHandle<vtkm::Id, ShapeStorageTag> &
GetCellToConnectivityIndexArray() const {
return this->MapCellToConnectivityIndex;
}
private:
vtkm::Id ConnectivityLength;

330
vtkm/cont/Field.h
View File

@ -203,176 +203,278 @@ class Field
{
public:
enum Association
{
ASSOC_WHOLE_MESH,
ASSOC_POINTS,
ASSOC_CELL_SET,
ASSOC_LOGICAL_DIM
};
enum AssociationEnum
{
ASSOC_WHOLE_MESH,
ASSOC_POINTS,
ASSOC_CELL_SET,
ASSOC_LOGICAL_DIM
};
/// constructors for points / whole mesh
template<typename T, typename Storage>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association,
vtkm::cont::DynamicArrayHandle &data)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(),
AssocLogicalDim(-1), Data(data), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
ArrayHandle<T, Storage> &data)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Data(data),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_WHOLE_MESH ||
this->AssocTag == ASSOC_POINTS);
VTKM_ASSERT_CONT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
}
template <typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association, ArrayHandle<T> &data)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(),
AssocLogicalDim(-1), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
const std::vector<T> &data)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_WHOLE_MESH ||
this->AssocTag == ASSOC_POINTS);
this->SetData(data);
VTKM_ASSERT_CONT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
this->CopyData(&data[0], static_cast<vtkm::Id>(data.size()));
}
template <typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association,
const std::vector<T> &data)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(),
AssocLogicalDim(-1), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
const T *data,
vtkm::Id nvals)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_WHOLE_MESH ||
this->AssocTag == ASSOC_POINTS);
this->CopyData(&data[0], data.size());
}
template <typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association, const T *data,
vtkm::Id nvals)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(),
AssocLogicalDim(-1), Bounds(), ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_WHOLE_MESH ||
this->AssocTag == ASSOC_POINTS);
VTKM_ASSERT_CONT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
this->CopyData(data, nvals);
}
template<typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association, T)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(),
AssocLogicalDim(-1), Data(vtkm::cont::ArrayHandle<T>()), Bounds(),
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->AssocTag == ASSOC_WHOLE_MESH ||
this->AssocTag == ASSOC_POINTS);
VTKM_ASSERT_CONT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
}
/// constructors for cell set associations
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association,
const std::string& cellSetName, vtkm::cont::DynamicArrayHandle &data)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(cellSetName),
AssocLogicalDim(-1), Data(data), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
const std::string& cellSetName,
vtkm::cont::DynamicArrayHandle &data)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Data(data),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_CELL_SET);
VTKM_ASSERT_CONT(this->Association == ASSOC_CELL_SET);
}
template <typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association,
const std::string& cellSetName, ArrayHandle<T> &data)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(cellSetName),
AssocLogicalDim(-1), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
const std::string& cellSetName,
vtkm::cont::ArrayHandle<T> &data)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Data(data),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_CELL_SET);
this->SetData(data);
VTKM_ASSERT_CONT(this->Association == ASSOC_CELL_SET);
}
template <typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association,
const std::string& cellSetName, const std::vector<T> &data)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(cellSetName),
AssocLogicalDim(-1), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
const std::string& cellSetName,
const std::vector<T> &data)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_CELL_SET);
this->CopyData(&data[0], data.size());
VTKM_ASSERT_CONT(this->Association == ASSOC_CELL_SET);
this->CopyData(&data[0], static_cast<vtkm::Id>(data.size()));
}
template <typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association,
const std::string& cellSetName, const T *data, vtkm::Id nvals)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(cellSetName),
AssocLogicalDim(-1), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
const std::string& cellSetName,
const T *data,
vtkm::Id nvals)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_CELL_SET);
VTKM_ASSERT_CONT(this->Association == ASSOC_CELL_SET);
this->CopyData(data, nvals);
}
template<typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association,
const std::string& cellSetName, T)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(cellSetName),
AssocLogicalDim(-1), Data(vtkm::cont::ArrayHandle<T>()), Bounds(),
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->AssocTag == ASSOC_CELL_SET);
VTKM_ASSERT_CONT(this->Association == ASSOC_CELL_SET);
}
/// constructors for logical dimension associations
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association, int logicalDim,
vtkm::cont::DynamicArrayHandle &data)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(),
AssocLogicalDim(logicalDim), Data(data), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
vtkm::IdComponent logicalDim,
vtkm::cont::DynamicArrayHandle &data)
: Name(name),
Order(order),
Association(association),
AssocCellSetName(),
AssocLogicalDim(logicalDim),
Data(data),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_LOGICAL_DIM);
VTKM_ASSERT_CONT(this->Association == ASSOC_LOGICAL_DIM);
}
template <typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association, int logicalDim,
ArrayHandle<T> &data)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(),
AssocLogicalDim(logicalDim), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
vtkm::IdComponent logicalDim,
vtkm::cont::ArrayHandle<T> &data)
: Name(name),
Order(order),
Association(association),
AssocLogicalDim(logicalDim),
Data(data),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_LOGICAL_DIM);
this->SetData(data);
VTKM_ASSERT_CONT(this->Association == ASSOC_LOGICAL_DIM);
}
template <typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association, int logicalDim,
const std::vector<T> &data)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(),
AssocLogicalDim(logicalDim), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
vtkm::IdComponent logicalDim,
const std::vector<T> &data)
: Name(name),
Order(order),
Association(association),
AssocLogicalDim(logicalDim),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_LOGICAL_DIM);
this->CopyData(&data[0], data.size());
VTKM_ASSERT_CONT(this->Association == ASSOC_LOGICAL_DIM);
this->CopyData(&data[0], static_cast<vtkm::Id>(data.size()));
}
template <typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association, int logicalDim,
const T *data, vtkm::Id nvals)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(),
AssocLogicalDim(logicalDim), Bounds(), ModifiedFlag(true)
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
vtkm::IdComponent logicalDim,
const T *data, vtkm::Id nvals)
: Name(name),
Order(order),
Association(association),
AssocLogicalDim(logicalDim),
Bounds(),
ModifiedFlag(true)
{
VTKM_ASSERT_CONT(this->AssocTag == ASSOC_LOGICAL_DIM);
this->CopyData(data, nvals);
VTKM_ASSERT_CONT(this->Association == ASSOC_LOGICAL_DIM);
CopyData(data, nvals);
}
template<typename T>
VTKM_CONT_EXPORT
Field(std::string name, int order, Association association, int logicalDim, T)
: Name(name), Order(order), AssocTag(association), AssocCellsetName(),
AssocLogicalDim(logicalDim), Data(vtkm::cont::ArrayHandle<T>()), Bounds(),
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->AssocTag == ASSOC_LOGICAL_DIM);
VTKM_ASSERT_CONT(this->Association == ASSOC_LOGICAL_DIM);
}
VTKM_CONT_EXPORT
@ -382,13 +484,13 @@ public:
}
VTKM_CONT_EXPORT
Association GetAssociation() const
AssociationEnum GetAssociation() const
{
return this->AssocTag;
return this->Association;
}
VTKM_CONT_EXPORT
int GetOrder() const
vtkm::IdComponent GetOrder() const
{
return this->Order;
}
@ -396,21 +498,15 @@ public:
VTKM_CONT_EXPORT
std::string GetAssocCellSet() const
{
return this->AssocCellsetName;
return this->AssocCellSetName;
}
VTKM_CONT_EXPORT
int GetAssocLogicalDim() const
vtkm::IdComponent GetAssocLogicalDim() const
{
return this->AssocLogicalDim;
}
VTKM_CONT_EXPORT
const vtkm::cont::DynamicArrayHandle &GetData() const
{
return this->Data;
}
template<typename DeviceAdapterTag, typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
const vtkm::cont::ArrayHandle<vtkm::Float64>& GetBounds(DeviceAdapterTag,
@ -429,7 +525,10 @@ public:
template<typename DeviceAdapterTag, typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
void GetBounds(vtkm::Float64 *bounds, DeviceAdapterTag, TypeList, StorageList) const
void GetBounds(vtkm::Float64 *bounds,
DeviceAdapterTag,
TypeList,
StorageList) const
{
this->GetBounds(DeviceAdapterTag(), TypeList(), StorageList());
@ -474,7 +573,7 @@ public:
}
VTKM_CONT_EXPORT
vtkm::cont::DynamicArrayHandle &GetData()
const vtkm::cont::DynamicArrayHandle &GetData() const
{
this->ModifiedFlag = true;
return this->Data;
@ -519,19 +618,20 @@ public:
case ASSOC_LOGICAL_DIM: out<<"LogicalDim "; break;
}
vtkm::cont::ArrayHandle<vtkm::Float32> vals;
vals = this->Data.CastToArrayHandle(vtkm::Float32(), VTKM_DEFAULT_STORAGE_TAG());
vals = this->Data.CastToArrayHandle(
vtkm::Float32(), VTKM_DEFAULT_STORAGE_TAG());
printSummary_ArrayHandle(vals, out);
//out<<" Order= "<<Order;
out<<"\n";
}
private:
std::string Name; ///< Name of field
std::string Name; ///< name of field
int Order; ///< 0=(piecewise) constant, 1=linear, 2=quadratic
Association AssocTag;
std::string AssocCellsetName; ///< only populate if assoc is cells
int AssocLogicalDim; ///< only populate if assoc is logical dim
vtkm::IdComponent Order; ///< 0=(piecewise) constant, 1=linear, 2=quadratic
AssociationEnum Association;
std::string AssocCellSetName; ///< only populate if assoc is cells
vtkm::IdComponent AssocLogicalDim; ///< only populate if assoc is logical dim
vtkm::cont::DynamicArrayHandle Data;
mutable vtkm::cont::ArrayHandle<vtkm::Float64> Bounds;

10
vtkm/cont/testing/MakeTestDataSet.h
View File

@ -69,7 +69,7 @@ MakeTestDataSet::Make2DRegularDataSet0()
boost::shared_ptr< vtkm::cont::CellSetStructured<2> > cs(
new vtkm::cont::CellSetStructured<2>("cells"));
//Set regular structure
cs->structure.SetNodeDimension( vtkm::make_Vec(3,2) );
cs->Structure.SetNodeDimension( vtkm::make_Vec(3,2) );
ds.AddCellSet(cs);
return ds;
@ -106,7 +106,7 @@ MakeTestDataSet::Make3DRegularDataSet0()
ds.AddCellSet(cs);
//Set regular structure
cs->structure.SetNodeDimension( vtkm::make_Vec(3,2,3) );
cs->Structure.SetNodeDimension( vtkm::make_Vec(3,2,3) );
return ds;
}
@ -156,7 +156,7 @@ MakeTestDataSet::Make3DExplicitDataSet0()
boost::shared_ptr< vtkm::cont::CellSetExplicit<> > cs(
new vtkm::cont::CellSetExplicit<>("cells", 2));
vtkm::cont::ExplicitConnectivity<> &ec = cs->nodesOfCellsConnectivity;
vtkm::cont::ExplicitConnectivity<> &ec = cs->NodesOfCellsConnectivity;
ec.FillViaCopy(shapes, numindices, conn);
//todo this need to be a reference/shared_ptr style class
@ -190,7 +190,7 @@ MakeTestDataSet::Make3DExplicitDataSet1()
boost::shared_ptr< vtkm::cont::CellSetExplicit<> > cs(
new vtkm::cont::CellSetExplicit<>("cells", 2));
vtkm::cont::ExplicitConnectivity<> &ec = cs->nodesOfCellsConnectivity;
vtkm::cont::ExplicitConnectivity<> &ec = cs->NodesOfCellsConnectivity;
ec.PrepareToAddCells(2, 7);
ec.AddCell(vtkm::VTKM_TRIANGLE, 3, make_Vec<vtkm::Id>(0,1,2));
@ -233,7 +233,7 @@ MakeTestDataSet::Make3DExplicitDataSetCowNose(double *pBounds)
boost::shared_ptr< vtkm::cont::CellSetExplicit<> > cs(
new vtkm::cont::CellSetExplicit<>("cells", 2));
vtkm::cont::ExplicitConnectivity<> &ec = cs->nodesOfCellsConnectivity;
vtkm::cont::ExplicitConnectivity<> &ec = cs->NodesOfCellsConnectivity;
ec.PrepareToAddCells(nPointIds/3, nPointIds);
for (i=0; i<nPointIds/3; i++)

20
vtkm/cont/testing/UnitTestDataSetRegular.cxx
View File

@ -55,17 +55,17 @@ TwoDimRegularTest()
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 4,
"Incorrect number of fields");
VTKM_TEST_ASSERT(cs->structure.GetNumberOfNodes() == 6,
VTKM_TEST_ASSERT(cs->Structure.GetNumberOfNodes() == 6,
"Incorrect number of nodes");
VTKM_TEST_ASSERT(cs->structure.GetNumberOfCells() == 2,
VTKM_TEST_ASSERT(cs->Structure.GetNumberOfCells() == 2,
"Incorrect number of cells");
vtkm::Id numCells = cs->structure.GetNumberOfCells();
vtkm::Id numCells = cs->Structure.GetNumberOfCells();
for (int i = 0; i < numCells; i++)
{
VTKM_TEST_ASSERT(cs->structure.GetNumberOfIndices() == 4,
VTKM_TEST_ASSERT(cs->Structure.GetNumberOfIndices() == 4,
"Incorrect number of cell indices");
vtkm::CellType shape = cs->structure.GetElementShapeType();
vtkm::CellType shape = cs->Structure.GetElementShapeType();
VTKM_TEST_ASSERT(shape == vtkm::VTKM_PIXEL, "Incorrect element type.");
}
@ -123,18 +123,18 @@ ThreeDimRegularTest()
VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 5,
"Incorrect number of fields");
VTKM_TEST_ASSERT(cs->structure.GetNumberOfNodes() == 18,
VTKM_TEST_ASSERT(cs->Structure.GetNumberOfNodes() == 18,
"Incorrect number of nodes");
VTKM_TEST_ASSERT(cs->structure.GetNumberOfCells() == 4,
VTKM_TEST_ASSERT(cs->Structure.GetNumberOfCells() == 4,
"Incorrect number of cells");
vtkm::Id numCells = cs->structure.GetNumberOfCells();
vtkm::Id numCells = cs->Structure.GetNumberOfCells();
for (int i = 0; i < numCells; i++)
{
VTKM_TEST_ASSERT(cs->structure.GetNumberOfIndices() == 8,
VTKM_TEST_ASSERT(cs->Structure.GetNumberOfIndices() == 8,
"Incorrect number of cell indices");
vtkm::CellType shape = cs->structure.GetElementShapeType();
vtkm::CellType shape = cs->Structure.GetElementShapeType();
VTKM_TEST_ASSERT(shape == vtkm::VTKM_VOXEL, "Incorrect element type.");
}

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

@ -60,8 +60,8 @@ vtkm::cont::DataSet MakePointElevationTestDataSet()
ds.AddCoordinateSystem(vtkm::cont::CoordinateSystem("x","y","z"));
boost::shared_ptr<vtkm::cont::CellSetExplicit<> > cs(
new vtkm::cont::CellSetExplicit<>("cells", numCells));
vtkm::cont::ExplicitConnectivity<> &ec = cs->nodesOfCellsConnectivity;
new vtkm::cont::CellSetExplicit<>("cells", 3));
vtkm::cont::ExplicitConnectivity<> &ec = cs->NodesOfCellsConnectivity;
ec.PrepareToAddCells(numCells, numCells * 4);
for (vtkm::Id j = 0; j < dim - 1; ++j)
{