2019-06-21 15:35:46 +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.
|
|
|
|
//============================================================================
|
2019-06-06 18:43:53 +00:00
|
|
|
#ifndef vtkm_internal_StorageExtrude_h
|
|
|
|
#define vtkm_internal_StorageExtrude_h
|
|
|
|
|
2019-06-22 04:48:12 +00:00
|
|
|
#include <vtkm/internal/IndicesExtrude.h>
|
|
|
|
|
2019-06-06 18:43:53 +00:00
|
|
|
#include <vtkm/cont/serial/DeviceAdapterSerial.h>
|
|
|
|
#include <vtkm/cont/tbb/DeviceAdapterTBB.h>
|
|
|
|
|
2019-06-22 04:48:12 +00:00
|
|
|
namespace vtkm
|
|
|
|
{
|
|
|
|
namespace exec
|
|
|
|
{
|
|
|
|
|
|
|
|
template <typename PortalType>
|
|
|
|
struct VTKM_ALWAYS_EXPORT ArrayPortalExtrudePlane
|
|
|
|
{
|
|
|
|
using ValueType = typename PortalType::ValueType;
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
ArrayPortalExtrudePlane()
|
|
|
|
: Portal()
|
|
|
|
, NumberOfPlanes(0){};
|
|
|
|
|
|
|
|
ArrayPortalExtrudePlane(const PortalType& p, vtkm::Int32 numOfPlanes)
|
|
|
|
: Portal(p)
|
|
|
|
, NumberOfPlanes(numOfPlanes)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
vtkm::Id GetNumberOfValues() const
|
|
|
|
{
|
|
|
|
return this->Portal.GetNumberOfValues() * static_cast<vtkm::Id>(NumberOfPlanes);
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
ValueType Get(vtkm::Id index) const { return this->Portal.Get(index % this->NumberOfPlanes); }
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
ValueType Get(vtkm::Id2 index) const { return this->Portal.Get(index[0]); }
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
vtkm::Vec<ValueType, 6> GetWedge(const IndicesExtrude& index) const
|
|
|
|
{
|
|
|
|
vtkm::Vec<ValueType, 6> result;
|
|
|
|
result[0] = this->Portal.Get(index.PointIds[0][0]);
|
|
|
|
result[1] = this->Portal.Get(index.PointIds[0][1]);
|
|
|
|
result[2] = this->Portal.Get(index.PointIds[0][2]);
|
|
|
|
result[3] = this->Portal.Get(index.PointIds[1][0]);
|
|
|
|
result[4] = this->Portal.Get(index.PointIds[1][1]);
|
|
|
|
result[5] = this->Portal.Get(index.PointIds[1][2]);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
void Set(vtkm::Id vtkmNotUsed(index), const ValueType& vtkmNotUsed(value)) const {}
|
|
|
|
|
|
|
|
PortalType Portal;
|
|
|
|
vtkm::Int32 NumberOfPlanes;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
} // vtkm::exec
|
|
|
|
|
|
|
|
namespace vtkm
|
|
|
|
{
|
|
|
|
namespace cont
|
|
|
|
{
|
|
|
|
namespace internal
|
|
|
|
{
|
|
|
|
|
|
|
|
struct VTKM_ALWAYS_EXPORT StorageTagExtrudePlane
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
class VTKM_ALWAYS_EXPORT Storage<T, internal::StorageTagExtrudePlane>
|
|
|
|
{
|
|
|
|
using HandleType = vtkm::cont::ArrayHandle<T>;
|
|
|
|
|
|
|
|
public:
|
|
|
|
using ValueType = T;
|
|
|
|
|
|
|
|
// This is meant to be invalid. Because point arrays are read only, you
|
|
|
|
// should only be able to use the const version.
|
|
|
|
struct PortalType
|
|
|
|
{
|
|
|
|
using ValueType = void*;
|
|
|
|
using IteratorType = void*;
|
|
|
|
};
|
|
|
|
|
|
|
|
using PortalConstType =
|
|
|
|
vtkm::exec::ArrayPortalExtrudePlane<typename HandleType::PortalConstControl>;
|
|
|
|
|
|
|
|
Storage()
|
|
|
|
: Array()
|
|
|
|
, NumberOfPlanes(0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
Storage(const HandleType& array, vtkm::Int32 numberOfPlanes)
|
|
|
|
: Array(array)
|
|
|
|
, NumberOfPlanes(numberOfPlanes)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
PortalType GetPortal() { return PortalType{}; }
|
|
|
|
|
|
|
|
PortalConstType GetPortalConst() const
|
|
|
|
{
|
|
|
|
return PortalConstType(this->Array.GetPortalConstControl(), this->NumberOfPlanes);
|
|
|
|
}
|
|
|
|
|
|
|
|
vtkm::Id GetNumberOfValues() const
|
|
|
|
{
|
|
|
|
return this->Array.GetNumberOfValues() * static_cast<vtkm::Id>(this->NumberOfPlanes);
|
|
|
|
}
|
|
|
|
|
|
|
|
vtkm::Int32 GetNumberOfValuesPerPlane() const
|
|
|
|
{
|
|
|
|
return static_cast<vtkm::Int32>(this->Array->GetNumberOfValues());
|
|
|
|
}
|
|
|
|
|
|
|
|
vtkm::Int32 GetNumberOfPlanes() const { return this->NumberOfPlanes; }
|
|
|
|
|
|
|
|
void Allocate(vtkm::Id vtkmNotUsed(numberOfValues))
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("ArrayPortalExtrudePlane is read only. It cannot be allocated.");
|
|
|
|
}
|
|
|
|
|
|
|
|
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues))
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("ArrayPortalExtrudePlane is read only. It cannot shrink.");
|
|
|
|
}
|
|
|
|
|
|
|
|
void ReleaseResources()
|
|
|
|
{
|
|
|
|
// This request is ignored since we don't own the memory that was past
|
|
|
|
// to us
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
vtkm::cont::ArrayHandle<T> Array;
|
|
|
|
vtkm::Int32 NumberOfPlanes;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T, typename Device>
|
|
|
|
class VTKM_ALWAYS_EXPORT ArrayTransfer<T, internal::StorageTagExtrudePlane, Device>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
using ValueType = T;
|
|
|
|
using StorageType = vtkm::cont::internal::Storage<T, internal::StorageTagExtrudePlane>;
|
|
|
|
|
|
|
|
using PortalControl = typename StorageType::PortalType;
|
|
|
|
using PortalConstControl = typename StorageType::PortalConstType;
|
|
|
|
|
|
|
|
//meant to be an invalid writeable execution portal
|
|
|
|
using PortalExecution = typename StorageType::PortalType;
|
|
|
|
using PortalConstExecution = vtkm::exec::ArrayPortalExtrudePlane<decltype(
|
|
|
|
vtkm::cont::ArrayHandle<T>{}.PrepareForInput(Device{}))>;
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
ArrayTransfer(StorageType* storage)
|
|
|
|
: ControlData(storage)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
vtkm::Id GetNumberOfValues() const { return this->ControlData->GetNumberOfValues(); }
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
|
|
|
|
{
|
|
|
|
return PortalConstExecution(this->ControlData->Array.PrepareForInput(Device()),
|
|
|
|
this->ControlData->NumberOfPlanes);
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
PortalExecution PrepareForInPlace(bool& vtkmNotUsed(updateData))
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("ArrayPortalExtrudePlane read only. "
|
|
|
|
"Cannot be used for in-place operations.");
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues))
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("ArrayPortalExtrudePlane read only. Cannot be used as output.");
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
void RetrieveOutputData(StorageType* vtkmNotUsed(storage)) const
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorInternal(
|
|
|
|
"ArrayPortalExtrudePlane read only. "
|
|
|
|
"There should be no occurance of the ArrayHandle trying to pull "
|
|
|
|
"data from the execution environment.");
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues))
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("ArrayPortalExtrudePlane read only. Cannot shrink.");
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
void ReleaseResources()
|
|
|
|
{
|
|
|
|
// This request is ignored since we don't own the memory that was past
|
|
|
|
// to us
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
const StorageType* const ControlData;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // vtkm::cont::internal
|
|
|
|
|
|
|
|
namespace vtkm
|
|
|
|
{
|
|
|
|
namespace exec
|
|
|
|
{
|
|
|
|
|
|
|
|
template <typename PortalType>
|
|
|
|
struct VTKM_ALWAYS_EXPORT ArrayPortalExtrude
|
|
|
|
{
|
|
|
|
using ValueType = vtkm::Vec<typename PortalType::ValueType, 3>;
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
ArrayPortalExtrude()
|
|
|
|
: Portal()
|
|
|
|
, NumberOfValues(0)
|
|
|
|
, NumberOfPlanes(0)
|
|
|
|
, UseCylindrical(false){};
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
ArrayPortalExtrude(const PortalType& p,
|
|
|
|
vtkm::Int32 numOfValues,
|
|
|
|
vtkm::Int32 numOfPlanes,
|
|
|
|
bool cylindrical = false)
|
|
|
|
: Portal(p)
|
|
|
|
, NumberOfValues(numOfValues)
|
|
|
|
, NumberOfPlanes(numOfPlanes)
|
|
|
|
, UseCylindrical(cylindrical)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
vtkm::Id GetNumberOfValues() const
|
|
|
|
{
|
|
|
|
return ((NumberOfValues / 2) * static_cast<vtkm::Id>(NumberOfPlanes));
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
ValueType Get(vtkm::Id index) const;
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
ValueType Get(vtkm::Id2 index) const;
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
vtkm::Vec<ValueType, 6> GetWedge(const IndicesExtrude& index) const;
|
|
|
|
|
|
|
|
VTKM_SUPPRESS_EXEC_WARNINGS
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
void Set(vtkm::Id vtkmNotUsed(index), const ValueType& vtkmNotUsed(value)) const {}
|
|
|
|
|
|
|
|
PortalType Portal;
|
|
|
|
vtkm::Int32 NumberOfValues;
|
|
|
|
vtkm::Int32 NumberOfPlanes;
|
|
|
|
bool UseCylindrical;
|
|
|
|
};
|
|
|
|
template <typename PortalType>
|
|
|
|
typename ArrayPortalExtrude<PortalType>::ValueType
|
|
|
|
ArrayPortalExtrude<PortalType>::ArrayPortalExtrude::Get(vtkm::Id index) const
|
|
|
|
{
|
|
|
|
using CompType = typename ValueType::ComponentType;
|
|
|
|
|
|
|
|
const vtkm::Id realIdx = (index * 2) % this->NumberOfValues;
|
|
|
|
const vtkm::Id whichPlane = (index * 2) / this->NumberOfValues;
|
|
|
|
const auto phi = static_cast<CompType>(whichPlane * (vtkm::TwoPi() / this->NumberOfPlanes));
|
|
|
|
|
|
|
|
auto r = this->Portal.Get(realIdx);
|
|
|
|
auto z = this->Portal.Get(realIdx + 1);
|
|
|
|
if (this->UseCylindrical)
|
|
|
|
{
|
|
|
|
return ValueType(r, phi, z);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return ValueType(r * vtkm::Cos(phi), r * vtkm::Sin(phi), z);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename PortalType>
|
|
|
|
typename ArrayPortalExtrude<PortalType>::ValueType
|
|
|
|
ArrayPortalExtrude<PortalType>::ArrayPortalExtrude::Get(vtkm::Id2 index) const
|
|
|
|
{
|
|
|
|
using CompType = typename ValueType::ComponentType;
|
|
|
|
|
|
|
|
const vtkm::Id realIdx = (index[0] * 2);
|
|
|
|
const vtkm::Id whichPlane = index[1];
|
|
|
|
const auto phi = static_cast<CompType>(whichPlane * (vtkm::TwoPi() / this->NumberOfPlanes));
|
|
|
|
|
|
|
|
auto r = this->Portal.Get(realIdx);
|
|
|
|
auto z = this->Portal.Get(realIdx + 1);
|
|
|
|
if (this->UseCylindrical)
|
|
|
|
{
|
|
|
|
return ValueType(r, phi, z);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return ValueType(r * vtkm::Cos(phi), r * vtkm::Sin(phi), z);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename PortalType>
|
|
|
|
vtkm::Vec<typename ArrayPortalExtrude<PortalType>::ValueType, 6>
|
|
|
|
ArrayPortalExtrude<PortalType>::ArrayPortalExtrude::GetWedge(const IndicesExtrude& index) const
|
|
|
|
{
|
|
|
|
using CompType = typename ValueType::ComponentType;
|
|
|
|
|
|
|
|
vtkm::Vec<ValueType, 6> result;
|
|
|
|
for (int j = 0; j < 2; ++j)
|
|
|
|
{
|
|
|
|
const auto phi =
|
|
|
|
static_cast<CompType>(index.Planes[j] * (vtkm::TwoPi() / this->NumberOfPlanes));
|
|
|
|
for (int i = 0; i < 3; ++i)
|
|
|
|
{
|
|
|
|
const vtkm::Id realIdx = index.PointIds[j][i] * 2;
|
|
|
|
auto r = this->Portal.Get(realIdx);
|
|
|
|
auto z = this->Portal.Get(realIdx + 1);
|
|
|
|
result[3 * j + i] = this->UseCylindrical
|
|
|
|
? ValueType(r, phi, z)
|
|
|
|
: ValueType(r * vtkm::Cos(phi), r * vtkm::Sin(phi), z);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-06 18:43:53 +00:00
|
|
|
namespace vtkm
|
|
|
|
{
|
|
|
|
namespace cont
|
|
|
|
{
|
|
|
|
namespace internal
|
|
|
|
{
|
|
|
|
struct VTKM_ALWAYS_EXPORT StorageTagExtrude
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
class Storage<T, internal::StorageTagExtrude>
|
|
|
|
{
|
|
|
|
using BaseT = typename BaseComponent<T>::Type;
|
|
|
|
using HandleType = vtkm::cont::ArrayHandle<BaseT>;
|
|
|
|
using TPortalType = typename HandleType::PortalConstControl;
|
|
|
|
|
|
|
|
public:
|
|
|
|
using ValueType = T;
|
|
|
|
|
|
|
|
// This is meant to be invalid. Because point arrays are read only, you
|
|
|
|
// should only be able to use the const version.
|
|
|
|
struct PortalType
|
|
|
|
{
|
|
|
|
using ValueType = void*;
|
|
|
|
using IteratorType = void*;
|
|
|
|
};
|
|
|
|
|
|
|
|
using PortalConstType = exec::ArrayPortalExtrude<TPortalType>;
|
|
|
|
|
|
|
|
Storage()
|
|
|
|
: Array()
|
|
|
|
, NumberOfPlanes(0)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create with externally managed memory
|
|
|
|
Storage(const BaseT* array, vtkm::Id arrayLength, vtkm::Int32 numberOfPlanes, bool cylindrical)
|
|
|
|
: Array(vtkm::cont::make_ArrayHandle(array, arrayLength))
|
|
|
|
, NumberOfPlanes(numberOfPlanes)
|
|
|
|
, UseCylindrical(cylindrical)
|
|
|
|
{
|
2019-06-22 03:01:03 +00:00
|
|
|
VTKM_ASSERT(this->Array.GetNumberOfValues() >= 0);
|
2019-06-06 18:43:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Storage(const HandleType& array, vtkm::Int32 numberOfPlanes, bool cylindrical)
|
|
|
|
: Array(array)
|
|
|
|
, NumberOfPlanes(numberOfPlanes)
|
|
|
|
, UseCylindrical(cylindrical)
|
|
|
|
{
|
2019-06-22 03:01:03 +00:00
|
|
|
VTKM_ASSERT(this->Array.GetNumberOfValues() >= 0);
|
2019-06-06 18:43:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PortalType GetPortal() { return PortalType{}; }
|
|
|
|
|
|
|
|
PortalConstType GetPortalConst() const
|
|
|
|
{
|
2019-06-22 03:01:03 +00:00
|
|
|
VTKM_ASSERT(this->Array.GetNumberOfValues() >= 0);
|
2019-06-06 18:43:53 +00:00
|
|
|
return PortalConstType(this->Array.GetPortalConstControl(),
|
2019-06-25 02:10:32 +00:00
|
|
|
static_cast<vtkm::Int32>(this->Array.GetNumberOfValues()),
|
2019-06-06 18:43:53 +00:00
|
|
|
this->NumberOfPlanes,
|
|
|
|
this->UseCylindrical);
|
|
|
|
}
|
|
|
|
|
|
|
|
vtkm::Id GetNumberOfValues() const
|
|
|
|
{
|
2019-06-22 03:01:03 +00:00
|
|
|
VTKM_ASSERT(this->Array.GetNumberOfValues() >= 0);
|
|
|
|
return (this->Array.GetNumberOfValues() / 2) * static_cast<vtkm::Id>(this->NumberOfPlanes);
|
2019-06-06 18:43:53 +00:00
|
|
|
}
|
|
|
|
|
2019-06-22 03:01:03 +00:00
|
|
|
vtkm::Id GetLength() const { return this->Array.GetNumberOfValues(); }
|
|
|
|
|
|
|
|
vtkm::Int32 GetNumberOfPlanes() const { return NumberOfPlanes; }
|
|
|
|
|
|
|
|
bool GetUseCylindrical() const { return UseCylindrical; }
|
2019-06-06 18:43:53 +00:00
|
|
|
void Allocate(vtkm::Id vtkmNotUsed(numberOfValues))
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("StorageTagExtrude is read only. It cannot be allocated.");
|
|
|
|
}
|
|
|
|
|
|
|
|
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues))
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("StoraageTagExtrue is read only. It cannot shrink.");
|
|
|
|
}
|
|
|
|
|
|
|
|
void ReleaseResources()
|
|
|
|
{
|
|
|
|
// This request is ignored since we don't own the memory that was past
|
|
|
|
// to us
|
|
|
|
}
|
|
|
|
|
2019-06-22 03:01:03 +00:00
|
|
|
|
2019-06-06 18:43:53 +00:00
|
|
|
vtkm::cont::ArrayHandle<BaseT> Array;
|
2019-06-22 03:01:03 +00:00
|
|
|
|
|
|
|
private:
|
2019-06-06 18:43:53 +00:00
|
|
|
vtkm::Int32 NumberOfPlanes;
|
|
|
|
bool UseCylindrical;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T, typename Device>
|
|
|
|
class VTKM_ALWAYS_EXPORT ArrayTransfer<T, internal::StorageTagExtrude, Device>
|
|
|
|
{
|
|
|
|
using BaseT = typename BaseComponent<T>::Type;
|
|
|
|
using TPortalType = decltype(vtkm::cont::ArrayHandle<BaseT>{}.PrepareForInput(Device{}));
|
|
|
|
|
|
|
|
public:
|
|
|
|
using ValueType = T;
|
|
|
|
using StorageType = vtkm::cont::internal::Storage<T, internal::StorageTagExtrude>;
|
|
|
|
|
|
|
|
using PortalControl = typename StorageType::PortalType;
|
|
|
|
using PortalConstControl = typename StorageType::PortalConstType;
|
|
|
|
|
|
|
|
//meant to be an invalid writeable execution portal
|
|
|
|
using PortalExecution = typename StorageType::PortalType;
|
|
|
|
|
|
|
|
using PortalConstExecution = vtkm::exec::ArrayPortalExtrude<TPortalType>;
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
ArrayTransfer(StorageType* storage)
|
|
|
|
: ControlData(storage)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
vtkm::Id GetNumberOfValues() const { return this->ControlData->GetNumberOfValues(); }
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
|
|
|
|
{
|
2019-06-25 02:10:32 +00:00
|
|
|
return PortalConstExecution(
|
|
|
|
this->ControlData->Array.PrepareForInput(Device()),
|
|
|
|
static_cast<vtkm::Int32>(this->ControlData->Array.GetNumberOfValues()),
|
|
|
|
this->ControlData->GetNumberOfPlanes(),
|
|
|
|
this->ControlData->GetUseCylindrical());
|
2019-06-06 18:43:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
PortalExecution PrepareForInPlace(bool& vtkmNotUsed(updateData))
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("StorageExtrude read only. "
|
|
|
|
"Cannot be used for in-place operations.");
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues))
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("StorageExtrude read only. Cannot be used as output.");
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
void RetrieveOutputData(StorageType* vtkmNotUsed(storage)) const
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorInternal(
|
|
|
|
"ArrayHandleExrPointCoordinates read only. "
|
|
|
|
"There should be no occurance of the ArrayHandle trying to pull "
|
|
|
|
"data from the execution environment.");
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues))
|
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("StorageExtrude read only. Cannot shrink.");
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
void ReleaseResources()
|
|
|
|
{
|
|
|
|
// This request is ignored since we don't own the memory that was past
|
|
|
|
// to us
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
const StorageType* const ControlData;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|