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
3297dbab41
vtk-m/vtkm/cont/ArrayHandleCompositeVector.h

672 lines
24 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.
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
The Copyright statement now has all the periods in the correct location.
2015-05-21 12:09:22 +00:00
// Copyright 2014 Los Alamos National Security.
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
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_ArrayHandleCompositeVector_h
#define vtk_m_ArrayHandleCompositeVector_h
#include <vtkm/cont/ArrayHandle.h>
Simplify exception hierarchy. Remove the ErrorControl class such that all subclasses now inherit from error. Renamed all exception classes via s/ErrorControl/Error/. See issue #57.
2017-01-09 21:15:32 +00:00
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/ErrorInternal.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
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>
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
#include <vtkm/internal/FunctionInterface.h>
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
#include <sstream>
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace vtkm
{
namespace cont
{
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
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
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace detail
{
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ValueType>
Make sure all custom storage containers are exported.
2016-12-19 19:39:17 +00:00
struct VTKM_ALWAYS_EXPORT CompositeVectorSwizzleFunctor
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
static const vtkm::IdComponent NUM_COMPONENTS = vtkm::VecTraits<ValueType>::NUM_COMPONENTS;
Change vtkm::Tuple to vtkm::Vec There are multiple reasons for this name change: * The name Tuple conflicts with the boost::Tuple class, which as a different interface and feature set. This gets confusing, especially since VTK-m uses boost quite a bit. * The use of this class is usually (although not always) as a mathematical vector. * The vtkm::Scalar and vtkm::Vector* classes are going to go away soon to better support multiple base data type widths. Having this abbriviated name will hopefully make the code a bit nicer when these types have to be explicitly specified. Also modified the implementation a bit to consolidate some of the code.
2014-10-07 23:17:03 +00:00
typedef vtkm::Vec<vtkm::IdComponent, NUM_COMPONENTS> ComponentMapType;
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
// Caution! This is a reference.
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
const ComponentMapType& SourceComponents;
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
CompositeVectorSwizzleFunctor(const ComponentMapType& sourceComponents)
: SourceComponents(sourceComponents)
{
}
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
// Currently only supporting 1-4 components.
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T1>
VTKM_EXEC_CONT ValueType operator()(const T1& p1) const
{
return ValueType(vtkm::VecTraits<T1>::GetComponent(p1, this->SourceComponents[0]));
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T1, typename T2>
VTKM_EXEC_CONT ValueType operator()(const T1& p1, const T2& p2) const
{
return ValueType(vtkm::VecTraits<T1>::GetComponent(p1, this->SourceComponents[0]),
vtkm::VecTraits<T2>::GetComponent(p2, this->SourceComponents[1]));
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T1, typename T2, typename T3>
VTKM_EXEC_CONT ValueType operator()(const T1& p1, const T2& p2, const T3& p3) const
{
return ValueType(vtkm::VecTraits<T1>::GetComponent(p1, this->SourceComponents[0]),
vtkm::VecTraits<T2>::GetComponent(p2, this->SourceComponents[1]),
vtkm::VecTraits<T3>::GetComponent(p3, this->SourceComponents[2]));
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T1, typename T2, typename T3, typename T4>
VTKM_EXEC_CONT ValueType operator()(const T1& p1, const T2& p2, const T3& p3, const T4& p4) const
{
return ValueType(vtkm::VecTraits<T1>::GetComponent(p1, this->SourceComponents[0]),
vtkm::VecTraits<T2>::GetComponent(p2, this->SourceComponents[1]),
vtkm::VecTraits<T3>::GetComponent(p3, this->SourceComponents[2]),
vtkm::VecTraits<T4>::GetComponent(p4, this->SourceComponents[3]));
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ReturnValueType>
Make sure all custom storage containers are exported.
2016-12-19 19:39:17 +00:00
struct VTKM_ALWAYS_EXPORT CompositeVectorPullValueFunctor
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
{
vtkm::Id Index;
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
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CompositeVectorPullValueFunctor(vtkm::Id index)
: Index(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
// This form is to pull values out of array arguments.
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
VTKM_SUPPRESS_EXEC_WARNINGS
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename PortalType>
VTKM_EXEC_CONT typename PortalType::ValueType operator()(const PortalType& portal) 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
return portal.Get(this->Index);
}
// This form is an identity to pass the return value back.
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
const ReturnValueType& operator()(const ReturnValueType& value) const { return 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
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
struct CompositeVectorArrayToPortalCont
{
template <typename ArrayHandleType, vtkm::IdComponent Index>
struct ReturnType
{
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
typedef typename ArrayHandleType::PortalConstControl type;
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType, vtkm::IdComponent Index>
VTKM_CONT typename ReturnType<ArrayHandleType, Index>::type operator()(
const ArrayHandleType& array, vtkm::internal::IndexTag<Index>) 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
return array.GetPortalConstControl();
}
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename DeviceAdapterTag>
struct CompositeVectorArrayToPortalExec
{
template <typename ArrayHandleType, vtkm::IdComponent Index>
struct ReturnType
{
typedef typename ArrayHandleType::template ExecutionTypes<DeviceAdapterTag>::PortalConst type;
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType, vtkm::IdComponent Index>
VTKM_CONT typename ReturnType<ArrayHandleType, Index>::type operator()(
const ArrayHandleType& array, vtkm::internal::IndexTag<Index>) 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
return array.PrepareForInput(DeviceAdapterTag());
}
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
struct CheckArraySizeFunctor
{
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
vtkm::Id ExpectedSize;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CheckArraySizeFunctor(vtkm::Id expectedSize)
: ExpectedSize(expectedSize)
{
}
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T, vtkm::IdComponent Index>
void operator()(const T& a, vtkm::internal::IndexTag<Index>) 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
if (a.GetNumberOfValues() != this->ExpectedSize)
{
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
std::stringstream message;
message << "All input arrays to ArrayHandleCompositeVector must be the same size.\n"
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
<< "Array " << Index - 1 << " has " << a.GetNumberOfValues() << ". Expected "
<< this->ExpectedSize << ".";
Simplify exception hierarchy. Remove the ErrorControl class such that all subclasses now inherit from error. Renamed all exception classes via s/ErrorControl/Error/. See issue #57.
2017-01-09 21:15:32 +00:00
throw vtkm::cont::ErrorBadValue(message.str().c_str());
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 detail
/// \brief A portal that gets values from components of other portals.
///
/// This is the portal used within ArrayHandleCompositeVector.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename SignatureWithPortals>
Make sure all custom storage containers are exported.
2016-12-19 19:39:17 +00:00
class VTKM_ALWAYS_EXPORT 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
{
typedef vtkm::internal::FunctionInterface<SignatureWithPortals> PortalTypes;
public:
typedef typename PortalTypes::ResultType ValueType;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
static const vtkm::IdComponent NUM_COMPONENTS = vtkm::VecTraits<ValueType>::NUM_COMPONENTS;
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
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
// Used internally.
typedef vtkm::Vec<vtkm::IdComponent, NUM_COMPONENTS> ComponentMapType;
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
VTKM_STATIC_ASSERT(NUM_COMPONENTS == PortalTypes::ARITY);
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
Suppress false positive warnings from nvcc about host/device.
2016-03-31 13:13:54 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
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
Suppress false positive warnings from nvcc about host/device.
2016-03-31 13:13:54 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
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
ArrayPortalCompositeVector(const PortalTypes portals,
vtkm::Vec<vtkm::IdComponent, NUM_COMPONENTS> sourceComponents)
: Portals(portals)
, SourceComponents(sourceComponents)
{
}
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
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
VTKM_SUPPRESS_EXEC_WARNINGS
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
vtkm::Id GetNumberOfValues() 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
return this->Portals.template GetParameter<1>().GetNumberOfValues();
}
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
VTKM_SUPPRESS_EXEC_WARNINGS
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
{
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 might be inefficient because we are copying all the portals only
// because they are coupled with the return value.
PortalTypes localPortals = this->Portals;
localPortals.InvokeExec(
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
detail::CompositeVectorSwizzleFunctor<ValueType>(this->SourceComponents),
detail::CompositeVectorPullValueFunctor<ValueType>(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
return localPortals.GetReturnValue();
}
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
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
void Set(vtkm::Id vtkmNotUsed(index), const ValueType& vtkmNotUsed(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
{
// There is no technical reason why this cannot be implemented. As of this
// writing no one has needed to write to a composite vector yet.
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_ASSERT(false &&
"Set not yet implemented for composite vector. Do you volunteer to implement it?");
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
private:
PortalTypes Portals;
ComponentMapType SourceComponents;
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename SignatureWithArrays>
struct VTKM_ALWAYS_EXPORT StorageTagCompositeVector
{
};
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
/// A convenience class that provides a typedef to the appropriate tag for
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
/// a composite storage.
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename SignatureWithArrays>
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
struct ArrayHandleCompositeVectorTraits
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef vtkm::cont::internal::StorageTagCompositeVector<SignatureWithArrays> Tag;
typedef typename vtkm::internal::FunctionInterface<SignatureWithArrays>::ResultType ValueType;
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
typedef vtkm::cont::internal::Storage<ValueType, Tag> StorageType;
Add default constructors/destructors/assignment to ArrayHandle classes The ArrayHandle classes all exclusively work in the control environment. However, CUDA likes to add __device__ to constructors, destructors, and assignment operators it automatically adds. This in turn causes warnings about the __device__ function using host-only classes (like boost::shared_ptr). Solve this problem by adding explicit methods for all of these. Implemented this by wrapping up all these default objects in a macro. This also solved the problem of other constructors that are necessary for array handles such as a constructor that takes the base array handle.
2015-10-21 19:36:27 +00:00
typedef vtkm::cont::ArrayHandle<ValueType, Tag> Superclass;
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
};
// It may seem weird that this specialization throws an exception for
// everything, but that is because all the functionality is handled in the
// ArrayTransfer class.
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename SignatureWithArrays>
class Storage<typename ArrayHandleCompositeVectorTraits<SignatureWithArrays>::ValueType,
vtkm::cont::internal::StorageTagCompositeVector<SignatureWithArrays>>
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef vtkm::internal::FunctionInterface<SignatureWithArrays> FunctionInterfaceWithArrays;
Add IdComponent and other base types with explicit widths In preparation for supporting base types with more widths, add typedefs for the base types with explicit widths (number of bits). Also added a IdComponent type that should be used for indices for components into tuples and vectors. There now should be no reason to use "int" inside of VTK-m code (especially for indexing). This change cleans up many of the int types that were used throughout.
2014-10-07 16:59:34 +00:00
static const vtkm::IdComponent NUM_COMPONENTS = FunctionInterfaceWithArrays::ARITY;
Change vtkm::Tuple to vtkm::Vec There are multiple reasons for this name change: * The name Tuple conflicts with the boost::Tuple class, which as a different interface and feature set. This gets confusing, especially since VTK-m uses boost quite a bit. * The use of this class is usually (although not always) as a mathematical vector. * The vtkm::Scalar and vtkm::Vector* classes are going to go away soon to better support multiple base data type widths. Having this abbriviated name will hopefully make the code a bit nicer when these types have to be explicitly specified. Also modified the implementation a bit to consolidate some of the code.
2014-10-07 23:17:03 +00:00
typedef vtkm::Vec<vtkm::IdComponent, NUM_COMPONENTS> ComponentMapType;
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
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
typedef typename FunctionInterfaceWithArrays::template StaticTransformType<
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
detail::CompositeVectorArrayToPortalCont>::type FunctionInterfaceWithPortals;
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
typedef typename FunctionInterfaceWithPortals::Signature SignatureWithPortals;
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:
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
typedef ArrayPortalCompositeVector<SignatureWithPortals> PortalType;
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
typedef PortalType PortalConstType;
typedef typename PortalType::ValueType 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_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
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(const FunctionInterfaceWithArrays& arrays, const ComponentMapType& sourceComponents)
: Arrays(arrays)
, SourceComponents(sourceComponents)
, Valid(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
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
arrays.ForEachCont(detail::CheckArraySizeFunctor(this->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
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
PortalType GetPortal()
{
throw vtkm::cont::ErrorBadValue("Composite vector arrays are read only.");
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
PortalConstType GetPortalConst() 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
if (!this->Valid)
{
Simplify exception hierarchy. Remove the ErrorControl class such that all subclasses now inherit from error. Renamed all exception classes via s/ErrorControl/Error/. See issue #57.
2017-01-09 21:15:32 +00:00
throw vtkm::cont::ErrorBadValue(
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
"Tried to use an ArrayHandleCompositeHandle without dependent 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
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
return PortalConstType(
this->Arrays.StaticTransformCont(detail::CompositeVectorArrayToPortalCont()),
this->SourceComponents);
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
{
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
if (!this->Valid)
{
Simplify exception hierarchy. Remove the ErrorControl class such that all subclasses now inherit from error. Renamed all exception classes via s/ErrorControl/Error/. See issue #57.
2017-01-09 21:15:32 +00:00
throw vtkm::cont::ErrorBadValue(
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
"Tried to use an ArrayHandleCompositeHandle without dependent 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
}
return this->Arrays.template GetParameter<1>().GetNumberOfValues();
}
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 Allocate(vtkm::Id vtkmNotUsed(numberOfValues))
{
Simplify exception hierarchy. Remove the ErrorControl class such that all subclasses now inherit from error. Renamed all exception classes via s/ErrorControl/Error/. See issue #57.
2017-01-09 21:15:32 +00:00
throw vtkm::cont::ErrorInternal(
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
"The allocate method for the composite vector storage should never "
"have been called. The allocate is generally only called by the "
"execution array manager, and the array transfer for the composite "
"storage should prevent the execution array manager from being "
"directly used.");
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 Shrink(vtkm::Id vtkmNotUsed(numberOfValues))
{
throw vtkm::cont::ErrorBadValue("Composite vector arrays are read-only.");
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()
{
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
if (this->Valid)
{
// TODO: Implement this.
}
}
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
const FunctionInterfaceWithArrays& GetArrays() const
{
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
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
const ComponentMapType& GetSourceComponents() const
{
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->SourceComponents;
}
private:
FunctionInterfaceWithArrays Arrays;
ComponentMapType SourceComponents;
bool Valid;
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename SignatureWithArrays, typename DeviceAdapterTag>
class ArrayTransfer<typename ArrayHandleCompositeVectorTraits<SignatureWithArrays>::ValueType,
vtkm::cont::internal::StorageTagCompositeVector<SignatureWithArrays>,
DeviceAdapterTag>
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
{
VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef typename ArrayHandleCompositeVectorTraits<SignatureWithArrays>::StorageType 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
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef vtkm::internal::FunctionInterface<SignatureWithArrays> FunctionWithArrays;
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
typedef typename FunctionWithArrays::template StaticTransformType<
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
detail::CompositeVectorArrayToPortalExec<DeviceAdapterTag>>::type FunctionWithPortals;
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
typedef typename FunctionWithPortals::Signature SignatureWithPortals;
public:
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef typename ArrayHandleCompositeVectorTraits<SignatureWithArrays>::ValueType ValueType;
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
// These are not currently fully implemented.
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
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
typedef ArrayPortalCompositeVector<SignatureWithPortals> PortalExecution;
typedef ArrayPortalCompositeVector<SignatureWithPortals> PortalConstExecution;
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
Change interface of ArrayTransfer to be more like ArrayHandle. This includes changing methods like LoadDataForInput to PrepareForInput. It also changed the interface a bit to save a reference to the storage object. (Maybe it would be better to save a pointer?) These changes also extend up to the ArrayManagerExecution class, so it can effect device adapter implementations.
2015-05-01 02:47:30 +00:00
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData)) 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
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
return PortalConstExecution(this->Storage->GetArrays().StaticTransformCont(
detail::CompositeVectorArrayToPortalExec<DeviceAdapterTag>()),
this->Storage->GetSourceComponents());
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
Change interface of ArrayTransfer to be more like ArrayHandle. This includes changing methods like LoadDataForInput to PrepareForInput. It also changed the interface a bit to save a reference to the storage object. (Maybe it would be better to save a pointer?) These changes also extend up to the ArrayManagerExecution class, so it can effect device adapter implementations.
2015-05-01 02:47:30 +00:00
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
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
{
Change interface of ArrayTransfer to be more like ArrayHandle. This includes changing methods like LoadDataForInput to PrepareForInput. It also changed the interface a bit to save a reference to the storage object. (Maybe it would be better to save a pointer?) These changes also extend up to the ArrayManagerExecution class, so it can effect device adapter implementations.
2015-05-01 02:47:30 +00:00
// It may be the case a composite vector could be used for in place
// operations, but this is not implemented currently.
Simplify exception hierarchy. Remove the ErrorControl class such that all subclasses now inherit from error. Renamed all exception classes via s/ErrorControl/Error/. See issue #57.
2017-01-09 21:15:32 +00:00
throw vtkm::cont::ErrorBadValue(
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
"Composite vector arrays cannot be used for output or in place.");
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
Change interface of ArrayTransfer to be more like ArrayHandle. This includes changing methods like LoadDataForInput to PrepareForInput. It also changed the interface a bit to save a reference to the storage object. (Maybe it would be better to save a pointer?) These changes also extend up to the ArrayManagerExecution class, so it can effect device adapter implementations.
2015-05-01 02:47:30 +00:00
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues))
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
{
Change interface of ArrayTransfer to be more like ArrayHandle. This includes changing methods like LoadDataForInput to PrepareForInput. It also changed the interface a bit to save a reference to the storage object. (Maybe it would be better to save a pointer?) These changes also extend up to the ArrayManagerExecution class, so it can effect device adapter implementations.
2015-05-01 02:47:30 +00:00
// It may be the case a composite vector could be used for output if you
// want the delegate arrays to be resized, but this is not implemented
// currently.
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
throw vtkm::cont::ErrorBadValue("Composite vector arrays cannot be used for output.");
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
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
throw vtkm::cont::ErrorBadValue("Composite vector arrays cannot be used for output.");
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
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
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues))
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
throw vtkm::cont::ErrorBadValue("Composite vector arrays cannot be resized.");
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() { this->Storage->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
private:
clang-format: apply to the entire tree
2017-05-18 14:29:41 +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
};
} // namespace internal
/// \brief An \c ArrayHandle that combines components from other arrays.
///
/// \c ArrayHandleCompositeVector is a specialization of \c ArrayHandle that
/// derives its content from other arrays. It takes up to 4 other \c
/// ArrayHandle objects and mimics an array that contains vectors with
/// components that come from these delegate arrays.
///
/// The easiest way to create and type an \c ArrayHandleCompositeVector is
/// to use the \c make_ArrayHandleCompositeVector functions.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename Signature>
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
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
: public internal::ArrayHandleCompositeVectorTraits<Signature>::Superclass
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef typename internal::ArrayHandleCompositeVectorTraits<Signature>::StorageType StorageType;
typedef
typename internal::ArrayPortalCompositeVector<Signature>::ComponentMapType ComponentMapType;
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:
Add default constructors/destructors/assignment to ArrayHandle classes The ArrayHandle classes all exclusively work in the control environment. However, CUDA likes to add __device__ to constructors, destructors, and assignment operators it automatically adds. This in turn causes warnings about the __device__ function using host-only classes (like boost::shared_ptr). Solve this problem by adding explicit methods for all of these. Implemented this by wrapping up all these default objects in a macro. This also solved the problem of other constructors that are necessary for array handles such as a constructor that takes the base array handle.
2015-10-21 19:36:27 +00:00
VTKM_ARRAY_HANDLE_SUBCLASS(
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
ArrayHandleCompositeVector, (ArrayHandleCompositeVector<Signature>),
(typename internal::ArrayHandleCompositeVectorTraits<Signature>::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
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
ArrayHandleCompositeVector(const vtkm::internal::FunctionInterface<Signature>& arrays,
const ComponentMapType& sourceComponents)
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
: Superclass(StorageType(arrays, sourceComponents))
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
/// Template constructors for passing in types. You'll get weird compile
/// errors if the argument types do not actually match the types in the
/// signature.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType1>
VTKM_CONT ArrayHandleCompositeVector(const ArrayHandleType1& array1,
vtkm::IdComponent sourceComponent1)
: Superclass(StorageType(vtkm::internal::make_FunctionInterface<ValueType>(array1),
ComponentMapType(sourceComponent1)))
{
}
template <typename ArrayHandleType1, typename ArrayHandleType2>
VTKM_CONT ArrayHandleCompositeVector(const ArrayHandleType1& array1,
vtkm::IdComponent sourceComponent1,
const ArrayHandleType2& array2,
vtkm::IdComponent sourceComponent2)
: Superclass(StorageType(vtkm::internal::make_FunctionInterface<ValueType>(array1, array2),
ComponentMapType(sourceComponent1, sourceComponent2)))
{
}
template <typename ArrayHandleType1, typename ArrayHandleType2, typename ArrayHandleType3>
VTKM_CONT ArrayHandleCompositeVector(const ArrayHandleType1& array1,
vtkm::IdComponent sourceComponent1,
const ArrayHandleType2& array2,
vtkm::IdComponent sourceComponent2,
const ArrayHandleType3& array3,
vtkm::IdComponent sourceComponent3)
: Superclass(
StorageType(vtkm::internal::make_FunctionInterface<ValueType>(array1, array2, array3),
ComponentMapType(sourceComponent1, sourceComponent2, sourceComponent3)))
{
}
template <typename ArrayHandleType1, typename ArrayHandleType2, typename ArrayHandleType3,
typename ArrayHandleType4>
VTKM_CONT ArrayHandleCompositeVector(
const ArrayHandleType1& array1, vtkm::IdComponent sourceComponent1,
const ArrayHandleType2& array2, vtkm::IdComponent sourceComponent2,
const ArrayHandleType3& array3, vtkm::IdComponent sourceComponent3,
const ArrayHandleType4& array4, vtkm::IdComponent sourceComponent4)
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
: Superclass(StorageType(
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::internal::make_FunctionInterface<ValueType>(array1, array2, array3, array4),
ComponentMapType(sourceComponent1, sourceComponent2, sourceComponent3, sourceComponent4)))
{
}
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
};
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
/// \brief Get the type for an ArrayHandleCompositeVector
///
/// The ArrayHandleCompositeVector has a difficult template specification.
/// Use this helper template to covert a list of array handle types to a
/// composite vector of these array handles. Here is a simple example.
///
/// \code{.cpp}
/// typedef vtkm::cont::ArrayHandleCompositeVector<
Update the documentation to use vtkm::FloatDefault instead of vtkm::Scalar.
2014-12-10 15:38:03 +00:00
/// vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
/// vtkm::cont::ArrayHandle<vtkm::FloatDefault> >::type OutArrayType;
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
/// OutArrayType outArray = vtkm::cont::make_ArrayHandleCompositeVector(a1,a2);
/// \endcode
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType1, typename ArrayHandleType2 = void,
typename ArrayHandleType3 = void, typename ArrayHandleType4 = void>
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
struct ArrayHandleCompositeVectorType
{
Have make_ArrayHandleCompositeVector consistent with fancy arrays Previously the make_ArrayHandleCompositeVector template was declared in such a way that if you passed it a fancy array handle, it would change the type to a base ArrayHandle with a fancy storage. This was inconsistent with types generated from ArrayHandleCompositeVectorType when using the same fancy array handle types. This change makes that more consistent.
2016-04-13 21:52:38 +00:00
VTKM_IS_ARRAY_HANDLE(ArrayHandleType1);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType2);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType3);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType4);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
private:
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef
typename vtkm::VecTraits<typename ArrayHandleType1::ValueType>::ComponentType ComponentType;
typedef vtkm::Vec<ComponentType, 4> Signature(ArrayHandleType1, ArrayHandleType2,
ArrayHandleType3, ArrayHandleType4);
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
public:
typedef vtkm::cont::ArrayHandleCompositeVector<Signature> type;
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType1, typename ArrayHandleType2, typename ArrayHandleType3>
struct ArrayHandleCompositeVectorType<ArrayHandleType1, ArrayHandleType2, ArrayHandleType3>
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
{
Have make_ArrayHandleCompositeVector consistent with fancy arrays Previously the make_ArrayHandleCompositeVector template was declared in such a way that if you passed it a fancy array handle, it would change the type to a base ArrayHandle with a fancy storage. This was inconsistent with types generated from ArrayHandleCompositeVectorType when using the same fancy array handle types. This change makes that more consistent.
2016-04-13 21:52:38 +00:00
VTKM_IS_ARRAY_HANDLE(ArrayHandleType1);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType2);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType3);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
private:
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef
typename vtkm::VecTraits<typename ArrayHandleType1::ValueType>::ComponentType ComponentType;
typedef vtkm::Vec<ComponentType, 3> Signature(ArrayHandleType1, ArrayHandleType2,
ArrayHandleType3);
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
public:
typedef vtkm::cont::ArrayHandleCompositeVector<Signature> type;
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType1, typename ArrayHandleType2>
struct ArrayHandleCompositeVectorType<ArrayHandleType1, ArrayHandleType2>
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
{
Have make_ArrayHandleCompositeVector consistent with fancy arrays Previously the make_ArrayHandleCompositeVector template was declared in such a way that if you passed it a fancy array handle, it would change the type to a base ArrayHandle with a fancy storage. This was inconsistent with types generated from ArrayHandleCompositeVectorType when using the same fancy array handle types. This change makes that more consistent.
2016-04-13 21:52:38 +00:00
VTKM_IS_ARRAY_HANDLE(ArrayHandleType1);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType2);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
private:
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef
typename vtkm::VecTraits<typename ArrayHandleType1::ValueType>::ComponentType ComponentType;
typedef vtkm::Vec<ComponentType, 2> Signature(ArrayHandleType1, ArrayHandleType2);
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
public:
typedef vtkm::cont::ArrayHandleCompositeVector<Signature> type;
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType1>
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
struct ArrayHandleCompositeVectorType<ArrayHandleType1>
{
Have make_ArrayHandleCompositeVector consistent with fancy arrays Previously the make_ArrayHandleCompositeVector template was declared in such a way that if you passed it a fancy array handle, it would change the type to a base ArrayHandle with a fancy storage. This was inconsistent with types generated from ArrayHandleCompositeVectorType when using the same fancy array handle types. This change makes that more consistent.
2016-04-13 21:52:38 +00:00
VTKM_IS_ARRAY_HANDLE(ArrayHandleType1);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
private:
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
typedef
typename vtkm::VecTraits<typename ArrayHandleType1::ValueType>::ComponentType ComponentType;
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
typedef ComponentType Signature(ArrayHandleType1);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Add a helper class to determine composite array types Getting the type right for ArrayHandleCompositeVector can be a bit tricky. It is expressed in a somewhat strange function signature format and you have to extract the right component type for the return. This adds an ArrayHandleCompositeVectorType that makes it easier (although no less verbose).
2014-06-06 22:05:55 +00:00
public:
typedef vtkm::cont::ArrayHandleCompositeVector<Signature> type;
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
// clang-format off
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.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ValueType1, typename Storage1>
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
typename ArrayHandleCompositeVectorType<vtkm::cont::ArrayHandle<ValueType1, Storage1>>::type
make_ArrayHandleCompositeVector(const vtkm::cont::ArrayHandle<ValueType1, Storage1>& array1,
vtkm::IdComponent sourceComponent1)
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
return
typename ArrayHandleCompositeVectorType<vtkm::cont::ArrayHandle<ValueType1, Storage1>>::type(
array1, sourceComponent1);
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
// clang-format on
template <typename ArrayHandleType1>
VTKM_CONT typename ArrayHandleCompositeVectorType<ArrayHandleType1>::type
make_ArrayHandleCompositeVector(const ArrayHandleType1& array1, vtkm::IdComponent sourceComponent1)
Have make_ArrayHandleCompositeVector consistent with fancy arrays Previously the make_ArrayHandleCompositeVector template was declared in such a way that if you passed it a fancy array handle, it would change the type to a base ArrayHandle with a fancy storage. This was inconsistent with types generated from ArrayHandleCompositeVectorType when using the same fancy array handle types. This change makes that more consistent.
2016-04-13 21:52:38 +00:00
{
VTKM_IS_ARRAY_HANDLE(ArrayHandleType1);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
return typename ArrayHandleCompositeVectorType<ArrayHandleType1>::type(array1, sourceComponent1);
Have make_ArrayHandleCompositeVector consistent with fancy arrays Previously the make_ArrayHandleCompositeVector template was declared in such a way that if you passed it a fancy array handle, it would change the type to a base ArrayHandle with a fancy storage. This was inconsistent with types generated from ArrayHandleCompositeVectorType when using the same fancy array handle types. This change makes that more consistent.
2016-04-13 21:52:38 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType1, typename ArrayHandleType2>
VTKM_CONT typename ArrayHandleCompositeVectorType<ArrayHandleType1, ArrayHandleType2>::type
make_ArrayHandleCompositeVector(const ArrayHandleType1& array1, vtkm::IdComponent sourceComponent1,
const ArrayHandleType2& array2, vtkm::IdComponent sourceComponent2)
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
{
Have make_ArrayHandleCompositeVector consistent with fancy arrays Previously the make_ArrayHandleCompositeVector template was declared in such a way that if you passed it a fancy array handle, it would change the type to a base ArrayHandle with a fancy storage. This was inconsistent with types generated from ArrayHandleCompositeVectorType when using the same fancy array handle types. This change makes that more consistent.
2016-04-13 21:52:38 +00:00
VTKM_IS_ARRAY_HANDLE(ArrayHandleType1);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType2);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
return typename ArrayHandleCompositeVectorType<ArrayHandleType1, ArrayHandleType2>::type(
array1, sourceComponent1, array2, sourceComponent2);
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType1, typename ArrayHandleType2, typename ArrayHandleType3>
VTKM_CONT typename ArrayHandleCompositeVectorType<ArrayHandleType1, ArrayHandleType2,
ArrayHandleType3>::type
make_ArrayHandleCompositeVector(const ArrayHandleType1& array1, vtkm::IdComponent sourceComponent1,
const ArrayHandleType2& array2, vtkm::IdComponent sourceComponent2,
const ArrayHandleType3& array3, vtkm::IdComponent sourceComponent3)
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
{
Have make_ArrayHandleCompositeVector consistent with fancy arrays Previously the make_ArrayHandleCompositeVector template was declared in such a way that if you passed it a fancy array handle, it would change the type to a base ArrayHandle with a fancy storage. This was inconsistent with types generated from ArrayHandleCompositeVectorType when using the same fancy array handle types. This change makes that more consistent.
2016-04-13 21:52:38 +00:00
VTKM_IS_ARRAY_HANDLE(ArrayHandleType1);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType2);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType3);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
return typename ArrayHandleCompositeVectorType<ArrayHandleType1, ArrayHandleType2,
ArrayHandleType3>::type(array1, sourceComponent1,
array2, sourceComponent2,
array3, sourceComponent3);
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: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename ArrayHandleType1, typename ArrayHandleType2, typename ArrayHandleType3,
typename ArrayHandleType4>
VTKM_CONT typename ArrayHandleCompositeVectorType<ArrayHandleType1, ArrayHandleType2,
ArrayHandleType3, ArrayHandleType4>::type
make_ArrayHandleCompositeVector(const ArrayHandleType1& array1, vtkm::IdComponent sourceComponent1,
const ArrayHandleType2& array2, vtkm::IdComponent sourceComponent2,
const ArrayHandleType3& array3, vtkm::IdComponent sourceComponent3,
const ArrayHandleType4& array4, vtkm::IdComponent sourceComponent4)
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
{
Have make_ArrayHandleCompositeVector consistent with fancy arrays Previously the make_ArrayHandleCompositeVector template was declared in such a way that if you passed it a fancy array handle, it would change the type to a base ArrayHandle with a fancy storage. This was inconsistent with types generated from ArrayHandleCompositeVectorType when using the same fancy array handle types. This change makes that more consistent.
2016-04-13 21:52:38 +00:00
VTKM_IS_ARRAY_HANDLE(ArrayHandleType1);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType2);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType3);
VTKM_IS_ARRAY_HANDLE(ArrayHandleType4);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
return
typename ArrayHandleCompositeVectorType<ArrayHandleType1, ArrayHandleType2, ArrayHandleType3,
ArrayHandleType4>::type(array1, sourceComponent1,
array2, sourceComponent2,
array3, sourceComponent3,
array4, sourceComponent4);
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
#endif //vtk_m_ArrayHandleCompositeVector_h
Reference in New Issue Copy Permalink