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

Remove vtkm::BaseComponent

Browse Source 
This functionality has been superseded by VecTraits::BaseComponentType.
The new functionality also supports replacing the BaseComponentType.
This commit is contained in:
Kenneth Moreland 2019-09-09 13:01:03 -06:00
parent 07c59fcf72
commit 6c136b978e
12 changed files with 31 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
docs/changelog/vec-traits-base-components.md
View File

@ -32,3 +32,8 @@ using NewVec1 =
using NewVec1 =
typename vtkm::VecTraits<NestedVec>::template ReplaceBaseComponentType<vtkm::Float64>;
```
This functionality replaces the functionality in `vtkm::BaseComponent`. Unfortunately,
`vtkm::BaseComponent` did not have the ability to replace the base component and
there was no straightforward way to implement that outside of `VecTraits`.

64
vtkm/BaseComponent.h
View File

@ -1,64 +0,0 @@
//============================================================================
// 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.
//============================================================================
#ifndef vtk_m_BaseComponent_h
#define vtk_m_BaseComponent_h
#include <vtkm/Matrix.h>
#include <vtkm/TypeTraits.h>
#include <vtkm/VecTraits.h>
namespace vtkm
{
namespace detail
{
template <typename VecType, typename DimensionalityTag>
struct BaseComponentImpl;
template <typename VecType>
struct BaseComponentImpl<VecType, vtkm::TypeTraitsVectorTag>
{
private:
using ComponentType = typename vtkm::VecTraits<VecType>::ComponentType;
public:
using Type =
typename BaseComponentImpl<ComponentType,
typename vtkm::TypeTraits<ComponentType>::DimensionalityTag>::Type;
};
template <typename VecType>
struct BaseComponentImpl<VecType, vtkm::TypeTraitsMatrixTag>
: BaseComponentImpl<VecType, vtkm::TypeTraitsVectorTag>
{
};
template <typename ScalarType>
struct BaseComponentImpl<ScalarType, vtkm::TypeTraitsScalarTag>
{
using Type = ScalarType;
};
} // namespace detail
// Finds the base component type of a Vec. If you have a Vec of Vecs, it will
// descend all Vecs until you get to the scalar type.
template <typename VecType>
struct BaseComponent
{
using Type =
typename detail::BaseComponentImpl<VecType,
typename vtkm::TypeTraits<VecType>::DimensionalityTag>::Type;
};
} // namespace vtkm
#endif //vtk_m_BaseComponent_h

1
vtkm/CMakeLists.txt
View File

@ -18,7 +18,6 @@ vtkm_install_headers(
set(headers
Assert.h
BaseComponent.h
BinaryPredicates.h
BinaryOperators.h
Bitset.h

6
vtkm/cont/ArrayHandleCast.h
View File

@ -14,8 +14,8 @@
#include <vtkm/cont/Logging.h>
#include <vtkm/BaseComponent.h>
#include <vtkm/Range.h>
#include <vtkm/VecTraits.h>
#include <limits>
@ -70,8 +70,8 @@ private:
{
#ifdef VTKM_ENABLE_LOGGING
using DstValueType = T;
using SrcComp = typename vtkm::BaseComponent<SrcValueType>::Type;
using DstComp = typename vtkm::BaseComponent<DstValueType>::Type;
using SrcComp = typename vtkm::VecTraits<SrcValueType>::BaseComponentType;
using DstComp = typename vtkm::VecTraits<DstValueType>::BaseComponentType;
using SrcLimits = std::numeric_limits<SrcComp>;
using DstLimits = std::numeric_limits<DstComp>;

6
vtkm/cont/StorageExtrude.h
View File

@ -12,7 +12,7 @@
#include <vtkm/internal/IndicesExtrude.h>
#include <vtkm/BaseComponent.h>
#include <vtkm/VecTraits.h>
#include <vtkm/cont/ErrorBadType.h>
@ -371,7 +371,7 @@ struct VTKM_ALWAYS_EXPORT StorageTagExtrude
template <typename T>
class Storage<T, internal::StorageTagExtrude>
{
using BaseT = typename BaseComponent<T>::Type;
using BaseT = typename VecTraits<T>::BaseComponentType;
using HandleType = vtkm::cont::ArrayHandle<BaseT>;
using TPortalType = typename HandleType::PortalConstControl;
@ -461,7 +461,7 @@ private:
template <typename T, typename Device>
class VTKM_ALWAYS_EXPORT ArrayTransfer<T, internal::StorageTagExtrude, Device>
{
using BaseT = typename BaseComponent<T>::Type;
using BaseT = typename VecTraits<T>::BaseComponentType;
using TPortalType = decltype(vtkm::cont::ArrayHandle<BaseT>{}.PrepareForInput(Device{}));
public:

12
vtkm/exec/CellDerivative.h
View File

@ -11,11 +11,11 @@
#define vtk_m_exec_Derivative_h
#include <vtkm/Assert.h>
#include <vtkm/BaseComponent.h>
#include <vtkm/CellShape.h>
#include <vtkm/Math.h>
#include <vtkm/Matrix.h>
#include <vtkm/VecAxisAlignedPointCoordinates.h>
#include <vtkm/VecTraits.h>
#include <vtkm/VectorAnalysis.h>
#include <vtkm/exec/CellInterpolate.h>
@ -341,7 +341,7 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivativeFor2D
CellShapeTag)
{
using FieldType = typename FieldVecType::ComponentType;
using BaseFieldType = typename BaseComponent<FieldType>::Type;
using BaseFieldType = typename vtkm::VecTraits<FieldType>::BaseComponentType;
// We have an underdetermined system in 3D, so create a 2D space in the
// plane that the polygon sits.
@ -523,7 +523,7 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
VTKM_ASSERT(wCoords.GetNumberOfComponents() == 2);
using FieldType = typename FieldVecType::ComponentType;
using BaseComponentType = typename BaseComponent<FieldType>::Type;
using BaseComponentType = typename vtkm::VecTraits<FieldType>::BaseComponentType;
FieldType deltaField(field[1] - field[0]);
vtkm::Vec<BaseComponentType, 3> vec(wCoords[1] - wCoords[0]);
@ -571,7 +571,7 @@ VTKM_EXEC vtkm::Vec<typename FieldVecType::ComponentType, 3> CellDerivative(
}
using FieldType = typename FieldVecType::ComponentType;
using BaseComponentType = typename BaseComponent<FieldType>::Type;
using BaseComponentType = typename vtkm::VecTraits<FieldType>::BaseComponentType;
ParametricCoordType dt;
dt = static_cast<ParametricCoordType>(1) / static_cast<ParametricCoordType>(numPoints - 1);
@ -690,7 +690,7 @@ template <typename ValueType, typename WCoordType>
VTKM_EXEC vtkm::Vec<ValueType, 3> TriangleDerivative(const vtkm::Vec<ValueType, 3>& field,
const vtkm::Vec<WCoordType, 3>& wCoords)
{
using BaseComponentType = typename BaseComponent<ValueType>::Type;
using BaseComponentType = typename vtkm::VecTraits<ValueType>::BaseComponentType;
// The scalar values of the three points in a triangle completely specify a
// linear field (with constant gradient) assuming the field is constant in
@ -998,7 +998,7 @@ template <typename ValueType, typename WorldCoordType>
VTKM_EXEC vtkm::Vec<ValueType, 3> TetraDerivative(const vtkm::Vec<ValueType, 4>& field,
const vtkm::Vec<WorldCoordType, 4>& wCoords)
{
using BaseComponentType = typename BaseComponent<ValueType>::Type;
using BaseComponentType = typename vtkm::VecTraits<ValueType>::BaseComponentType;
// The scalar values of the four points in a tetrahedron completely specify a
// linear field (with constant gradient). The field, defined by the 3-vector

2
vtkm/worklet/Gradient.h
View File

@ -114,7 +114,7 @@ struct GradientOutputFields : public vtkm::cont::ExecutionObjectBase
{
using ValueType = T;
using BaseTType = typename vtkm::BaseComponent<T>::Type;
using BaseTType = typename vtkm::VecTraits<T>::BaseComponentType;
template <typename DeviceAdapter>
struct ExecutionTypes

10
vtkm/worklet/ScalarsToColors.hxx
View File

@ -10,7 +10,7 @@
#include <vtkm/worklet/ScalarsToColors.h>
#include <vtkm/BaseComponent.h>
#include <vtkm/VecTraits.h>
#include <vtkm/cont/ArrayHandleExtractComponent.h>
#include <vtkm/cont/ArrayHandleTransform.h>
@ -54,7 +54,7 @@ void ScalarsToColors::Run(const vtkm::cont::ArrayHandle<T, S>& values,
{
using namespace vtkm::worklet::colorconversion;
//If our shift is 0 and our scale == 1 no need to apply them
using BaseT = typename vtkm::BaseComponent<T>::Type;
using BaseT = typename vtkm::VecTraits<T>::BaseComponentType;
const bool shiftscale = needShiftScale(BaseT{}, this->Shift, this->Scale);
if (shiftscale)
{
@ -76,7 +76,7 @@ void ScalarsToColors::Run(const vtkm::cont::ArrayHandle<T, S>& values,
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8>& rgbOut) const
{
using namespace vtkm::worklet::colorconversion;
using BaseT = typename vtkm::BaseComponent<T>::Type;
using BaseT = typename vtkm::VecTraits<T>::BaseComponentType;
const bool shiftscale = needShiftScale(BaseT{}, this->Shift, this->Scale);
if (shiftscale)
{
@ -101,7 +101,7 @@ void ScalarsToColors::RunMagnitude(const vtkm::cont::ArrayHandle<vtkm::Vec<T, N>
//
using namespace vtkm::worklet::colorconversion;
//If our shift is 0 and our scale == 1 no need to apply them
using BaseT = typename vtkm::BaseComponent<T>::Type;
using BaseT = typename vtkm::VecTraits<T>::BaseComponentType;
const bool shiftscale = needShiftScale(BaseT{}, this->Shift, this->Scale);
if (shiftscale)
{
@ -126,7 +126,7 @@ void ScalarsToColors::RunMagnitude(const vtkm::cont::ArrayHandle<vtkm::Vec<T, N>
{
using namespace vtkm::worklet::colorconversion;
using BaseT = typename vtkm::BaseComponent<T>::Type;
using BaseT = typename vtkm::VecTraits<T>::BaseComponentType;
const bool shiftscale = needShiftScale(BaseT{}, this->Shift, this->Scale);
if (shiftscale)
{

10
vtkm/worklet/gradient/GradientOutput.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_worklet_gradient_GradientOutput_h
#define vtk_m_worklet_gradient_GradientOutput_h
#include <vtkm/BaseComponent.h>
#include <vtkm/VecTraits.h>
#include <vtkm/cont/arg/TransportTagArrayOut.h>
#include <vtkm/cont/arg/TransportTagExecObject.h>
@ -31,7 +31,7 @@ template <typename T, typename DeviceAdapter>
struct GradientScalarOutputExecutionObject
{
using ValueType = vtkm::Vec<T, 3>;
using BaseTType = typename vtkm::BaseComponent<T>::Type;
using BaseTType = typename vtkm::VecTraits<T>::BaseComponentType;
struct PortalTypes
{
@ -61,7 +61,7 @@ template <typename T>
struct GradientScalarOutput : public vtkm::cont::ExecutionObjectBase
{
using ValueType = vtkm::Vec<T, 3>;
using BaseTType = typename vtkm::BaseComponent<T>::Type;
using BaseTType = typename vtkm::VecTraits<T>::BaseComponentType;
template <typename Device>
VTKM_CONT vtkm::exec::GradientScalarOutputExecutionObject<T, Device> PrepareForExecution(
@ -93,7 +93,7 @@ template <typename T, typename DeviceAdapter>
struct GradientVecOutputExecutionObject
{
using ValueType = vtkm::Vec<T, 3>;
using BaseTType = typename vtkm::BaseComponent<T>::Type;
using BaseTType = typename vtkm::VecTraits<T>::BaseComponentType;
template <typename FieldType>
struct PortalTypes
@ -185,7 +185,7 @@ template <typename T>
struct GradientVecOutput : public vtkm::cont::ExecutionObjectBase
{
using ValueType = vtkm::Vec<T, 3>;
using BaseTType = typename vtkm::BaseComponent<T>::Type;
using BaseTType = typename vtkm::VecTraits<T>::BaseComponentType;
template <typename Device>
VTKM_CONT vtkm::exec::GradientVecOutputExecutionObject<T, Device> PrepareForExecution(

2
vtkm/worklet/gradient/PointGradient.h
View File

@ -78,7 +78,7 @@ struct PointGradient : public vtkm::worklet::WorkletVisitPointsWithCells
if (numCells != 0)
{
using BaseGradientType = typename vtkm::BaseComponent<ValueType>::Type;
using BaseGradientType = typename vtkm::VecTraits<ValueType>::BaseComponentType;
const BaseGradientType invNumCells =
static_cast<BaseGradientType>(1.) / static_cast<BaseGradientType>(numCells);

2
vtkm/worklet/gradient/StructuredPointGradient.h
View File

@ -47,7 +47,7 @@ struct StructuredPointGradient : public vtkm::worklet::WorkletPointNeighborhood
GradientOutType& outputGradient) const
{
using CoordType = typename PointsIn::ValueType;
using CT = typename vtkm::BaseComponent<CoordType>::Type;
using CT = typename vtkm::VecTraits<CoordType>::BaseComponentType;
using OT = typename GradientOutType::ComponentType;
vtkm::Vec<CT, 3> xi, eta, zeta;

2
vtkm/worklet/testing/UnitTestScalarsToColors.cxx
View File

@ -80,7 +80,7 @@ vtkm::Vec4ui_8 as_color<vtkm::Vec4ui_8>(vtkm::Float32 v, vtkm::Float32 alpha)
template <typename T>
vtkm::cont::ArrayHandle<T> make_data(const vtkm::Range& r)
{
using BaseT = typename vtkm::BaseComponent<T>::Type;
using BaseT = typename vtkm::VecTraits<T>::BaseComponentType;
vtkm::Float32 shift, scale;
vtkm::worklet::colorconversion::ComputeShiftScale(r, shift, scale);
const bool shiftscale = vtkm::worklet::colorconversion::needShiftScale(BaseT{}, shift, scale);