Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 18:45:43 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
e11f612add
vtk-m/vtkm/cont/ArrayHandleCompositeVector.h

705 lines
20 KiB
C
Raw Normal View History

Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
conslidate the license statement
2019-04-15 23:24:21 +00:00
//
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
// 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_ArrayHandleCompositeVector_h
#define vtk_m_ArrayHandleCompositeVector_h
#include <vtkm/cont/ArrayHandle.h>
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
#include <vtkm/Deprecated.h>
Declare new VTKM_STATIC_ASSERT This is to be used in place of BOOST_STATIC_ASSERT so that we can control its implementation. The implementation is designed to fix the issue where the latest XCode clang compiler gives a warning about a unused typedefs when the boost static assert is used within a function. (This warning also happens when using the C++11 static_assert keyword.) You can suppress this warning with _Pragma commands, but _Pragma commands inside a block is not supported in GCC. The implementation of VTKM_STATIC_ASSERT handles all current cases.
2015-09-17 19:45:35 +00:00
#include <vtkm/StaticAssert.h>
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
#include <vtkm/Tuple.h>
Change VectorTraits to VecTraits. Matches the previous move from Tuple to Vec. We can unify on this name.
2014-10-07 23:27:31 +00:00
#include <vtkm/VecTraits.h>
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Ensure that Portal::Set isn't defined for read-only portals. This patch removes (or conditionally removes) the Set method from portals that are read-only so that IsWritableArrayHandle will work as expected. The ArrayPortal doxygen has been updated to reflect this. The remaining exceptions are `ArrayPortalVirtual` and `ArrayPortalMultiplexer`, since their mutability cannot be determined at compile time.
2019-09-13 15:42:33 +00:00
#include <vtkm/internal/brigand.hpp>
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
#include <vtkmstd/integer_sequence.h>
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
#include <type_traits>
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace vtkm
{
namespace cont
{
namespace internal
{
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
namespace compvec
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
// AllAreArrayHandles: ---------------------------------------------------------
// Ensures that all types in ArrayHandlesT... are subclasses of ArrayHandleBase
template <typename... ArrayHandlesT>
struct AllAreArrayHandlesImpl;
template <typename Head, typename... Tail>
struct AllAreArrayHandlesImpl<Head, Tail...>
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
private:
using Next = AllAreArrayHandlesImpl<Tail...>;
constexpr static bool HeadValid = std::is_base_of<ArrayHandleBase, Head>::value;
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
public:
constexpr static bool Value = HeadValid && Next::Value;
};
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
template <typename Head>
struct AllAreArrayHandlesImpl<Head>
{
constexpr static bool Value = std::is_base_of<ArrayHandleBase, Head>::value;
};
template <typename... ArrayHandleTs>
struct AllAreArrayHandles
{
constexpr static bool Value = AllAreArrayHandlesImpl<ArrayHandleTs...>::Value;
};
// GetValueType: ---------------------------------------------------------------
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
// Determines the output `ValueType` of the set of `ArrayHandle` objects. For example, if the input
// set contains 3 types with `vtkm::Float32` ValueTypes, then the ValueType defined here will be
// `vtkm::Vec<Float32, 3>`. This also validates that all members have the same `ValueType`.
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename ExpectedValueType, typename ArrayType>
constexpr bool CheckValueType()
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
VTKM_STATIC_ASSERT_MSG((std::is_same<ExpectedValueType, typename ArrayType::ValueType>::value),
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
"ArrayHandleCompositeVector must be built from "
"ArrayHandles with the same ValueTypes.");
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return std::is_same<ExpectedValueType, typename ArrayType::ValueType>::value;
}
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename ArrayType0, typename... ArrayTypes>
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
struct GetValueType
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
static constexpr vtkm::IdComponent COUNT =
static_cast<vtkm::IdComponent>(sizeof...(ArrayTypes)) + 1;
using ComponentType = typename ArrayType0::ValueType;
static constexpr std::array<bool, sizeof...(ArrayTypes) + 1> ValueCheck{
{ true, CheckValueType<ComponentType, ArrayTypes>()... }
};
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
using ValueType = vtkm::Vec<ComponentType, COUNT>;
};
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
// Special case for only one component
template <typename ArrayType>
struct GetValueType<ArrayType>
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
static constexpr vtkm::IdComponent COUNT = 1;
using ComponentType = typename ArrayType::ValueType;
using ValueType = typename ArrayType::ValueType;
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
};
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
// -----------------------------------------------------------------------------
// Functors to access Storage methods. This is used with vtkm::Tuple's
// ForEach and Transform methods.
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
struct WritePortal
{
template <typename ArrayHandle>
typename ArrayHandle::WritePortalType operator()(const ArrayHandle& array) const
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return array.WritePortal();
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
};
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
struct ReadPortal
{
template <typename ArrayHandle>
typename ArrayHandle::ReadPortalType operator()(const ArrayHandle& array) const
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return array.ReadPortal();
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
};
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
struct Allocate
{
vtkm::Id NumValues;
VTKM_CONT Allocate(vtkm::Id numValues)
: NumValues(numValues)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename Array>
VTKM_CONT void operator()(Array& array)
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
array.Allocate(this->NumValues);
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
};
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
struct Shrink
{
vtkm::Id NumValues;
VTKM_CONT Shrink(vtkm::Id numValues)
: NumValues(numValues)
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
{
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename Array>
VTKM_CONT void operator()(Array& array)
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
array.Shrink(this->NumValues);
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
};
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
struct ReleaseResources
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename Array>
VTKM_CONT void operator()(Array& array)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
array.ReleaseResources();
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
};
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
// -----------------------------------------------------------------------------
// Functors to access ArrayTransfer methods. This is used with vtkm::Tuple's
// ForEach and Transform methods.
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename Device>
struct PrepareForInput
{
vtkm::cont::Token& Token;
VTKM_CONT PrepareForInput(vtkm::cont::Token& token)
: Token(token)
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
{
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename Array>
VTKM_CONT typename Array::template ExecutionTypes<Device>::PortalConst operator()(
const Array& array)
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return array.PrepareForInput(Device{}, this->Token);
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
}
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
};
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename Device>
struct PrepareForInPlace
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
vtkm::cont::Token& Token;
VTKM_CONT PrepareForInPlace(vtkm::cont::Token& token)
: Token(token)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename Array>
VTKM_CONT typename Array::template ExecutionTypes<Device>::Portal operator()(Array& array)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return array.PrepareForInPlace(Device{}, this->Token);
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
};
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename Device>
struct PrepareForOutput
{
vtkm::Id NumValues;
vtkm::cont::Token& Token;
VTKM_CONT PrepareForOutput(vtkm::Id numValues, vtkm::cont::Token& token)
: NumValues(numValues)
, Token(token)
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
{
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename Array>
VTKM_CONT typename Array::template ExecutionTypes<Device>::Portal operator()(Array& array)
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return array.PrepareForOutput(this->NumValues, Device{}, this->Token);
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
};
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
struct ReleaseResourcesExecution
{
template <typename Array>
VTKM_CONT void operator()(Array& array)
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
array.ReleaseResourcesExecution();
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
};
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
// ArraySizeValidator: ---------------------------------------------------------
// Call Exec(ArrayTuple, NumValues) to ensure that all arrays in the tuple have
// the specified number of values.
template <std::size_t Index, std::size_t Count, typename TupleType>
struct ArraySizeValidatorImpl
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
using Next = ArraySizeValidatorImpl<Index + 1, Count, TupleType>;
Correct more host/device warnings from methods that should be host only
2019-04-29 17:15:42 +00:00
VTKM_CONT
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
static bool Exec(const TupleType& tuple, vtkm::Id numVals)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return vtkm::Get<Index>(tuple).GetNumberOfValues() == numVals && Next::Exec(tuple, numVals);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
}
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
};
template <std::size_t Index, typename TupleType>
struct ArraySizeValidatorImpl<Index, Index, TupleType>
{
Correct more host/device warnings from methods that should be host only
2019-04-29 17:15:42 +00:00
VTKM_CONT
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
static bool Exec(const TupleType&, vtkm::Id) { return true; }
};
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
template <typename TupleType>
struct ArraySizeValidator
{
Correct more host/device warnings from methods that should be host only
2019-04-29 17:15:42 +00:00
VTKM_CONT
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
static bool Exec(const TupleType& tuple, vtkm::Id numVals)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return ArraySizeValidatorImpl<0, vtkm::TupleSize<TupleType>::value, TupleType>::Exec(tuple,
numVals);
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
};
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename... PortalList>
Ensure that Portal::Set isn't defined for read-only portals. This patch removes (or conditionally removes) the Set method from portals that are read-only so that IsWritableArrayHandle will work as expected. The ArrayPortal doxygen has been updated to reflect this. The remaining exceptions are `ArrayPortalVirtual` and `ArrayPortalMultiplexer`, since their mutability cannot be determined at compile time.
2019-09-13 15:42:33 +00:00
using AllPortalsAreWritable =
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
typename brigand::all<brigand::list<PortalList...>,
Ensure that Portal::Set isn't defined for read-only portals. This patch removes (or conditionally removes) the Set method from portals that are read-only so that IsWritableArrayHandle will work as expected. The ArrayPortal doxygen has been updated to reflect this. The remaining exceptions are `ArrayPortalVirtual` and `ArrayPortalMultiplexer`, since their mutability cannot be determined at compile time.
2019-09-13 15:42:33 +00:00
brigand::bind<vtkm::internal::PortalSupportsSets, brigand::_1>>::type;
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
// GetFromPortals: -------------------------------------------------------------
// Given a set of array portals as arguments, returns a Vec comprising the values
// at the provided index.
VTKM_SUPPRESS_EXEC_WARNINGS
template <typename... Portals>
VTKM_EXEC_CONT typename GetValueType<Portals...>::ValueType GetFromPortals(
vtkm::Id index,
const Portals&... portals)
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return { portals.Get(index)... };
}
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
// SetToPortals: ---------------------------------------------------------------
// Given a Vec-like object, and index, and a set of array portals, sets each of
// the portals to the respective component of the Vec.
VTKM_SUPPRESS_EXEC_WARNINGS
template <typename ValueType, vtkm::IdComponent... I, typename... Portals>
VTKM_EXEC_CONT void SetToPortalsImpl(vtkm::Id index,
const ValueType& value,
vtkmstd::integer_sequence<vtkm::IdComponent, I...>,
const Portals&... portals)
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
using Traits = vtkm::VecTraits<ValueType>;
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
(void)std::initializer_list<bool>{ (portals.Set(index, Traits::GetComponent(value, I)),
false)... };
}
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
template <typename ValueType, typename... Portals>
VTKM_EXEC_CONT void SetToPortals(vtkm::Id index, const ValueType& value, const Portals&... portals)
{
SetToPortalsImpl(
index,
value,
vtkmstd::make_integer_sequence<vtkm::IdComponent, vtkm::IdComponent(sizeof...(Portals))>{},
portals...);
}
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
} // end namespace compvec
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
template <typename... PortalTypes>
class VTKM_ALWAYS_EXPORT ArrayPortalCompositeVector
{
using Writable = compvec::AllPortalsAreWritable<PortalTypes...>;
using TupleType = vtkm::Tuple<PortalTypes...>;
TupleType Portals;
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
public:
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
using ValueType = typename compvec::GetValueType<PortalTypes...>::ValueType;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
ArrayPortalCompositeVector() {}
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
ArrayPortalCompositeVector(const PortalTypes&... portals)
: Portals(portals...)
{
}
VTKM_CONT
ArrayPortalCompositeVector(const TupleType& portals)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
: Portals(portals)
{
}
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
vtkm::Id GetNumberOfValues() const { return vtkm::Get<0>(this->Portals).GetNumberOfValues(); }
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
ValueType Get(vtkm::Id index) const
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return this->Portals.Apply(compvec::GetFromPortals<PortalTypes...>, index);
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Ensure that Portal::Set isn't defined for read-only portals. This patch removes (or conditionally removes) the Set method from portals that are read-only so that IsWritableArrayHandle will work as expected. The ArrayPortal doxygen has been updated to reflect this. The remaining exceptions are `ArrayPortalVirtual` and `ArrayPortalMultiplexer`, since their mutability cannot be determined at compile time.
2019-09-13 15:42:33 +00:00
template <typename Writable_ = Writable,
typename = typename std::enable_if<Writable_::value>::type>
VTKM_EXEC_CONT void Set(vtkm::Id index, const ValueType& value) const
Make sure all ArrayPortals have a Set method. The current design for ArrayPortalVirtual makes it a requirement for all array portals (that it wraps) to have Set defined. Thus, make sure Set is defined for all ArrayPortal. Where Set is invalid, an assert is thrown if something calls it at runtime.
2017-01-31 19:13:45 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
this->Portals.Apply(compvec::SetToPortals<ValueType, PortalTypes...>, index, value);
Make sure all ArrayPortals have a Set method. The current design for ArrayPortalVirtual makes it a requirement for all array portals (that it wraps) to have Set defined. Thus, make sure Set is defined for all ArrayPortal. Where Set is invalid, an assert is thrown if something calls it at runtime.
2017-01-31 19:13:45 +00:00
}
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
};
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
} // namespace internal
template <typename... StorageTags>
struct VTKM_ALWAYS_EXPORT StorageTagCompositeVec
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
};
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
namespace internal
{
template <typename... ArrayTs>
struct CompositeVectorTraits
{
// Need to check this here, since this traits struct is used in the
// ArrayHandleCompositeVector superclass definition before any other
// static_asserts could be used.
VTKM_STATIC_ASSERT_MSG(compvec::AllAreArrayHandles<ArrayTs...>::Value,
"Template parameters for ArrayHandleCompositeVector "
"must be a list of ArrayHandle types.");
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
using ValueType = typename compvec::GetValueType<ArrayTs...>::ValueType;
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
using StorageTag = vtkm::cont::StorageTagCompositeVec<typename ArrayTs::StorageTag...>;
using StorageType = Storage<ValueType, StorageTag>;
using Superclass = ArrayHandle<ValueType, StorageTag>;
};
template <typename T, typename... StorageTags>
class Storage<vtkm::Vec<T, static_cast<vtkm::IdComponent>(sizeof...(StorageTags))>,
vtkm::cont::StorageTagCompositeVec<StorageTags...>>
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
using ArrayTuple = vtkm::Tuple<vtkm::cont::ArrayHandle<T, StorageTags>...>;
ArrayTuple Arrays;
bool Valid;
Support control array portals in composite vector. Previously, the ArrayHandleCompositeVector had a separate implementation of ArrayPortal for the control and execution environments. Because I was lazy when I implemented it, the control version did not support Get. Since originally implementing this class, VTK-m now allows defining methods that are declared as working in both control and execution environments (VTKM_EXEC_CONT_EXPORT) but only work in one or the other depending on methods of templated subclasses they call. Thus, solve this problem by simply removing the control version of the portal and use the same portal for both.
2016-01-04 19:53:56 +00:00
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
public:
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
using ValueType = vtkm::Vec<T, static_cast<vtkm::IdComponent>(sizeof...(StorageTags))>;
using PortalType = ArrayPortalCompositeVector<
typename vtkm::cont::ArrayHandle<T, StorageTags>::WritePortalType...>;
using PortalConstType =
ArrayPortalCompositeVector<typename vtkm::cont::ArrayHandle<T, StorageTags>::ReadPortalType...>;
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Storage()
: Valid(false)
{
}
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Fix name clash of template parameter and field
2020-01-06 22:31:14 +00:00
template <typename... ArrayTypes>
VTKM_CONT Storage(const ArrayTypes&... arrays)
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
: Arrays(arrays...)
, Valid(true)
{
using SizeValidator = compvec::ArraySizeValidator<ArrayTuple>;
if (!SizeValidator::Exec(this->Arrays, this->GetNumberOfValues()))
{
throw ErrorBadValue("All arrays must have the same number of values.");
}
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
PortalType GetPortal()
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
VTKM_ASSERT(this->Valid);
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return this->Arrays.Transform(compvec::WritePortal{});
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
void TypeCheck(int) const;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
PortalConstType GetPortalConst() const
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
VTKM_ASSERT(this->Valid);
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
this->Arrays.Transform(compvec::ReadPortal{});
return this->Arrays.Transform(compvec::ReadPortal{});
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Id GetNumberOfValues() const
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
VTKM_ASSERT(this->Valid);
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return vtkm::Get<0>(this->Arrays).GetNumberOfValues();
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
void Allocate(vtkm::Id numValues)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
VTKM_ASSERT(this->Valid);
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
this->Arrays.ForEach(compvec::Allocate{ numValues });
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
void Shrink(vtkm::Id numValues)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
VTKM_ASSERT(this->Valid);
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
this->Arrays.ForEach(compvec::Shrink{ numValues });
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
void ReleaseResources()
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
VTKM_ASSERT(this->Valid);
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
this->Arrays.ForEach(compvec::ReleaseResources{});
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
const ArrayTuple& GetArrayTuple() const
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Valid);
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
return this->Arrays;
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
ArrayTuple& GetArrayTuple()
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Valid);
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
return this->Arrays;
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
};
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
// Special case for single component. Just defer to the original storage.
template <typename T, typename StorageTag>
class Storage<T, vtkm::cont::StorageTagCompositeVec<StorageTag>> : public Storage<T, StorageTag>
{
using ArrayType = vtkm::cont::ArrayHandle<T, StorageTag>;
using TupleType = vtkm::Tuple<ArrayType>;
public:
Storage() = default;
Storage(const ArrayType& array)
: Storage<T, StorageTag>(array.GetStorage())
{
}
VTKM_CONT
const TupleType GetArrayTuple() const { return TupleType(ArrayType(this->GetStoragea())); }
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
};
template <typename T, typename... StorageTags, typename DeviceTag>
class ArrayTransfer<vtkm::Vec<T, static_cast<vtkm::IdComponent>(sizeof...(StorageTags))>,
vtkm::cont::StorageTagCompositeVec<StorageTags...>,
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
DeviceTag>
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
VTKM_IS_DEVICE_ADAPTER_TAG(DeviceTag);
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
using ArrayTuple = vtkm::Tuple<vtkm::cont::ArrayHandle<T, StorageTags>...>;
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
public:
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
using ValueType = vtkm::Vec<T, static_cast<vtkm::IdComponent>(sizeof...(StorageTags))>;
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
private:
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
using StorageTag = vtkm::cont::StorageTagCompositeVec<StorageTags...>;
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
using StorageType = internal::Storage<ValueType, StorageTag>;
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
StorageType* Storage;
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
public:
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
using PortalControl = typename StorageType::PortalType;
using PortalConstControl = typename StorageType::PortalConstType;
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
clang-format: reformat the repository with clang-format-9
2020-08-17 14:18:24 +00:00
using PortalExecution =
ArrayPortalCompositeVector<typename vtkm::cont::ArrayHandle<T, StorageTags>::
template ExecutionTypes<DeviceTag>::Portal...>;
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
using PortalConstExecution =
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
ArrayPortalCompositeVector<typename vtkm::cont::ArrayHandle<T, StorageTags>::
template ExecutionTypes<DeviceTag>::PortalConst...>;
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
ArrayTransfer(StorageType* storage)
: Storage(storage)
{
}
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Id GetNumberOfValues() const { return this->Storage->GetNumberOfValues(); }
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Support using Token calling PrepareForExecution in ExecutionObject The old version of ExecutionObject (that only takes a device) is still supported, but you will get a deprecated warning if that is what is defined. Supporing this also included sending vtkm::cont::Token through the vtkm::cont::arg::Transport mechanism, which was a change that propogated through a lot of code.
2020-01-19 06:36:14 +00:00
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token) const
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return this->GetArrayTuple().Transform(compvec::PrepareForInput<DeviceTag>{ token });
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Support using Token calling PrepareForExecution in ExecutionObject The old version of ExecutionObject (that only takes a device) is still supported, but you will get a deprecated warning if that is what is defined. Supporing this also included sending vtkm::cont::Token through the vtkm::cont::arg::Transport mechanism, which was a change that propogated through a lot of code.
2020-01-19 06:36:14 +00:00
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return this->GetArrayTuple().Transform(compvec::PrepareForInPlace<DeviceTag>{ token });
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Support using Token calling PrepareForExecution in ExecutionObject The old version of ExecutionObject (that only takes a device) is still supported, but you will get a deprecated warning if that is what is defined. Supporing this also included sending vtkm::cont::Token through the vtkm::cont::arg::Transport mechanism, which was a change that propogated through a lot of code.
2020-01-19 06:36:14 +00:00
PortalExecution PrepareForOutput(vtkm::Id numValues, vtkm::cont::Token& token)
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
return this->GetArrayTuple().Transform(
compvec::PrepareForOutput<DeviceTag>{ numValues, token });
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
void RetrieveOutputData(StorageType* vtkmNotUsed(storage)) const
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
// Implementation of this method should be unnecessary. The internal
// array handle should automatically retrieve the output data as
// necessary.
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
void Shrink(vtkm::Id numValues) { this->GetArrayTuple().ForEach(compvec::Shrink{ numValues }); }
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
void ReleaseResources() { this->GetArrayTuple().ForEach(compvec::ReleaseResourcesExecution{}); }
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
VTKM_CONT
const ArrayTuple& GetArrayTuple() const { return this->Storage->GetArrayTuple(); }
ArrayTuple& GetArrayTuple() { return this->Storage->GetArrayTuple(); }
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
};
} // namespace internal
/// \brief An \c ArrayHandle that combines components from other arrays.
///
/// \c ArrayHandleCompositeVector is a specialization of \c ArrayHandle that
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
/// derives its content from other arrays. It takes any number of
/// single-component \c ArrayHandle objects and mimics an array that contains
/// vectors with components that come from these delegate arrays.
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
///
/// The easiest way to create and type an \c ArrayHandleCompositeVector is
/// to use the \c make_ArrayHandleCompositeVector functions.
///
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
/// The \c ArrayHandleExtractComponent class may be helpful when a desired
/// component is part of an \c ArrayHandle with a \c vtkm::Vec \c ValueType.
///
template <typename... ArrayTs>
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
class ArrayHandleCompositeVector
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
: public ArrayHandle<typename internal::CompositeVectorTraits<ArrayTs...>::ValueType,
typename internal::CompositeVectorTraits<ArrayTs...>::StorageTag>
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
private:
using Traits = internal::CompositeVectorTraits<ArrayTs...>;
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
using TupleType = vtkm::Tuple<ArrayTs...>;
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
using StorageType = typename Traits::StorageType;
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
public:
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
VTKM_ARRAY_HANDLE_SUBCLASS(ArrayHandleCompositeVector,
(ArrayHandleCompositeVector<ArrayTs...>),
(typename Traits::Superclass));
Explicitly add destructors and copy constructors to ArrayHandle classes Under CUDA, the default constructors and destructors created are exported as __host__ and __device__, which causes problems because they used a boost pointer that only works on the host. The explicit copy constructors and destructors do the same thing as the default ones except declared to only work on the host.
2015-10-21 13:11:38 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
ArrayHandleCompositeVector(const ArrayTs&... arrays)
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
: Superclass(StorageType(arrays...))
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
}
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
};
/// Create a composite vector array from other arrays.
///
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
template <typename... ArrayTs>
VTKM_CONT ArrayHandleCompositeVector<ArrayTs...> make_ArrayHandleCompositeVector(
const ArrayTs&... arrays)
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
{
Refactor ArrayHandleCompositeVector to simplify usage and impl. - Use tao::tuple instead of FunctionInterface to hold array/portal collections. - Type signatures are simplified. Now just use: - ArrayHandleCompositeVector<ArrayT1, ArrayT2, ...> - make_ArrayHandleCompositeVector(array1, array2, ...) instead of relying on helper structs to determine types. - No longer support component selection from an input array. All input arrays must have the same ValueType (See ArrayHandleSwizzle and ArrayHandleExtractComponent as the replacements for these usecases.
2018-05-10 17:06:08 +00:00
VTKM_STATIC_ASSERT_MSG(internal::compvec::AllAreArrayHandles<ArrayTs...>::Value,
"Arguments to make_ArrayHandleCompositeVector must be "
"of ArrayHandle types.");
return ArrayHandleCompositeVector<ArrayTs...>(arrays...);
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
}
}
} // namespace vtkm::cont
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
//=============================================================================
// Specializations of serialization related classes
Don't generate doxygen for serialization helpers
2019-09-12 21:19:36 +00:00
/// @cond SERIALIZATION
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
namespace vtkm
{
namespace cont
{
template <typename... AHs>
Clarify intent of TypeString and TypeName functions. TypeName is used for logging, and is now TypeToString. TypeString is used for serialization, and is now SerializableTypeString.
2019-02-28 18:15:27 +00:00
struct SerializableTypeString<vtkm::cont::ArrayHandleCompositeVector<AHs...>>
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
Clarify intent of TypeString and TypeName functions. TypeName is used for logging, and is now TypeToString. TypeString is used for serialization, and is now SerializableTypeString.
2019-02-28 18:15:27 +00:00
"AH_CompositeVector<" + internal::GetVariadicSerializableTypeString(AHs{}...) + ">";
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
return name;
}
};
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
template <typename T, typename... STs>
struct SerializableTypeString<
vtkm::cont::ArrayHandle<vtkm::Vec<T, static_cast<vtkm::IdComponent>(sizeof...(STs))>,
vtkm::cont::StorageTagCompositeVec<STs...>>>
: SerializableTypeString<
vtkm::cont::ArrayHandleCompositeVector<vtkm::cont::ArrayHandle<T, STs>...>>
{
};
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
}
} // vtkm::cont
VTK-m now doesn't clobber external DIY installations Fixes #334
2019-02-05 16:02:29 +00:00
namespace mangled_diy_namespace
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
{
template <typename... AHs>
struct Serialization<vtkm::cont::ArrayHandleCompositeVector<AHs...>>
{
private:
using Type = typename vtkm::cont::ArrayHandleCompositeVector<AHs...>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
struct SaveFunctor
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
BinaryBuffer& Buffer;
SaveFunctor(BinaryBuffer& bb)
: Buffer(bb)
{
}
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
template <typename AH>
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
void operator()(const AH& ah) const
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
vtkmdiy::save(this->Buffer, ah);
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
}
};
struct LoadFunctor
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
BinaryBuffer& Buffer;
LoadFunctor(BinaryBuffer& bb)
: Buffer(bb)
{
}
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
template <typename AH>
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
void operator()(AH& ah) const
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
vtkmdiy::load(this->Buffer, ah);
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
}
};
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
static BaseType Create(const AHs&... arrays) { return Type(arrays...); }
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
obj.GetStorage().GetArrayTuple().ForEach(SaveFunctor{ bb });
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
Move from tao::tuple to vtkm::Tuple The new version of vtkm::Tuple should be faster. It also gives us more control over the implementation and can provide some VTK-m specific things.
2020-02-25 22:11:10 +00:00
vtkm::Tuple<AHs...> tuple;
tuple.ForEach(LoadFunctor{ bb });
obj = tuple.Apply(Create);
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
}
};
Shorten tag name for ArrayHandleCompositeVector
2019-12-20 00:14:32 +00:00
template <typename T, typename... STs>
struct Serialization<
vtkm::cont::ArrayHandle<vtkm::Vec<T, static_cast<vtkm::IdComponent>(sizeof...(STs))>,
vtkm::cont::StorageTagCompositeVec<STs...>>>
: Serialization<vtkm::cont::ArrayHandleCompositeVector<vtkm::cont::ArrayHandle<T, STs>...>>
{
};
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
} // diy
Don't generate doxygen for serialization helpers
2019-09-12 21:19:36 +00:00
/// @endcond SERIALIZATION
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
#endif //vtk_m_ArrayHandleCompositeVector_h
Reference in New Issue Copy Permalink