mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-09-19 18:45:43 +00:00
Add support for rectilinear coordinates via ArrayHandleCartesianProduct.
It consists of 3 ArrayHandles, and handles indexing to give each point in the grid. Added some examples to the test dataset class, and a basic test.
This commit is contained in:
parent
bc474bd568
commit
92438f9d23
487
vtkm/cont/ArrayHandleCartesianProduct.h
Normal file
487
vtkm/cont/ArrayHandleCartesianProduct.h
Normal file
@ -0,0 +1,487 @@
|
||||
//============================================================================
|
||||
// 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_cont_ArrayHandleCartesianProduct_h
|
||||
#define vtk_m_cont_ArrayHandleCartesianProduct_h
|
||||
|
||||
#include <vtkm/cont/ArrayHandle.h>
|
||||
#include <vtkm/cont/Assert.h>
|
||||
#include <vtkm/cont/ErrorControlBadAllocation.h>
|
||||
|
||||
namespace vtkm {
|
||||
namespace exec {
|
||||
namespace internal {
|
||||
|
||||
/// \brief An array portal that acts as a 3D cartesian product of 3 arrays.
|
||||
/// for the execution environment
|
||||
|
||||
template<typename ValueType_,
|
||||
typename PortalTypeFirst_,
|
||||
typename PortalTypeSecond_,
|
||||
typename PortalTypeThird_>
|
||||
class ArrayPortalExecCartesianProduct
|
||||
{
|
||||
public:
|
||||
typedef ValueType_ ValueType;
|
||||
typedef ValueType_ IteratorType;
|
||||
typedef PortalTypeFirst_ PortalTypeFirst;
|
||||
typedef PortalTypeSecond_ PortalTypeSecond;
|
||||
typedef PortalTypeThird_ PortalTypeThird;
|
||||
|
||||
VTKM_EXEC_CONT_EXPORT
|
||||
ArrayPortalExecCartesianProduct()
|
||||
: PortalFirst(), PortalSecond(), PortalThird()
|
||||
{ } //needs to be host and device so that cuda can create lvalue of these
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
ArrayPortalExecCartesianProduct(const PortalTypeFirst &portalfirst,
|
||||
const PortalTypeSecond &portalsecond,
|
||||
const PortalTypeThird &portalthird)
|
||||
: PortalFirst(portalfirst), PortalSecond(portalsecond), PortalThird(portalthird)
|
||||
{ }
|
||||
|
||||
/// Copy constructor for any other ArrayPortalExecCartesianProduct with an iterator
|
||||
/// type that can be copied to this iterator type. This allows us to do any
|
||||
/// type casting that the iterators do (like the non-const to const cast).
|
||||
///
|
||||
|
||||
template<class OtherV, class OtherP1, class OtherP2, class OtherP3>
|
||||
VTKM_CONT_EXPORT
|
||||
ArrayPortalExecCartesianProduct(const ArrayPortalExecCartesianProduct<OtherV,OtherP1,OtherP2,OtherP3> &src)
|
||||
: PortalFirst(src.GetPortalFirst()),
|
||||
PortalSecond(src.GetPortalSecond()),
|
||||
PortalThird(src.GetPortalThird())
|
||||
{ }
|
||||
|
||||
|
||||
VTKM_EXEC_CONT_EXPORT
|
||||
vtkm::Id GetNumberOfValues() const
|
||||
{
|
||||
return this->PortalFirst.GetNumberOfValues() *
|
||||
this->PortalSecond.GetNumberOfValue() *
|
||||
this->PortalThird.GetNumberOfValue();
|
||||
}
|
||||
|
||||
VTKM_EXEC_EXPORT
|
||||
ValueType Get(vtkm::Id index) const
|
||||
{
|
||||
vtkm::Id dim1 = this->PortalFirst.GetNumberOfValues();
|
||||
vtkm::Id dim2 = this->PortalSecond.GetNumberOfValues();
|
||||
vtkm::Id dim3 = this->PortalThird.GetNumberOfValues();
|
||||
vtkm::Id dim12 = dim1*dim2;
|
||||
vtkm::Id idx12 = index % dim12;
|
||||
vtkm::Id i1 = idx12 % dim1;
|
||||
vtkm::Id i2 = idx12 / dim1;
|
||||
vtkm::Id i3 = index / dim12;
|
||||
|
||||
return vtkm::make_Vec(this->PortalFirst.Get(i1),
|
||||
this->PortalSecond.Get(i2),
|
||||
this->PortalThird.Get(i3));
|
||||
}
|
||||
|
||||
VTKM_EXEC_EXPORT
|
||||
void Set(vtkm::Id index, const ValueType &value) const
|
||||
{
|
||||
vtkm::Id i1=0, i2=0, i3=0;
|
||||
this->PortalFirst.Set(i1, value[0]);
|
||||
this->PortalSecond.Set(i2, value[1]);
|
||||
this->PortalThird.Set(i3, value[2]);
|
||||
}
|
||||
|
||||
VTKM_EXEC_CONT_EXPORT
|
||||
const PortalTypeFirst &GetFirstPortal() const { return this->PortalFirst; }
|
||||
|
||||
VTKM_EXEC_CONT_EXPORT
|
||||
const PortalTypeSecond &GetSecondPortal() const { return this->PortalSecond; }
|
||||
|
||||
VTKM_EXEC_CONT_EXPORT
|
||||
const PortalTypeThird &GetThirdPortal() const { return this->PortalThird; }
|
||||
|
||||
|
||||
private:
|
||||
PortalTypeFirst PortalFirst;
|
||||
PortalTypeSecond PortalSecond;
|
||||
PortalTypeThird PortalThird;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
} // namespace vtkm::exec::internal
|
||||
|
||||
|
||||
namespace vtkm {
|
||||
namespace cont {
|
||||
|
||||
namespace internal {
|
||||
|
||||
/// \brief An array portal that zips two portals together into a single value
|
||||
/// for the control environment
|
||||
template<typename ValueType_,
|
||||
typename PortalTypeFirst,
|
||||
typename PortalTypeSecond,
|
||||
typename PortalTypeThird>
|
||||
class ArrayPortalContCartesianProduct
|
||||
{
|
||||
public:
|
||||
typedef ValueType_ ValueType;
|
||||
typedef ValueType_ IteratorType;
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
ArrayPortalContCartesianProduct(const PortalTypeFirst &portalfirst = PortalTypeFirst(),
|
||||
const PortalTypeSecond &portalsecond = PortalTypeSecond(),
|
||||
const PortalTypeSecond &portalthird = PortalTypeThird())
|
||||
: PortalFirst(portalfirst), PortalSecond(portalsecond), PortalThird(portalthird)
|
||||
{ }
|
||||
|
||||
/// Copy constructor for any other ArrayPortalContCartesianProduct with an iterator
|
||||
/// type that can be copied to this iterator type. This allows us to do any
|
||||
/// type casting that the iterators do (like the non-const to const cast).
|
||||
///
|
||||
template<class OtherV, class OtherP1, class OtherP2, class OtherP3>
|
||||
VTKM_CONT_EXPORT
|
||||
ArrayPortalContCartesianProduct(const ArrayPortalContCartesianProduct<OtherV,OtherP1,OtherP2,OtherP3> &src)
|
||||
: PortalFirst(src.GetPortalFirst()),
|
||||
PortalSecond(src.GetPortalSecond()),
|
||||
PortalThird(src.GetPortalThird())
|
||||
{ }
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
vtkm::Id GetNumberOfValues() const
|
||||
{
|
||||
return this->PortalFirst.GetNumberOfValues() *
|
||||
this->PortalSecond.GetNumberOfValues() *
|
||||
this->PortalThird.GetNumberOfValues();
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
ValueType Get(vtkm::Id index) const
|
||||
{
|
||||
vtkm::Id dim1 = this->PortalFirst.GetNumberOfValues();
|
||||
vtkm::Id dim2 = this->PortalSecond.GetNumberOfValues();
|
||||
vtkm::Id dim3 = this->PortalThird.GetNumberOfValues();
|
||||
vtkm::Id dim12 = dim1*dim2;
|
||||
vtkm::Id idx12 = index % dim12;
|
||||
vtkm::Id i1 = idx12 % dim1;
|
||||
vtkm::Id i2 = idx12 / dim1;
|
||||
vtkm::Id i3 = index / dim12;
|
||||
return vtkm::make_Vec(this->PortalFirst.Get(i1),
|
||||
this->PortalSecond.Get(i2),
|
||||
this->PortalThird.Get(i3));
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
void Set(vtkm::Id index, const ValueType &value) const
|
||||
{
|
||||
vtkm::Id i1=0, i2=0, i3=0;
|
||||
this->PortalFirst.Set(i1, value[0]);
|
||||
this->PortalSecond.Set(i2, value[1]);
|
||||
this->PortalThird.Set(i3, value[2]);
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
const PortalTypeFirst &GetFirstPortal() const { return this->PortalFirst; }
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
const PortalTypeSecond &GetSecondPortal() const { return this->PortalSecond; }
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
const PortalTypeSecond &GetThirdPortal() const { return this->PortalThird; }
|
||||
|
||||
|
||||
private:
|
||||
PortalTypeFirst PortalFirst;
|
||||
PortalTypeSecond PortalSecond;
|
||||
PortalTypeThird PortalThird;
|
||||
};
|
||||
|
||||
template<typename FirstHandleType, typename SecondHandleType, typename ThirdHandleType>
|
||||
struct StorageTagCartesianProduct { };
|
||||
|
||||
/// This helper struct defines the value type for a zip container containing
|
||||
/// the given two array handles.
|
||||
///
|
||||
template<typename FirstHandleType, typename SecondHandleType, typename ThirdHandleType>
|
||||
struct ArrayHandleCartesianProductTraits {
|
||||
/// The ValueType (a pair containing the value types of the two arrays).
|
||||
///
|
||||
typedef vtkm::Vec<typename FirstHandleType::ValueType,3> ValueType;
|
||||
|
||||
/// The appropriately templated tag.
|
||||
///
|
||||
typedef StorageTagCartesianProduct<FirstHandleType,SecondHandleType,ThirdHandleType> Tag;
|
||||
|
||||
/// The superclass for ArrayHandleCartesianProduct.
|
||||
///
|
||||
typedef vtkm::cont::ArrayHandle<ValueType,Tag> Superclass;
|
||||
};
|
||||
|
||||
|
||||
template<typename T, typename FirstHandleType, typename SecondHandleType, typename ThirdHandleType>
|
||||
class Storage<T, StorageTagCartesianProduct<FirstHandleType, SecondHandleType, ThirdHandleType > >
|
||||
{
|
||||
VTKM_IS_ARRAY_HANDLE(FirstHandleType);
|
||||
VTKM_IS_ARRAY_HANDLE(SecondHandleType);
|
||||
VTKM_IS_ARRAY_HANDLE(ThirdHandleType);
|
||||
|
||||
public:
|
||||
typedef T ValueType;
|
||||
|
||||
typedef ArrayPortalContCartesianProduct< ValueType,
|
||||
typename FirstHandleType::PortalControl,
|
||||
typename SecondHandleType::PortalControl,
|
||||
typename ThirdHandleType::PortalControl> PortalType;
|
||||
typedef ArrayPortalContCartesianProduct< ValueType,
|
||||
typename FirstHandleType::PortalConstControl,
|
||||
typename SecondHandleType::PortalConstControl,
|
||||
typename ThirdHandleType::PortalConstControl>
|
||||
PortalConstType;
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
Storage() : FirstArray(), SecondArray(), ThirdArray() { }
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
Storage(const FirstHandleType &array1, const SecondHandleType &array2, const ThirdHandleType &array3)
|
||||
: FirstArray(array1), SecondArray(array2), ThirdArray(array3)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
PortalType GetPortal()
|
||||
{
|
||||
return PortalType(this->FirstArray.GetPortalControl(),
|
||||
this->SecondArray.GetPortalControl(),
|
||||
this->ThirdArray.GetPortalControl());
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
PortalConstType GetPortalConst() const
|
||||
{
|
||||
return PortalConstType(this->FirstArray.GetPortalConstControl(),
|
||||
this->SecondArray.GetPortalConstControl(),
|
||||
this->ThirdArray.GetPortalConstControl());
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
vtkm::Id GetNumberOfValues() const
|
||||
{
|
||||
return this->FirstArray.GetNumberOfValues() *
|
||||
this->SecondArray.GetNumberOfValues() *
|
||||
this->ThirdArray.GetNumberOfValues();
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
void Allocate(vtkm::Id /*numberOfValues*/)
|
||||
{
|
||||
throw vtkm::cont::ErrorControlBadAllocation("Does not make sense.");
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
void Shrink(vtkm::Id /*numberOfValues*/)
|
||||
{
|
||||
throw vtkm::cont::ErrorControlBadAllocation("Does not make sense.");
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
void ReleaseResources()
|
||||
{
|
||||
// This request is ignored since it is asking to release the resources
|
||||
// of the arrays, which may be used elsewhere.
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
const FirstHandleType &GetFirstArray() const
|
||||
{
|
||||
return this->FirstArray;
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
const SecondHandleType &GetSecondArray() const
|
||||
{
|
||||
return this->SecondArray;
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
const ThirdHandleType &GetThirdArray() const
|
||||
{
|
||||
return this->ThirdArray;
|
||||
}
|
||||
|
||||
private:
|
||||
FirstHandleType FirstArray;
|
||||
SecondHandleType SecondArray;
|
||||
ThirdHandleType ThirdArray;
|
||||
};
|
||||
|
||||
template<typename T,
|
||||
typename FirstHandleType,
|
||||
typename SecondHandleType,
|
||||
typename ThirdHandleType,
|
||||
typename Device>
|
||||
class ArrayTransfer<
|
||||
T, StorageTagCartesianProduct<FirstHandleType,SecondHandleType,ThirdHandleType>, Device>
|
||||
{
|
||||
typedef StorageTagCartesianProduct<FirstHandleType,SecondHandleType,ThirdHandleType> StorageTag;
|
||||
typedef vtkm::cont::internal::Storage<T, StorageTag> StorageType;
|
||||
|
||||
public:
|
||||
typedef T ValueType;
|
||||
|
||||
typedef typename StorageType::PortalType PortalControl;
|
||||
typedef typename StorageType::PortalConstType PortalConstControl;
|
||||
|
||||
typedef vtkm::exec::internal::ArrayPortalExecCartesianProduct<
|
||||
ValueType,
|
||||
typename FirstHandleType::template ExecutionTypes<Device>::Portal,
|
||||
typename SecondHandleType::template ExecutionTypes<Device>::Portal,
|
||||
typename ThirdHandleType::template ExecutionTypes<Device>::Portal
|
||||
> PortalExecution;
|
||||
|
||||
typedef vtkm::exec::internal::ArrayPortalExecCartesianProduct<
|
||||
ValueType,
|
||||
typename FirstHandleType::template ExecutionTypes<Device>::PortalConst,
|
||||
typename SecondHandleType::template ExecutionTypes<Device>::PortalConst,
|
||||
typename ThirdHandleType::template ExecutionTypes<Device>::PortalConst
|
||||
> PortalConstExecution;
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
ArrayTransfer(StorageType *storage)
|
||||
: FirstArray(storage->GetFirstArray()),
|
||||
SecondArray(storage->GetSecondArray()),
|
||||
ThirdArray(storage->GetThirdArray())
|
||||
{ }
|
||||
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
vtkm::Id GetNumberOfValues() const
|
||||
{
|
||||
return this->FirstArray.GetNumberOfValues() *
|
||||
this->SecondArray.GetNumberOfValues() *
|
||||
this->ThirdArray.GetNumberOfValues();
|
||||
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData)) {
|
||||
return PortalConstExecution(this->FirstArray.PrepareForInput(Device()),
|
||||
this->SecondArray.PrepareForInput(Device()));
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
|
||||
{
|
||||
throw vtkm::cont::ErrorControlBadAllocation("Does not make sense.");
|
||||
/*
|
||||
const vtkm::Id numberOfValues = this->GetNumberOfValues();
|
||||
return PortalExecution(this->FirstArray.PrepareForOutput(numberOfValues, Device()),
|
||||
this->SecondArray.PrepareForOutput(numberOfValues, Device()));
|
||||
*/
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
|
||||
{
|
||||
throw vtkm::cont::ErrorControlBadAllocation("Does not make sense.");
|
||||
return PortalExecution(this->FirstArray.PrepareForOutput(numberOfValues, Device()),
|
||||
this->SecondArray.PrepareForOutput(numberOfValues, Device()),
|
||||
this->ThirdArray.PrepareForOutput(numberOfValues, Device()));
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
void RetrieveOutputData(StorageType *vtkmNotUsed(storage)) const
|
||||
{
|
||||
// Implementation of this method should be unnecessary. The internal
|
||||
// first and second array handles should automatically retrieve the
|
||||
// output data as necessary.
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
void Shrink(vtkm::Id numberOfValues)
|
||||
{
|
||||
throw vtkm::cont::ErrorControlBadAllocation("Does not make sense.");
|
||||
}
|
||||
|
||||
VTKM_CONT_EXPORT
|
||||
void ReleaseResources() {
|
||||
this->FirstArray.ReleaseResourcesExecution();
|
||||
this->SecondArray.ReleaseResourcesExecution();
|
||||
this->ThirdArray.ReleaseResourcesExecution();
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
FirstHandleType FirstArray;
|
||||
SecondHandleType SecondArray;
|
||||
ThirdHandleType ThirdArray;
|
||||
};
|
||||
} // namespace internal
|
||||
|
||||
/// ArrayHandleCartesianProduct is a specialization of ArrayHandle. It takes two delegate
|
||||
/// array handle and makes a new handle that access the corresponding entries
|
||||
/// in these arrays as a pair.
|
||||
///
|
||||
template<typename FirstHandleType,
|
||||
typename SecondHandleType,
|
||||
typename ThirdHandleType>
|
||||
class ArrayHandleCartesianProduct
|
||||
: public internal::ArrayHandleCartesianProductTraits<FirstHandleType,SecondHandleType,ThirdHandleType>::Superclass
|
||||
{
|
||||
// If the following line gives a compile error, then the FirstHandleType
|
||||
// template argument is not a valid ArrayHandle type.
|
||||
VTKM_IS_ARRAY_HANDLE(FirstHandleType);
|
||||
VTKM_IS_ARRAY_HANDLE(SecondHandleType);
|
||||
VTKM_IS_ARRAY_HANDLE(ThirdHandleType);
|
||||
|
||||
public:
|
||||
VTKM_ARRAY_HANDLE_SUBCLASS(
|
||||
ArrayHandleCartesianProduct,
|
||||
(ArrayHandleCartesianProduct<FirstHandleType,SecondHandleType,ThirdHandleType>),
|
||||
(typename internal::ArrayHandleCartesianProductTraits<
|
||||
FirstHandleType,SecondHandleType,ThirdHandleType>::Superclass));
|
||||
|
||||
private:
|
||||
typedef vtkm::cont::internal::Storage<ValueType, StorageTag> StorageType;
|
||||
|
||||
public:
|
||||
VTKM_CONT_EXPORT
|
||||
ArrayHandleCartesianProduct(const FirstHandleType &firstArray,
|
||||
const SecondHandleType &secondArray,
|
||||
const ThirdHandleType &thirdArray)
|
||||
: Superclass(StorageType(firstArray, secondArray, thirdArray)) { }
|
||||
};
|
||||
|
||||
/// A convenience function for creating an ArrayHandleCartesianProduct. It takes the two
|
||||
/// arrays to be zipped together.
|
||||
///
|
||||
template<typename FirstHandleType, typename SecondHandleType, typename ThirdHandleType>
|
||||
VTKM_CONT_EXPORT
|
||||
vtkm::cont::ArrayHandleCartesianProduct<FirstHandleType,SecondHandleType,ThirdHandleType>
|
||||
make_ArrayHandleCartesianProduct(const FirstHandleType &first,
|
||||
const SecondHandleType &second,
|
||||
const ThirdHandleType &third)
|
||||
{
|
||||
return ArrayHandleCartesianProduct<FirstHandleType,
|
||||
SecondHandleType,
|
||||
ThirdHandleType>(first, second,third);
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace vtkm::cont
|
||||
|
||||
#endif //vtk_m_cont_ArrayHandleCartesianProduct_h
|
165
vtkm/cont/DataSetBuilderRectilinear.h
Normal file
165
vtkm/cont/DataSetBuilderRectilinear.h
Normal file
@ -0,0 +1,165 @@
|
||||
//============================================================================
|
||||
// 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 2015 Sandia Corporation.
|
||||
// Copyright 2015 UT-Battelle, LLC.
|
||||
// Copyright 2015 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_cont_DataSetBuilderRectilinear_h
|
||||
#define vtk_m_cont_DataSetBuilderRectilinear_h
|
||||
|
||||
#include <vtkm/cont/DataSet.h>
|
||||
#include <vtkm/cont/CoordinateSystem.h>
|
||||
#include <vtkm/cont/Assert.h>
|
||||
#include <vtkm/cont/ArrayHandleCartesianProduct.h>
|
||||
|
||||
namespace vtkm {
|
||||
namespace cont {
|
||||
|
||||
class DataSetBuilderRectilinear
|
||||
{
|
||||
public:
|
||||
VTKM_CONT_EXPORT
|
||||
DataSetBuilderRectilinear() {}
|
||||
|
||||
//2D grids.
|
||||
template<typename T>
|
||||
VTKM_CONT_EXPORT
|
||||
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);
|
||||
}
|
||||
template<typename T>
|
||||
VTKM_CONT_EXPORT
|
||||
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 Create(2, xvals, yvals, zvals, coordNm, cellNm);
|
||||
}
|
||||
|
||||
//3D grids.
|
||||
template<typename T>
|
||||
VTKM_CONT_EXPORT
|
||||
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);
|
||||
}
|
||||
template<typename T>
|
||||
VTKM_CONT_EXPORT
|
||||
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 Create(3, xvals, yvals, zvals, coordNm, cellNm);
|
||||
}
|
||||
|
||||
private:
|
||||
template<typename T>
|
||||
VTKM_CONT_EXPORT
|
||||
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)));
|
||||
|
||||
vtkm::cont::ArrayHandle<T> X = vtkm::cont::make_ArrayHandle(nx,xvals);
|
||||
vtkm::cont::ArrayHandle<T> Y = vtkm::cont::make_ArrayHandle(ny,yvals);
|
||||
vtkm::cont::ArrayHandle<T> Z = vtkm::cont::make_ArrayHandle(nz,zvals);
|
||||
|
||||
return BuildDataSet(dim, X,Y,Z, coordNm, cellNm);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
VTKM_CONT_EXPORT
|
||||
vtkm::cont::DataSet
|
||||
Create(int dim,
|
||||
const std::vector<T> &xvals,
|
||||
const std::vector<T> &yvals,
|
||||
const std::vector<T> &zvals,
|
||||
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)));
|
||||
|
||||
vtkm::cont::ArrayHandle<T> X = vtkm::cont::make_ArrayHandle(xvals);
|
||||
vtkm::cont::ArrayHandle<T> Y = vtkm::cont::make_ArrayHandle(yvals);
|
||||
vtkm::cont::ArrayHandle<T> Z = vtkm::cont::make_ArrayHandle(zvals);
|
||||
|
||||
return BuildDataSet(dim, X,Y,Z, coordNm, cellNm);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
VTKM_CONT_EXPORT
|
||||
vtkm::cont::DataSet
|
||||
BuildDataSet(int dim,
|
||||
const vtkm::cont::ArrayHandle<T> &X,
|
||||
const vtkm::cont::ArrayHandle<T> &Y,
|
||||
const vtkm::cont::ArrayHandle<T> &Z,
|
||||
std::string coordNm, std::string cellNm)
|
||||
{
|
||||
vtkm::cont::DataSet dataSet;
|
||||
|
||||
vtkm::cont::ArrayHandleCartesianProduct<
|
||||
vtkm::cont::ArrayHandle<T>,
|
||||
vtkm::cont::ArrayHandle<T>,
|
||||
vtkm::cont::ArrayHandle<T> > coords;
|
||||
vtkm::cont::ArrayHandle<T> Xc, Yc, Zc;
|
||||
|
||||
vtkm::cont::DeviceAdapterAlgorithm<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Copy(X, Xc);
|
||||
vtkm::cont::DeviceAdapterAlgorithm<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Copy(Y, Yc);
|
||||
vtkm::cont::DeviceAdapterAlgorithm<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Copy(Z, Zc);
|
||||
|
||||
coords = vtkm::cont::make_ArrayHandleCartesianProduct(Xc,Yc,Zc);
|
||||
vtkm::cont::CoordinateSystem cs(coordNm, 1, coords);
|
||||
dataSet.AddCoordinateSystem(cs);
|
||||
|
||||
if (dim == 2)
|
||||
{
|
||||
vtkm::cont::CellSetStructured<2> cellSet(cellNm);
|
||||
cellSet.SetPointDimensions(vtkm::make_Vec(Xc.GetNumberOfValues(),
|
||||
Yc.GetNumberOfValues()));
|
||||
dataSet.AddCellSet(cellSet);
|
||||
}
|
||||
else
|
||||
{
|
||||
vtkm::cont::CellSetStructured<3> cellSet(cellNm);
|
||||
cellSet.SetPointDimensions(vtkm::make_Vec(Xc.GetNumberOfValues(),
|
||||
Yc.GetNumberOfValues(),
|
||||
Zc.GetNumberOfValues()));
|
||||
dataSet.AddCellSet(cellSet);
|
||||
}
|
||||
|
||||
return dataSet;
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace cont
|
||||
} // namespace vtkm
|
||||
|
||||
#endif //vtk_m_cont_DataSetBuilderRectilinear_h
|
@ -49,9 +49,9 @@ public:
|
||||
T originX, T originY, T spacingX, T spacingY,
|
||||
std::string coordNm="coords", std::string cellNm="cells")
|
||||
{
|
||||
Create(2, nx,ny,1, originX,originY,0,
|
||||
spacingX,spacingY,1,
|
||||
coordNm, cellNm);
|
||||
return Create(2, nx,ny,1, originX,originY,0,
|
||||
spacingX,spacingY,1,
|
||||
coordNm, cellNm);
|
||||
}
|
||||
|
||||
//3D regular grids.
|
||||
@ -83,7 +83,7 @@ private:
|
||||
T originX, T originY, T originZ, T spacingX, T spacingY, T spacingZ,
|
||||
std::string coordNm, std::string cellNm)
|
||||
{
|
||||
VTKM_ASSERT_CONT(nx>1 && ny>1 && ((dim==2 && nz==1)||(dim==3 && nz>1)));
|
||||
VTKM_ASSERT_CONT(nx>1 && ny>1 && ((dim==2 && nz==1)||(dim==3 && nz>=1)));
|
||||
vtkm::cont::DataSet dataSet;
|
||||
|
||||
vtkm::cont::ArrayHandleUniformPointCoordinates
|
||||
|
@ -43,6 +43,7 @@ set(unit_tests
|
||||
UnitTestContTesting.cxx
|
||||
UnitTestComputeBoundsSerial.cxx
|
||||
UnitTestDataSetRegular.cxx
|
||||
UnitTestDataSetRectilinear.cxx
|
||||
UnitTestDataSetExplicit.cxx
|
||||
UnitTestDataSetSingleType.cxx
|
||||
UnitTestDataSetPermutation.cxx
|
||||
|
@ -24,6 +24,7 @@
|
||||
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
|
||||
#include <vtkm/cont/DataSet.h>
|
||||
#include <vtkm/cont/DataSetBuilderRegular.h>
|
||||
#include <vtkm/cont/DataSetBuilderRectilinear.h>
|
||||
#include <vtkm/cont/DataSetBuilderExplicit.h>
|
||||
#include <vtkm/cont/DataSetFieldAdd.h>
|
||||
|
||||
@ -42,6 +43,14 @@ public:
|
||||
VTKM_CONT_EXPORT
|
||||
vtkm::cont::DataSet Make3DRegularDataSet0();
|
||||
|
||||
//2D rectilinear
|
||||
VTKM_CONT_EXPORT
|
||||
vtkm::cont::DataSet Make2DRectilinearDataSet0();
|
||||
|
||||
//3D rectilinear
|
||||
VTKM_CONT_EXPORT
|
||||
vtkm::cont::DataSet Make3DRectilinearDataSet0();
|
||||
|
||||
// 3D explicit datasets.
|
||||
VTKM_CONT_EXPORT
|
||||
vtkm::cont::DataSet Make3DExplicitDataSet0();
|
||||
@ -94,6 +103,69 @@ MakeTestDataSet::Make3DRegularDataSet0()
|
||||
return dataSet;
|
||||
}
|
||||
|
||||
vtkm::cont::DataSet
|
||||
MakeTestDataSet::Make2DRectilinearDataSet0()
|
||||
{
|
||||
vtkm::cont::DataSetBuilderRectilinear dsb;
|
||||
std::vector<vtkm::Float32> X(3), Y(2);
|
||||
|
||||
X[0] = 0.0;
|
||||
X[1] = 1.0;
|
||||
X[2] = 2.0;
|
||||
Y[0] = 0.0;
|
||||
Y[1] = 1.0;
|
||||
|
||||
vtkm::cont::DataSet dataSet = dsb.Create(X, Y);
|
||||
|
||||
vtkm::cont::DataSetFieldAdd dsf;
|
||||
const vtkm::Id nVerts = 6;
|
||||
vtkm::Float32 var[nVerts];
|
||||
for (int i = 0; i < nVerts; i++)
|
||||
var[i] = (vtkm::Float32)i;
|
||||
dsf.AddPointField(dataSet, "pointvar", var, nVerts);
|
||||
|
||||
const vtkm::Id nCells = 2;
|
||||
vtkm::Float32 cellvar[nCells];
|
||||
for (int i = 0; i < nCells; i++)
|
||||
cellvar[i] = (vtkm::Float32)i;
|
||||
dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells");
|
||||
|
||||
return dataSet;
|
||||
}
|
||||
|
||||
vtkm::cont::DataSet
|
||||
MakeTestDataSet::Make3DRectilinearDataSet0()
|
||||
{
|
||||
vtkm::cont::DataSetBuilderRectilinear dsb;
|
||||
std::vector<vtkm::Float32> X(3), Y(2), Z(3);
|
||||
|
||||
X[0] = 0.0;
|
||||
X[1] = 1.0;
|
||||
X[2] = 2.0;
|
||||
Y[0] = 0.0;
|
||||
Y[1] = 1.0;
|
||||
Z[0] = 0.0;
|
||||
Z[1] = 1.0;
|
||||
Z[2] = 2.0;
|
||||
|
||||
vtkm::cont::DataSet dataSet = dsb.Create(X, Y, Z);
|
||||
|
||||
vtkm::cont::DataSetFieldAdd dsf;
|
||||
const vtkm::Id nVerts = 18;
|
||||
vtkm::Float32 var[nVerts];
|
||||
for (int i = 0; i < nVerts; i++)
|
||||
var[i] = (vtkm::Float32)i;
|
||||
dsf.AddPointField(dataSet, "pointvar", var, nVerts);
|
||||
|
||||
const vtkm::Id nCells = 4;
|
||||
vtkm::Float32 cellvar[nCells];
|
||||
for (int i = 0; i < nCells; i++)
|
||||
cellvar[i] = (vtkm::Float32)i;
|
||||
dsf.AddCellField(dataSet, "cellvar", cellvar, nCells, "cells");
|
||||
|
||||
return dataSet;
|
||||
}
|
||||
|
||||
vtkm::cont::DataSet
|
||||
MakeTestDataSet::Make3DExplicitDataSet0()
|
||||
{
|
||||
|
290
vtkm/cont/testing/UnitTestDataSetRectilinear.cxx
Normal file
290
vtkm/cont/testing/UnitTestDataSetRectilinear.cxx
Normal file
@ -0,0 +1,290 @@
|
||||
//============================================================================
|
||||
// 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.
|
||||
//============================================================================
|
||||
|
||||
#include <vtkm/CellShape.h>
|
||||
|
||||
#include <vtkm/cont/CellSetStructured.h>
|
||||
#include <vtkm/cont/DataSet.h>
|
||||
#include <vtkm/cont/DeviceAdapterSerial.h>
|
||||
|
||||
#include <vtkm/exec/ConnectivityStructured.h>
|
||||
|
||||
#include <vtkm/cont/testing/Testing.h>
|
||||
#include <vtkm/cont/testing/MakeTestDataSet.h>
|
||||
#include <vtkm/cont/CoordinateSystem.h>
|
||||
|
||||
static void TwoDimRectilinearTest();
|
||||
static void ThreeDimRectilinearTest();
|
||||
|
||||
void TestDataSet_Rectilinear()
|
||||
{
|
||||
std::cout << std::endl;
|
||||
std::cout << "--TestDataSet_Rectilinear--" << std::endl << std::endl;
|
||||
|
||||
TwoDimRectilinearTest();
|
||||
ThreeDimRectilinearTest();
|
||||
}
|
||||
|
||||
static void
|
||||
TwoDimRectilinearTest()
|
||||
{
|
||||
std::cout<<"2D Rectilinear data set"<<std::endl;
|
||||
vtkm::cont::testing::MakeTestDataSet testDataSet;
|
||||
|
||||
vtkm::cont::DataSet dataSet = testDataSet.Make2DRectilinearDataSet0();
|
||||
|
||||
/*
|
||||
dataSet.PrintSummary(std::cout);
|
||||
vtkm::cont::CoordinateSystem cs = dataSet.GetCoordinateSystem();
|
||||
vtkm::cont::DynamicArrayHandleCoordinateSystem dcs = cs.GetData();
|
||||
vtkm::cont::ArrayHandleCartesianProduct<
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32> > coords;
|
||||
dcs.CastToArrayHandle(coords);
|
||||
vtkm::Id n = dcs.GetNumberOfValues();
|
||||
vtkm::Vec<vtkm::Float32, 3> pt(0,0,0);
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
pt = coords.GetPortalConstControl().Get(i);
|
||||
std::cout<<i<<": ["<<pt[0]<<" "<<pt[1]<<" "<<pt[2]<<"]"<<std::endl;
|
||||
}
|
||||
*/
|
||||
|
||||
typedef vtkm::cont::CellSetStructured<2> CellSetType;
|
||||
CellSetType cellSet = dataSet.GetCellSet(0).CastTo<CellSetType>();
|
||||
|
||||
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
|
||||
"Incorrect number of cell sets");
|
||||
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 2,
|
||||
"Incorrect number of fields");
|
||||
VTKM_TEST_ASSERT(dataSet.GetNumberOfCoordinateSystems() == 1,
|
||||
"Incorrect number of coordinate systems");
|
||||
VTKM_TEST_ASSERT(cellSet.GetNumberOfPoints() == 6,
|
||||
"Incorrect number of points");
|
||||
VTKM_TEST_ASSERT(cellSet.GetNumberOfCells() == 2,
|
||||
"Incorrect number of cells");
|
||||
|
||||
// test various field-getting methods and associations
|
||||
try
|
||||
{
|
||||
dataSet.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
dataSet.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
VTKM_TEST_FAIL("Failed to get field 'pointvar' with ASSOC_POINT_SET.");
|
||||
}
|
||||
|
||||
vtkm::Id numCells = cellSet.GetNumberOfCells();
|
||||
for (vtkm::Id cellIndex = 0; cellIndex < numCells; cellIndex++)
|
||||
{
|
||||
VTKM_TEST_ASSERT(cellSet.GetNumberOfPointsInCell(cellIndex) == 4,
|
||||
"Incorrect number of cell indices");
|
||||
vtkm::IdComponent shape = cellSet.GetCellShape();
|
||||
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_QUAD,
|
||||
"Incorrect element type.");
|
||||
}
|
||||
|
||||
vtkm::exec::ConnectivityStructured<
|
||||
vtkm::TopologyElementTagPoint,
|
||||
vtkm::TopologyElementTagCell,
|
||||
2> pointToCell =
|
||||
cellSet.PrepareForInput(
|
||||
vtkm::cont::DeviceAdapterTagSerial(),
|
||||
vtkm::TopologyElementTagPoint(),
|
||||
vtkm::TopologyElementTagCell());
|
||||
vtkm::exec::ConnectivityStructured<
|
||||
vtkm::TopologyElementTagCell,
|
||||
vtkm::TopologyElementTagPoint,
|
||||
2> cellToPoint =
|
||||
cellSet.PrepareForInput(
|
||||
vtkm::cont::DeviceAdapterTagSerial(),
|
||||
vtkm::TopologyElementTagCell(),
|
||||
vtkm::TopologyElementTagPoint());
|
||||
|
||||
|
||||
vtkm::Id cells[2][4] = {{0,1,4,3}, {1,2,5,4}};
|
||||
for (vtkm::Id cellIndex = 0; cellIndex < 2; cellIndex++)
|
||||
{
|
||||
vtkm::Vec<vtkm::Id,4> pointIds =
|
||||
pointToCell.GetIndices(pointToCell.FlatToLogicalToIndex(cellIndex));
|
||||
for (vtkm::IdComponent localPointIndex = 0;
|
||||
localPointIndex < 4;
|
||||
localPointIndex++)
|
||||
{
|
||||
VTKM_TEST_ASSERT(
|
||||
pointIds[localPointIndex] == cells[cellIndex][localPointIndex],
|
||||
"Incorrect point ID for cell");
|
||||
}
|
||||
}
|
||||
|
||||
vtkm::Id expectedCellIds[6][4] = {{0,-1,-1,-1},
|
||||
{0,1,-1,-1},
|
||||
{1,-1,-1,-1},
|
||||
{0,-1,-1,-1},
|
||||
{0,1,-1,-1},
|
||||
{1,-1,-1,-1}};
|
||||
|
||||
for (vtkm::Id pointIndex = 0; pointIndex < 6; pointIndex++)
|
||||
{
|
||||
vtkm::VecVariable<vtkm::Id,4> retrievedCellIds =
|
||||
cellToPoint.GetIndices(cellToPoint.FlatToLogicalToIndex(pointIndex));
|
||||
VTKM_TEST_ASSERT(retrievedCellIds.GetNumberOfComponents() <= 4,
|
||||
"Got wrong number of cell ids.");
|
||||
for (vtkm::IdComponent cellIndex = 0;
|
||||
cellIndex < retrievedCellIds.GetNumberOfComponents();
|
||||
cellIndex++)
|
||||
{
|
||||
VTKM_TEST_ASSERT(
|
||||
retrievedCellIds[cellIndex] == expectedCellIds[pointIndex][cellIndex],
|
||||
"Incorrect cell ID for point");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
ThreeDimRectilinearTest()
|
||||
{
|
||||
std::cout<<"3D Rectilinear data set"<<std::endl;
|
||||
vtkm::cont::testing::MakeTestDataSet testDataSet;
|
||||
|
||||
vtkm::cont::DataSet dataSet = testDataSet.Make3DRectilinearDataSet0();
|
||||
|
||||
/*
|
||||
dataSet.PrintSummary(std::cout);
|
||||
vtkm::cont::CoordinateSystem cs = dataSet.GetCoordinateSystem();
|
||||
vtkm::cont::DynamicArrayHandleCoordinateSystem dcs = cs.GetData();
|
||||
vtkm::cont::ArrayHandleCartesianProduct<
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32> > coords;
|
||||
dcs.CastToArrayHandle(coords);
|
||||
vtkm::Id n = dcs.GetNumberOfValues();
|
||||
vtkm::Vec<vtkm::Float32, 3> pt(0,0,0);
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
pt = coords.GetPortalConstControl().Get(i);
|
||||
std::cout<<i<<": ["<<pt[0]<<" "<<pt[1]<<" "<<pt[2]<<"]"<<std::endl;
|
||||
}
|
||||
*/
|
||||
|
||||
typedef vtkm::cont::CellSetStructured<3> CellSetType;
|
||||
CellSetType cellSet = dataSet.GetCellSet(0).CastTo<CellSetType>();
|
||||
|
||||
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
|
||||
"Incorrect number of cell sets");
|
||||
|
||||
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 2,
|
||||
"Incorrect number of fields");
|
||||
|
||||
VTKM_TEST_ASSERT(dataSet.GetNumberOfCoordinateSystems() == 1,
|
||||
"Incorrect number of coordinate systems");
|
||||
|
||||
VTKM_TEST_ASSERT(cellSet.GetNumberOfPoints() == 18,
|
||||
"Incorrect number of points");
|
||||
|
||||
VTKM_TEST_ASSERT(cellSet.GetNumberOfCells() == 4,
|
||||
"Incorrect number of cells");
|
||||
|
||||
try
|
||||
{
|
||||
dataSet.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
dataSet.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
VTKM_TEST_FAIL("Failed to get field 'pointvar' with ASSOC_POINT_SET.");
|
||||
}
|
||||
|
||||
vtkm::Id numCells = cellSet.GetNumberOfCells();
|
||||
for (vtkm::Id cellIndex = 0; cellIndex < numCells; cellIndex++)
|
||||
{
|
||||
VTKM_TEST_ASSERT(cellSet.GetNumberOfPointsInCell(cellIndex) == 8,
|
||||
"Incorrect number of cell indices");
|
||||
vtkm::IdComponent shape = cellSet.GetCellShape();
|
||||
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_HEXAHEDRON,
|
||||
"Incorrect element type.");
|
||||
}
|
||||
|
||||
//Test regular connectivity.
|
||||
vtkm::exec::ConnectivityStructured<
|
||||
vtkm::TopologyElementTagPoint,
|
||||
vtkm::TopologyElementTagCell,
|
||||
3> pointToCell =
|
||||
cellSet.PrepareForInput(
|
||||
vtkm::cont::DeviceAdapterTagSerial(),
|
||||
vtkm::TopologyElementTagPoint(),
|
||||
vtkm::TopologyElementTagCell());
|
||||
vtkm::Id expectedPointIds[8] = {0,1,4,3,6,7,10,9};
|
||||
vtkm::Vec<vtkm::Id,8> retrievedPointIds =
|
||||
pointToCell.GetIndices(vtkm::Id3(0));
|
||||
for (vtkm::IdComponent localPointIndex = 0;
|
||||
localPointIndex < 8;
|
||||
localPointIndex++)
|
||||
{
|
||||
VTKM_TEST_ASSERT(
|
||||
retrievedPointIds[localPointIndex] == expectedPointIds[localPointIndex],
|
||||
"Incorrect point ID for cell");
|
||||
}
|
||||
|
||||
vtkm::exec::ConnectivityStructured<
|
||||
vtkm::TopologyElementTagCell,
|
||||
vtkm::TopologyElementTagPoint,
|
||||
3> cellToPoint =
|
||||
cellSet.PrepareForInput(
|
||||
vtkm::cont::DeviceAdapterTagSerial(),
|
||||
vtkm::TopologyElementTagCell(),
|
||||
vtkm::TopologyElementTagPoint());
|
||||
vtkm::Id retrievedCellIds[6] = {0,-1,-1,-1,-1,-1};
|
||||
vtkm::VecVariable<vtkm::Id,6> expectedCellIds =
|
||||
cellToPoint.GetIndices(vtkm::Id3(0));
|
||||
VTKM_TEST_ASSERT(expectedCellIds.GetNumberOfComponents() <= 6,
|
||||
"Got unexpected number of cell ids");
|
||||
for (vtkm::IdComponent localPointIndex = 0;
|
||||
localPointIndex < expectedCellIds.GetNumberOfComponents();
|
||||
localPointIndex++)
|
||||
{
|
||||
VTKM_TEST_ASSERT(
|
||||
expectedCellIds[localPointIndex] == retrievedCellIds[localPointIndex],
|
||||
"Incorrect cell ID for point");
|
||||
}
|
||||
}
|
||||
|
||||
int UnitTestDataSetRectilinear(int, char *[])
|
||||
{
|
||||
return vtkm::cont::testing::Testing::Run(TestDataSet_Rectilinear);
|
||||
}
|
Loading…
Reference in New Issue
Block a user