Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 10:35:42 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
ad49b1e25b
vtk-m/vtkm/cont/DataSetBuilderRectilinear.h
Kenneth Moreland 170a10e4b4 Fix slow ArrayCopy calls 
The `ArrayCopy` method has been changed to be precompiled. It handles
most standard array types. But there are some special `ArrayHandle`
types that are not correctly handled, and these go to a slow fallback.
Find places in the code that use that fallback and fix them.

There are also some instances of replacing an `ArrayHandleCounting` with
an `ArrayHandleIndex`. This change is probably not strictly necessary to
make the `ArrayCopy` faster, but when it can be used `ArrayHandleIndex`
is generally better.
2022-01-24 14:15:45 -07:00

248 lines
9.2 KiB
C++
Raw Blame History

//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_cont_DataSetBuilderRectilinear_h
#define vtk_m_cont_DataSetBuilderRectilinear_h
#include <vtkm/cont/ArrayCopy.h>
#include <vtkm/cont/ArrayHandleCartesianProduct.h>
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/CoordinateSystem.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/serial/DeviceAdapterSerial.h>
namespace vtkm
{
namespace cont
{
class VTKM_CONT_EXPORT DataSetBuilderRectilinear
{
template <typename T, typename U>
VTKM_CONT static void CopyInto(const std::vector<T>& input, vtkm::cont::ArrayHandle<U>& output)
{
DataSetBuilderRectilinear::CopyInto(vtkm::cont::make_ArrayHandle(input, vtkm::CopyFlag::Off),
output);
}
template <typename T, typename U>
VTKM_CONT static void CopyInto(const vtkm::cont::ArrayHandle<T>& input,
vtkm::cont::ArrayHandle<U>& output)
{
vtkm::cont::ArrayCopy(input, output);
}
template <typename T, typename U>
VTKM_CONT static void CopyInto(const T* input, vtkm::Id len, vtkm::cont::ArrayHandle<U>& output)
{
DataSetBuilderRectilinear::CopyInto(
vtkm::cont::make_ArrayHandle(input, len, vtkm::CopyFlag::Off), output);
}
public:
VTKM_CONT
DataSetBuilderRectilinear();
//1D grids.
template <typename T>
VTKM_CONT static vtkm::cont::DataSet Create(const std::vector<T>& xvals,
const std::string& coordNm = "coords")
{
std::vector<T> yvals(1, 0), zvals(1, 0);
return DataSetBuilderRectilinear::BuildDataSet(xvals, yvals, zvals, coordNm);
}
template <typename T>
VTKM_CONT static vtkm::cont::DataSet Create(vtkm::Id nx,
T* xvals,
const std::string& coordNm = "coords")
{
T yvals = 0, zvals = 0;
return DataSetBuilderRectilinear::BuildDataSet(nx, 1, 1, xvals, &yvals, &zvals, coordNm);
}
template <typename T>
VTKM_CONT static vtkm::cont::DataSet Create(const vtkm::cont::ArrayHandle<T>& xvals,
const std::string& coordNm = "coords")
{
vtkm::cont::ArrayHandle<T> yvals, zvals;
yvals.Allocate(1);
yvals.WritePortal().Set(0, 0.0);
zvals.Allocate(1);
zvals.WritePortal().Set(0, 0.0);
return DataSetBuilderRectilinear::BuildDataSet(xvals, yvals, zvals, coordNm);
}
//2D grids.
template <typename T>
VTKM_CONT static vtkm::cont::DataSet Create(const std::vector<T>& xvals,
const std::vector<T>& yvals,
const std::string& coordNm = "coords")
{
std::vector<T> zvals(1, 0);
return DataSetBuilderRectilinear::BuildDataSet(xvals, yvals, zvals, coordNm);
}
template <typename T>
VTKM_CONT static vtkm::cont::DataSet Create(vtkm::Id nx,
vtkm::Id ny,
T* xvals,
T* yvals,
const std::string& coordNm = "coords")
{
T zvals = 0;
return DataSetBuilderRectilinear::BuildDataSet(nx, ny, 1, xvals, yvals, &zvals, coordNm);
}
template <typename T>
VTKM_CONT static vtkm::cont::DataSet Create(const vtkm::cont::ArrayHandle<T>& xvals,
const vtkm::cont::ArrayHandle<T>& yvals,
const std::string& coordNm = "coords")
{
vtkm::cont::ArrayHandle<T> zvals;
zvals.Allocate(1);
zvals.WritePortal().Set(0, 0.0);
return DataSetBuilderRectilinear::BuildDataSet(xvals, yvals, zvals, coordNm);
}
//3D grids.
template <typename T>
VTKM_CONT static vtkm::cont::DataSet Create(vtkm::Id nx,
vtkm::Id ny,
vtkm::Id nz,
T* xvals,
T* yvals,
T* zvals,
const std::string& coordNm = "coords")
{
return DataSetBuilderRectilinear::BuildDataSet(nx, ny, nz, xvals, yvals, zvals, coordNm);
}
template <typename T>
VTKM_CONT static vtkm::cont::DataSet Create(const std::vector<T>& xvals,
const std::vector<T>& yvals,
const std::vector<T>& zvals,
const std::string& coordNm = "coords")
{
return DataSetBuilderRectilinear::BuildDataSet(xvals, yvals, zvals, coordNm);
}
template <typename T>
VTKM_CONT static vtkm::cont::DataSet Create(const vtkm::cont::ArrayHandle<T>& xvals,
const vtkm::cont::ArrayHandle<T>& yvals,
const vtkm::cont::ArrayHandle<T>& zvals,
const std::string& coordNm = "coords")
{
return DataSetBuilderRectilinear::BuildDataSet(xvals, yvals, zvals, coordNm);
}
private:
template <typename T>
VTKM_CONT static vtkm::cont::DataSet BuildDataSet(const std::vector<T>& xvals,
const std::vector<T>& yvals,
const std::vector<T>& zvals,
const std::string& coordNm)
{
vtkm::cont::ArrayHandle<vtkm::FloatDefault> Xc, Yc, Zc;
DataSetBuilderRectilinear::CopyInto(xvals, Xc);
DataSetBuilderRectilinear::CopyInto(yvals, Yc);
DataSetBuilderRectilinear::CopyInto(zvals, Zc);
return DataSetBuilderRectilinear::BuildDataSet(Xc, Yc, Zc, coordNm);
}
template <typename T>
VTKM_CONT static vtkm::cont::DataSet BuildDataSet(vtkm::Id nx,
vtkm::Id ny,
vtkm::Id nz,
const T* xvals,
const T* yvals,
const T* zvals,
const std::string& coordNm)
{
vtkm::cont::ArrayHandle<vtkm::FloatDefault> Xc, Yc, Zc;
DataSetBuilderRectilinear::CopyInto(xvals, nx, Xc);
DataSetBuilderRectilinear::CopyInto(yvals, ny, Yc);
DataSetBuilderRectilinear::CopyInto(zvals, nz, Zc);
return DataSetBuilderRectilinear::BuildDataSet(Xc, Yc, Zc, coordNm);
}
template <typename T>
VTKM_CONT static vtkm::cont::DataSet BuildDataSet(const vtkm::cont::ArrayHandle<T>& X,
const vtkm::cont::ArrayHandle<T>& Y,
const vtkm::cont::ArrayHandle<T>& Z,
const std::string& coordNm)
{
vtkm::cont::DataSet dataSet;
//Convert all coordinates to floatDefault.
vtkm::cont::ArrayHandleCartesianProduct<vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>>
coords;
vtkm::cont::ArrayHandle<vtkm::FloatDefault> Xc, Yc, Zc;
DataSetBuilderRectilinear::CopyInto(X, Xc);
DataSetBuilderRectilinear::CopyInto(Y, Yc);
DataSetBuilderRectilinear::CopyInto(Z, Zc);
coords = vtkm::cont::make_ArrayHandleCartesianProduct(Xc, Yc, Zc);
vtkm::cont::CoordinateSystem cs(coordNm, coords);
dataSet.AddCoordinateSystem(cs);
// compute the dimensions of the cellset by counting the number of axes
// with >1 dimension
int ndims = 0;
vtkm::Id dims[3];
if (Xc.GetNumberOfValues() > 1)
{
dims[ndims++] = Xc.GetNumberOfValues();
}
if (Yc.GetNumberOfValues() > 1)
{
dims[ndims++] = Yc.GetNumberOfValues();
}
if (Zc.GetNumberOfValues() > 1)
{
dims[ndims++] = Zc.GetNumberOfValues();
}
if (ndims == 1)
{
vtkm::cont::CellSetStructured<1> cellSet;
cellSet.SetPointDimensions(dims[0]);
dataSet.SetCellSet(cellSet);
}
else if (ndims == 2)
{
vtkm::cont::CellSetStructured<2> cellSet;
cellSet.SetPointDimensions(vtkm::make_Vec(dims[0], dims[1]));
dataSet.SetCellSet(cellSet);
}
else if (ndims == 3)
{
vtkm::cont::CellSetStructured<3> cellSet;
cellSet.SetPointDimensions(vtkm::make_Vec(dims[0], dims[1], dims[2]));
dataSet.SetCellSet(cellSet);
}
else
{
throw vtkm::cont::ErrorBadValue("Invalid cell set dimension");
}
return dataSet;
}
};
} // namespace cont
} // namespace vtkm
#endif //vtk_m_cont_DataSetBuilderRectilinear_h
Reference in New Issue View Git Blame Copy Permalink