Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Implement DataSet Serialization

Browse Source
This commit is contained in:
Sujin Philip 2018-06-18 13:56:38 -04:00
parent fd89dfc89b
commit 365d3d3921
11 changed files with 755 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
vtkm/cont/CellSetExplicit.h
View File

@ -340,6 +340,76 @@ extern template class VTKM_CONT_TEMPLATE_EXPORT CellSetExplicit<
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename ShapeST, typename CountST, typename ConnectivityST, typename OffsetST>
struct TypeString<vtkm::cont::CellSetExplicit<ShapeST, CountST, ConnectivityST, OffsetST>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "CS_Explicit<" +
TypeString<vtkm::cont::ArrayHandle<vtkm::UInt8, ShapeST>>::Get() + "_ST," +
TypeString<vtkm::cont::ArrayHandle<vtkm::IdComponent, CountST>>::Get() + "_ST," +
TypeString<vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST>>::Get() + "_ST," +
TypeString<vtkm::cont::ArrayHandle<vtkm::Id, OffsetST>>::Get() + "_ST>";
return name;
}
};
}
} // vtkm::cont
namespace diy
{
template <typename ShapeST, typename CountST, typename ConnectivityST, typename OffsetST>
struct Serialization<vtkm::cont::CellSetExplicit<ShapeST, CountST, ConnectivityST, OffsetST>>
{
private:
using Type = vtkm::cont::CellSetExplicit<ShapeST, CountST, ConnectivityST, OffsetST>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& cs)
{
diy::save(bb, cs.GetName());
diy::save(bb, cs.GetNumberOfPoints());
diy::save(bb,
cs.GetShapesArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
diy::save(
bb, cs.GetNumIndicesArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
diy::save(
bb, cs.GetConnectivityArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
diy::save(
bb, cs.GetIndexOffsetArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& cs)
{
std::string name;
diy::load(bb, name);
vtkm::Id numberOfPoints = 0;
diy::load(bb, numberOfPoints);
vtkm::cont::ArrayHandle<vtkm::UInt8, ShapeST> shapes;
diy::load(bb, shapes);
vtkm::cont::ArrayHandle<vtkm::IdComponent, CountST> counts;
diy::load(bb, counts);
vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST> connectivity;
diy::load(bb, connectivity);
vtkm::cont::ArrayHandle<vtkm::Id, OffsetST> offsets;
diy::load(bb, offsets);
cs = Type(name);
cs.Fill(numberOfPoints, shapes, counts, connectivity, offsets);
}
};
} // diy
#include <vtkm/cont/CellSetExplicit.hxx>
#endif //vtk_m_cont_CellSetExplicit_h

52
vtkm/cont/CellSetPermutation.h
View File

@ -396,4 +396,56 @@ vtkm::cont::CellSetPermutation<OriginalCellSet, PermutationArrayHandleType> make
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename CSType, typename AHValidCellIds>
struct TypeString<vtkm::cont::CellSetPermutation<CSType, AHValidCellIds>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"CS_Permutation<" + TypeString<CSType>::Get() + "," + TypeString<AHValidCellIds>::Get() + ">";
return name;
}
};
}
} // vtkm::cont
namespace diy
{
template <typename CSType, typename AHValidCellIds>
struct Serialization<vtkm::cont::CellSetPermutation<CSType, AHValidCellIds>>
{
private:
using Type = vtkm::cont::CellSetPermutation<CSType, AHValidCellIds>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& cs)
{
diy::save(bb, cs.GetName());
diy::save(bb, cs.GetFullCellSet());
diy::save(bb, cs.GetValidCellIds());
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& cs)
{
std::string name;
diy::load(bb, name);
CSType fullCS;
diy::load(bb, fullCS);
AHValidCellIds validCellIds;
diy::load(bb, validCellIds);
cs = make_CellSetPermutation(validCellIds, fullCS, name);
}
};
} // diy
#endif //vtk_m_cont_CellSetPermutation_h

61
vtkm/cont/CellSetSingleType.h
View File

@ -261,4 +261,65 @@ private:
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename ConnectivityST>
struct TypeString<vtkm::cont::CellSetSingleType<ConnectivityST>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"CS_Single<" + TypeString<vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST>>::Get() + "_ST>";
return name;
}
};
}
} // vtkm::cont
namespace diy
{
template <typename ConnectivityST>
struct Serialization<vtkm::cont::CellSetSingleType<ConnectivityST>>
{
private:
using Type = vtkm::cont::CellSetSingleType<ConnectivityST>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& cs)
{
diy::save(bb, cs.GetName());
diy::save(bb, cs.GetNumberOfPoints());
diy::save(bb, cs.GetCellShape(0));
diy::save(bb, cs.GetNumberOfPointsInCell(0));
diy::save(
bb, cs.GetConnectivityArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& cs)
{
std::string name;
diy::load(bb, name);
vtkm::Id numberOfPoints = 0;
diy::load(bb, numberOfPoints);
vtkm::UInt8 shape;
diy::load(bb, shape);
vtkm::IdComponent count;
diy::load(bb, count);
vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST> connectivity;
diy::load(bb, connectivity);
cs = Type(name);
cs.Fill(numberOfPoints, shape, count, connectivity);
}
};
} // diy
#endif //vtk_m_cont_CellSetSingleType_h

48
vtkm/cont/CellSetStructured.h
View File

@ -112,6 +112,54 @@ extern template class VTKM_CONT_TEMPLATE_EXPORT CellSetStructured<3>;
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <vtkm::IdComponent DIMENSION>
struct TypeString<vtkm::cont::CellSetStructured<DIMENSION>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "CS_Structured<" + std::to_string(DIMENSION) + ">";
return name;
}
};
}
} // vtkm::cont
namespace diy
{
template <vtkm::IdComponent DIMENSION>
struct Serialization<vtkm::cont::CellSetStructured<DIMENSION>>
{
private:
using Type = vtkm::cont::CellSetStructured<DIMENSION>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& cs)
{
diy::save(bb, cs.GetName());
diy::save(bb, cs.GetPointDimensions());
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& cs)
{
std::string name;
diy::load(bb, name);
typename Type::SchedulingRangeType dims;
diy::load(bb, dims);
cs = Type(name);
cs.SetPointDimensions(dims);
}
};
} // diy
#include <vtkm/cont/CellSetStructured.hxx>
#endif //vtk_m_cont_CellSetStructured_h

26
vtkm/cont/CoordinateSystem.h
View File

@ -129,4 +129,30 @@ struct DynamicTransformTraits<vtkm::cont::CoordinateSystem>
} // namespace cont
} // namespace vtkm
//=============================================================================
// Specializations of serialization related classes
namespace diy
{
template <>
struct Serialization<vtkm::cont::CoordinateSystem>
{
static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::cont::CoordinateSystem& cs)
{
diy::save(bb, cs.GetName());
diy::save(bb, cs.GetData());
}
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::cont::CoordinateSystem& cs)
{
std::string name;
diy::load(bb, name);
vtkm::cont::ArrayHandleVirtualCoordinates array;
diy::load(bb, array);
cs = vtkm::cont::CoordinateSystem(name, array);
}
};
} // diy
#endif //vtk_m_cont_CoordinateSystem_h

98
vtkm/cont/DataSet.h
View File

@ -187,4 +187,102 @@ private:
} // namespace cont
} // namespace vtkm
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename FieldTypeList = VTKM_DEFAULT_TYPE_LIST_TAG,
typename FieldStorageList = VTKM_DEFAULT_STORAGE_LIST_TAG,
typename CellSetTypesList = VTKM_DEFAULT_CELL_SET_LIST_TAG>
struct SerializableDataSet
{
SerializableDataSet() = default;
explicit SerializableDataSet(const vtkm::cont::DataSet& dataset)
: DataSet(dataset)
{
}
vtkm::cont::DataSet DataSet;
};
}
} // vtkm::cont
namespace diy
{
template <typename FieldTypeList, typename FieldStorageList, typename CellSetTypesList>
struct Serialization<
vtkm::cont::SerializableDataSet<FieldTypeList, FieldStorageList, CellSetTypesList>>
{
private:
using Type = vtkm::cont::SerializableDataSet<FieldTypeList, FieldStorageList, CellSetTypesList>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& serializable)
{
const auto& dataset = serializable.DataSet;
vtkm::IdComponent numberOfCoordinateSystems = dataset.GetNumberOfCoordinateSystems();
diy::save(bb, numberOfCoordinateSystems);
for (vtkm::IdComponent i = 0; i < numberOfCoordinateSystems; ++i)
{
diy::save(bb, dataset.GetCoordinateSystem(i));
}
vtkm::IdComponent numberOfCellSets = dataset.GetNumberOfCellSets();
diy::save(bb, numberOfCellSets);
for (vtkm::IdComponent i = 0; i < numberOfCellSets; ++i)
{
diy::save(bb, dataset.GetCellSet(i).ResetCellSetList(CellSetTypesList{}));
}
vtkm::IdComponent numberOfFields = dataset.GetNumberOfFields();
diy::save(bb, numberOfFields);
for (vtkm::IdComponent i = 0; i < numberOfFields; ++i)
{
diy::save(
bb, vtkm::cont::SerializableField<FieldTypeList, FieldStorageList>(dataset.GetField(i)));
}
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& serializable)
{
auto& dataset = serializable.DataSet;
dataset = {}; // clear
vtkm::IdComponent numberOfCoordinateSystems = 0;
diy::load(bb, numberOfCoordinateSystems);
for (vtkm::IdComponent i = 0; i < numberOfCoordinateSystems; ++i)
{
vtkm::cont::CoordinateSystem coords;
diy::load(bb, coords);
dataset.AddCoordinateSystem(coords);
}
vtkm::IdComponent numberOfCellSets = 0;
diy::load(bb, numberOfCellSets);
for (vtkm::IdComponent i = 0; i < numberOfCellSets; ++i)
{
vtkm::cont::DynamicCellSetBase<CellSetTypesList> cells;
diy::load(bb, cells);
dataset.AddCellSet(vtkm::cont::DynamicCellSet(cells));
}
vtkm::IdComponent numberOfFields = 0;
diy::load(bb, numberOfFields);
for (vtkm::IdComponent i = 0; i < numberOfFields; ++i)
{
vtkm::cont::SerializableField<FieldTypeList, FieldStorageList> field;
diy::load(bb, field);
dataset.AddField(field.Field);
}
}
};
} // diy
#endif //vtk_m_cont_DataSet_h

75
vtkm/cont/DynamicCellSet.h
View File

@ -357,4 +357,79 @@ struct DynamicCellSetCheck<vtkm::cont::DynamicCellSetBase<CellSetList>>
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace diy
{
namespace internal
{
struct DynamicCellSetSerializeFunctor
{
template <typename CellSetType>
void operator()(const CellSetType& cs, BinaryBuffer& bb) const
{
diy::save(bb, vtkm::cont::TypeString<CellSetType>::Get());
diy::save(bb, cs);
}
};
template <typename CellSetTypes>
struct DynamicCellSetDeserializeFunctor
{
template <typename CellSetType>
void operator()(CellSetType,
vtkm::cont::DynamicCellSetBase<CellSetTypes>& dh,
const std::string& typeString,
bool& success,
BinaryBuffer& bb) const
{
if (!success && (typeString == vtkm::cont::TypeString<CellSetType>::Get()))
{
CellSetType cs;
diy::load(bb, cs);
dh = vtkm::cont::DynamicCellSetBase<CellSetTypes>(cs);
success = true;
}
}
};
} // internal
template <typename CellSetTypes>
struct Serialization<vtkm::cont::DynamicCellSetBase<CellSetTypes>>
{
private:
using Type = vtkm::cont::DynamicCellSetBase<CellSetTypes>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& obj)
{
obj.CastAndCall(internal::DynamicCellSetSerializeFunctor{}, bb);
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& obj)
{
std::string typeString;
diy::load(bb, typeString);
bool success = false;
vtkm::ListForEach(internal::DynamicCellSetDeserializeFunctor<CellSetTypes>{},
CellSetTypes{},
obj,
typeString,
success,
bb);
if (!success)
{
throw vtkm::cont::ErrorBadType("Error deserializing DynamicCellSet. Message TypeString: " +
typeString);
}
}
};
} // diy
#endif //vtk_m_cont_DynamicCellSet_h

86
vtkm/cont/Field.h
View File

@ -398,4 +398,90 @@ struct DynamicTransformTraits<vtkm::cont::Field>
} // namespace cont
} // namespace vtkm
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename TypeList = VTKM_DEFAULT_TYPE_LIST_TAG,
typename StorageList = VTKM_DEFAULT_STORAGE_LIST_TAG>
struct SerializableField
{
SerializableField() = default;
explicit SerializableField(const vtkm::cont::Field& field)
: Field(field)
{
}
vtkm::cont::Field Field;
};
}
} // vtkm::cont
namespace diy
{
template <typename TypeList, typename StorageList>
struct Serialization<vtkm::cont::SerializableField<TypeList, StorageList>>
{
private:
using Type = vtkm::cont::SerializableField<TypeList, StorageList>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& serializable)
{
const auto& field = serializable.Field;
diy::save(bb, field.GetName());
diy::save(bb, static_cast<int>(field.GetAssociation()));
if (field.GetAssociation() == vtkm::cont::Field::Association::CELL_SET)
{
diy::save(bb, field.GetAssocCellSet());
}
else if (field.GetAssociation() == vtkm::cont::Field::Association::LOGICAL_DIM)
{
diy::save(bb, field.GetAssocLogicalDim());
}
diy::save(bb, field.GetData().ResetTypeAndStorageLists(TypeList{}, StorageList{}));
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& serializable)
{
auto& field = serializable.Field;
std::string name;
diy::load(bb, name);
int assocVal = 0;
diy::load(bb, assocVal);
auto assoc = static_cast<vtkm::cont::Field::Association>(assocVal);
vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList> data;
if (assoc == vtkm::cont::Field::Association::CELL_SET)
{
std::string assocCellSetName;
diy::load(bb, assocCellSetName);
diy::load(bb, data);
field =
vtkm::cont::Field(name, assoc, assocCellSetName, vtkm::cont::DynamicArrayHandle(data));
}
else if (assoc == vtkm::cont::Field::Association::LOGICAL_DIM)
{
vtkm::IdComponent assocLogicalDim;
diy::load(bb, assocLogicalDim);
diy::load(bb, data);
field = vtkm::cont::Field(name, assoc, assocLogicalDim, vtkm::cont::DynamicArrayHandle(data));
}
else
{
diy::load(bb, data);
field = vtkm::cont::Field(name, assoc, vtkm::cont::DynamicArrayHandle(data));
}
}
};
} // diy
#endif //vtk_m_cont_Field_h

1
vtkm/cont/testing/CMakeLists.txt
View File

@ -89,5 +89,6 @@ vtkm_unit_tests(SOURCES ${unit_tests})
set(mpi_unit_tests
UnitTestFieldRangeGlobalCompute.cxx
UnitTestSerializationArrayHandle.cxx
UnitTestSerializationDataSet.cxx
)
vtkm_unit_tests(MPI SOURCES ${mpi_unit_tests})

196
vtkm/cont/testing/UnitTestSerializationDataSet.cxx Normal file
View File

@ -0,0 +1,196 @@
//============================================================================
// 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 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-NA0003525 with NTESS,
// 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.
//============================================================================
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/cont/testing/TestingSerialization.h>
using namespace vtkm::cont::testing::serialization;
namespace
{
struct TestEqualCellSet
{
template <typename ShapeST, typename CountST, typename ConnectivityST, typename OffsetST>
void operator()(
const vtkm::cont::CellSetExplicit<ShapeST, CountST, ConnectivityST, OffsetST>& cs1,
const vtkm::cont::CellSetExplicit<ShapeST, CountST, ConnectivityST, OffsetST>& cs2) const
{
vtkm::TopologyElementTagPoint p2cFrom{};
vtkm::TopologyElementTagCell p2cTo{};
VTKM_TEST_ASSERT(cs1.GetName() == cs2.GetName(), "cellset names don't match");
VTKM_TEST_ASSERT(cs1.GetNumberOfPoints() == cs2.GetNumberOfPoints(),
"cellset number of points don't match");
TestEqualArrayHandle{}(cs1.GetShapesArray(p2cFrom, p2cTo), cs2.GetShapesArray(p2cFrom, p2cTo));
TestEqualArrayHandle{}(cs1.GetNumIndicesArray(p2cFrom, p2cTo),
cs2.GetNumIndicesArray(p2cFrom, p2cTo));
TestEqualArrayHandle{}(cs1.GetConnectivityArray(p2cFrom, p2cTo),
cs2.GetConnectivityArray(p2cFrom, p2cTo));
TestEqualArrayHandle{}(cs1.GetIndexOffsetArray(p2cFrom, p2cTo),
cs2.GetIndexOffsetArray(p2cFrom, p2cTo));
}
template <vtkm::IdComponent DIMENSION>
void operator()(const vtkm::cont::CellSetStructured<DIMENSION>& cs1,
const vtkm::cont::CellSetStructured<DIMENSION>& cs2) const
{
VTKM_TEST_ASSERT(cs1.GetName() == cs2.GetName(), "cellset names don't match");
VTKM_TEST_ASSERT(cs1.GetPointDimensions() == cs2.GetPointDimensions(),
"CellSetStructured: point dimensions don't match");
}
template <typename CellSetTypes>
void operator()(const vtkm::cont::DynamicCellSetBase<CellSetTypes>& cs1,
const vtkm::cont::DynamicCellSetBase<CellSetTypes>& cs2)
{
cs1.CastAndCall(*this, cs2);
}
template <typename CellSet, typename CellSetTypes>
void operator()(const CellSet& cs, const vtkm::cont::DynamicCellSetBase<CellSetTypes>& dcs)
{
this->operator()(cs, dcs.template Cast<CellSet>());
}
};
template <typename FieldTypeList, typename FieldStorageList, typename CellSetTypes>
void TestEqualDataSet(
const vtkm::cont::SerializableDataSet<FieldTypeList, FieldStorageList, CellSetTypes>& s1,
const vtkm::cont::SerializableDataSet<FieldTypeList, FieldStorageList, CellSetTypes>& s2)
{
const auto& ds1 = s1.DataSet;
const auto& ds2 = s2.DataSet;
VTKM_TEST_ASSERT(ds1.GetNumberOfCoordinateSystems() == ds2.GetNumberOfCoordinateSystems(),
"datasets' number of coordinate systems don't match");
for (vtkm::IdComponent i = 0; i < ds1.GetNumberOfCoordinateSystems(); ++i)
{
TestEqualArrayHandle{}(ds1.GetCoordinateSystem(i).GetData(),
ds2.GetCoordinateSystem(i).GetData());
}
VTKM_TEST_ASSERT(ds1.GetNumberOfCellSets() == ds2.GetNumberOfCellSets(),
"datasets' number of cellsets don't match");
for (vtkm::IdComponent i = 0; i < ds1.GetNumberOfCellSets(); ++i)
{
TestEqualCellSet{}(ds1.GetCellSet(i).ResetCellSetList(CellSetTypes{}),
ds2.GetCellSet(i).ResetCellSetList(CellSetTypes{}));
}
VTKM_TEST_ASSERT(ds1.GetNumberOfFields() == ds2.GetNumberOfFields(),
"datasets' number of fields don't match");
for (vtkm::IdComponent i = 0; i < ds1.GetNumberOfFields(); ++i)
{
auto f1 = ds1.GetField(i);
auto f2 = ds2.GetField(i);
VTKM_TEST_ASSERT(f1.GetName() == f2.GetName(), "field names don't match");
VTKM_TEST_ASSERT(f1.GetAssociation() == f1.GetAssociation(), "fields' association don't match");
if (f1.GetAssociation() == vtkm::cont::Field::Association::CELL_SET)
{
VTKM_TEST_ASSERT(f1.GetAssocCellSet() == f2.GetAssocCellSet(),
"fields' associated cellset names don't match");
}
else if (f1.GetAssociation() == vtkm::cont::Field::Association::LOGICAL_DIM)
{
VTKM_TEST_ASSERT(f1.GetAssocLogicalDim() == f2.GetAssocLogicalDim(),
"fields' associated logical dims don't match");
}
TestEqualArrayHandle{}(
f1.GetData().ResetTypeAndStorageLists(FieldTypeList{}, FieldStorageList{}),
f2.GetData().ResetTypeAndStorageLists(FieldTypeList{}, FieldStorageList{}));
}
}
void RunTest(const vtkm::cont::DataSet& ds)
{
using TypeList = vtkm::ListTagBase<vtkm::Float32>;
using StorageList = VTKM_DEFAULT_STORAGE_LIST_TAG;
using CellSetTypes = vtkm::ListTagBase<vtkm::cont::CellSetExplicit<>,
vtkm::cont::CellSetSingleType<>,
vtkm::cont::CellSetStructured<1>,
vtkm::cont::CellSetStructured<2>,
vtkm::cont::CellSetStructured<3>>;
TestSerialization(vtkm::cont::SerializableDataSet<TypeList, StorageList, CellSetTypes>(ds),
TestEqualDataSet<TypeList, StorageList, CellSetTypes>);
}
void TestDataSetSerialization()
{
vtkm::cont::testing::MakeTestDataSet makeDS;
std::cout << "Testing 1D Uniform DataSet #0\n";
RunTest(makeDS.Make1DUniformDataSet0());
std::cout << "Testing 1D Uniform DataSet #1\n";
RunTest(makeDS.Make1DUniformDataSet1());
std::cout << "Testing 2D Uniform DataSet #0\n";
RunTest(makeDS.Make2DUniformDataSet0());
std::cout << "Testing 2D Uniform DataSet #1\n";
RunTest(makeDS.Make2DUniformDataSet1());
std::cout << "Testing 3D Uniform DataSet #0\n";
RunTest(makeDS.Make3DUniformDataSet0());
std::cout << "Testing 3D Uniform DataSet #1\n";
RunTest(makeDS.Make3DUniformDataSet1());
std::cout << "Testing 3D Uniform DataSet #2\n";
RunTest(makeDS.Make3DUniformDataSet2());
std::cout << "Testing 3D Regular DataSet #0\n";
RunTest(makeDS.Make3DRegularDataSet0());
std::cout << "Testing 3D Regular DataSet #1\n";
RunTest(makeDS.Make3DRegularDataSet1());
std::cout << "Testing 2D Rectilinear DataSet #0\n";
RunTest(makeDS.Make2DRectilinearDataSet0());
std::cout << "Testing 3D Rectilinear DataSet #0\n";
RunTest(makeDS.Make3DRectilinearDataSet0());
std::cout << "Testing 1D Explicit DataSet #0\n";
RunTest(makeDS.Make1DExplicitDataSet0());
std::cout << "Testing 2D Explicit DataSet #0\n";
RunTest(makeDS.Make2DExplicitDataSet0());
std::cout << "Testing 3D Explicit DataSet #0\n";
RunTest(makeDS.Make3DExplicitDataSet0());
std::cout << "Testing 3D Explicit DataSet #1\n";
RunTest(makeDS.Make3DExplicitDataSet1());
std::cout << "Testing 3D Explicit DataSet #2\n";
RunTest(makeDS.Make3DExplicitDataSet2());
std::cout << "Testing 3D Explicit DataSet #3\n";
RunTest(makeDS.Make3DExplicitDataSet3());
std::cout << "Testing 3D Explicit DataSet #4\n";
RunTest(makeDS.Make3DExplicitDataSet4());
std::cout << "Testing 3D Explicit DataSet #5\n";
RunTest(makeDS.Make3DExplicitDataSet5());
std::cout << "Testing 3D Explicit DataSet #6\n";
RunTest(makeDS.Make3DExplicitDataSet6());
std::cout << "Testing 3D Polygonal DataSet #0\n";
RunTest(makeDS.Make3DExplicitDataSetPolygonal());
std::cout << "Testing Cow Nose DataSet\n";
RunTest(makeDS.Make3DExplicitDataSetCowNose());
}
} // anonymous namespace
int UnitTestSerializationDataSet(int, char* [])
{
return vtkm::cont::testing::Testing::Run(TestDataSetSerialization);
}

43
vtkm/filter/PolicyBase.h
View File

@ -25,6 +25,7 @@
#include <vtkm/cont/CellSetListTag.h>
#include <vtkm/cont/CoordinateSystem.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/DeviceAdapterListTag.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/Field.h>
@ -107,7 +108,47 @@ ApplyPolicyUnstructured(const vtkm::cont::DynamicCellSet& cellset,
using CellSetList = typename DerivedPolicy::UnstructuredCellSetList;
return cellset.ResetCellSetList(CellSetList());
}
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList,
typename DerivedPolicy::FieldStorageList>
MakeSerializableField(const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
return {};
}
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList,
typename DerivedPolicy::FieldStorageList>
MakeSerializableField(const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
return vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList,
typename DerivedPolicy::FieldStorageList>{ field };
}
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::SerializableDataSet<typename DerivedPolicy::FieldTypeList,
typename DerivedPolicy::FieldStorageList,
typename DerivedPolicy::AllCellSetList>
MakeSerializableDataSet(const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
return {};
}
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::SerializableDataSet<typename DerivedPolicy::FieldTypeList,
typename DerivedPolicy::FieldStorageList,
typename DerivedPolicy::AllCellSetList>
MakeSerializableDataSet(const vtkm::cont::DataSet& dataset,
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
return vtkm::cont::SerializableDataSet<typename DerivedPolicy::FieldTypeList,
typename DerivedPolicy::FieldStorageList,
typename DerivedPolicy::AllCellSetList>{ dataset };
}
}
} // vtkm::filter
#endif //vtk_m_filter_PolicyBase_h