Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Merge topic 'partitioned_dataset_fields'

Browse Source 
0fb721207 Kick the dashboard builds.
30d1d86a0 Method was deprecated during the rename within the MR. (Not a new method).
a215ac320 Use {} initialization of FieldCollection.
4b60978a0 Simplify implementation of CreateResult.
98994026b Change GetPartitionField to GetFieldFromPartition.
fbe78b45c Change all usage of IsField* to Is*Field.
e395fe8fe Rename methods for consistency.
019d6cbc6 fix build error due to typo.
...

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !2853
This commit is contained in:
Dave Pugmire 2022-08-31 01:25:24 +00:00 committed by Kitware Robot
commit 7740ba5bc1
74 changed files with 766 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tutorial/extract_edges.cxx
View File

@ -127,11 +127,11 @@ VTKM_CONT bool DoMapField(
{
vtkm::cont::Field outputField;
if (inputField.IsFieldPoint())
if (inputField.IsPointField())
{
outputField = inputField; // pass through
}
else if (inputField.IsFieldCell())
else if (inputField.IsCellField())
{
vtkm::cont::Field permuted;
vtkm::filter::MapFieldPermutation(inputField, OutputToInputCellMap, permuted);

1
vtkm/cont/CMakeLists.txt
View File

@ -166,6 +166,7 @@ set(sources
FieldRangeGlobalCompute.cxx
internal/DeviceAdapterMemoryManager.cxx
internal/DeviceAdapterMemoryManagerShared.cxx
internal/FieldCollection.cxx
internal/RuntimeDeviceConfiguration.cxx
internal/RuntimeDeviceConfigurationOptions.cxx
internal/RuntimeDeviceOption.cxx

57
vtkm/cont/DataSet.cxx
View File

@ -34,7 +34,7 @@ VTKM_CONT void SetGlobalGhostCellFieldName(const std::string& name) noexcept
void DataSet::Clear()
{
this->CoordSystems.clear();
this->Fields.clear();
this->Fields.Clear();
this->CellSet = this->CellSet.NewInstance();
}
@ -59,55 +59,6 @@ void DataSet::CopyStructure(const vtkm::cont::DataSet& source)
this->GhostCellName = source.GhostCellName;
}
const vtkm::cont::Field& DataSet::GetField(vtkm::Id index) const
{
VTKM_ASSERT((index >= 0) && (index < this->GetNumberOfFields()));
auto it = this->Fields.cbegin();
std::advance(it, index);
return it->second;
}
vtkm::cont::Field& DataSet::GetField(vtkm::Id index)
{
VTKM_ASSERT((index >= 0) && (index < this->GetNumberOfFields()));
auto it = this->Fields.begin();
std::advance(it, index);
return it->second;
}
vtkm::Id DataSet::GetFieldIndex(const std::string& name, vtkm::cont::Field::Association assoc) const
{
const auto it = this->Fields.find({ name, assoc });
if (it != this->Fields.end())
{
return static_cast<vtkm::Id>(std::distance(this->Fields.begin(), it));
}
return -1;
}
const vtkm::cont::Field& DataSet::GetField(const std::string& name,
vtkm::cont::Field::Association assoc) const
{
auto idx = this->GetFieldIndex(name, assoc);
if (idx == -1)
{
throw vtkm::cont::ErrorBadValue("No field with requested name: " + name);
}
return this->GetField(idx);
}
vtkm::cont::Field& DataSet::GetField(const std::string& name, vtkm::cont::Field::Association assoc)
{
auto idx = this->GetFieldIndex(name, assoc);
if (idx == -1)
{
throw vtkm::cont::ErrorBadValue("No field with requested name: " + name);
}
return this->GetField(idx);
}
const vtkm::cont::CoordinateSystem& DataSet::GetCoordinateSystem(vtkm::Id index) const
{
VTKM_ASSERT((index >= 0) && (index < this->GetNumberOfCoordinateSystems()));
@ -187,12 +138,6 @@ void DataSet::PrintSummary(std::ostream& out) const
out.flush();
}
VTKM_CONT void DataSet::AddField(const Field& field)
{
// map::insert will not replace the duplicated element
this->Fields[{ field.GetName(), field.GetAssociation() }] = field;
}
void DataSet::ConvertToExpected()
{
for (vtkm::IdComponent coordIndex = 0; coordIndex < this->GetNumberOfCoordinateSystems();

54
vtkm/cont/DataSet.h
View File

@ -18,6 +18,7 @@
#include <vtkm/cont/Field.h>
#include <vtkm/cont/UnknownArrayHandle.h>
#include <vtkm/cont/UnknownCellSet.h>
#include <vtkm/cont/internal/FieldCollection.h>
namespace vtkm
{
@ -54,25 +55,25 @@ public:
/// to have the same number of points.
VTKM_CONT vtkm::Id GetNumberOfPoints() const;
VTKM_CONT void AddField(const Field& field);
VTKM_CONT void AddField(const Field& field) { this->Fields.AddField(field); }
VTKM_CONT
const vtkm::cont::Field& GetField(vtkm::Id index) const;
const vtkm::cont::Field& GetField(vtkm::Id index) const { return this->Fields.GetField(index); }
VTKM_CONT
vtkm::cont::Field& GetField(vtkm::Id index);
vtkm::cont::Field& GetField(vtkm::Id index) { return this->Fields.GetField(index); }
VTKM_CONT
bool HasField(const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const
{
return (this->GetFieldIndex(name, assoc) != -1);
return this->Fields.HasField(name, assoc);
}
VTKM_CONT
bool HasCellField(const std::string& name) const
{
return (this->GetFieldIndex(name, vtkm::cont::Field::Association::Cells) != -1);
return (this->Fields.GetFieldIndex(name, vtkm::cont::Field::Association::Cells) != -1);
}
VTKM_CONT
@ -104,7 +105,7 @@ public:
VTKM_CONT
bool HasPointField(const std::string& name) const
{
return (this->GetFieldIndex(name, vtkm::cont::Field::Association::Points) != -1);
return (this->Fields.GetFieldIndex(name, vtkm::cont::Field::Association::Points) != -1);
}
@ -113,7 +114,10 @@ public:
VTKM_CONT
vtkm::Id GetFieldIndex(
const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const;
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const
{
return this->Fields.GetFieldIndex(name, assoc);
}
/// Returns the field that matches the provided name and association
/// Will throw an exception if no match is found
@ -121,12 +125,19 @@ public:
VTKM_CONT
const vtkm::cont::Field& GetField(
const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const;
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const
{
return this->Fields.GetField(name, assoc);
}
VTKM_CONT
vtkm::cont::Field& GetField(
const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any);
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any)
{
return this->Fields.GetField(name, assoc);
}
//@}
/// Returns the first cell field that matches the provided name.
@ -309,10 +320,7 @@ public:
vtkm::cont::UnknownCellSet& GetCellSet() { return this->CellSet; }
VTKM_CONT
vtkm::IdComponent GetNumberOfFields() const
{
return static_cast<vtkm::IdComponent>(this->Fields.size());
}
vtkm::IdComponent GetNumberOfFields() const { return this->Fields.GetNumberOfFields(); }
VTKM_CONT
vtkm::IdComponent GetNumberOfCoordinateSystems() const
@ -344,23 +352,11 @@ public:
void PrintSummary(std::ostream& out) const;
private:
struct FieldCompare
{
using Key = std::pair<std::string, vtkm::cont::Field::Association>;
template <typename T>
bool operator()(const T& a, const T& b) const
{
if (a.first == b.first)
return a.second < b.second && a.second != vtkm::cont::Field::Association::Any &&
b.second != vtkm::cont::Field::Association::Any;
return a.first < b.first;
}
};
std::vector<vtkm::cont::CoordinateSystem> CoordSystems;
std::map<FieldCompare::Key, vtkm::cont::Field, FieldCompare> Fields;
vtkm::cont::internal::FieldCollection Fields{ vtkm::cont::Field::Association::WholeDataSet,
vtkm::cont::Field::Association::Points,
vtkm::cont::Field::Association::Cells };
vtkm::cont::UnknownCellSet CellSet;
std::shared_ptr<std::string> GhostCellName;
};

10
vtkm/cont/Field.cxx
View File

@ -88,8 +88,8 @@ void Field::PrintSummary(std::ostream& out) const
case Association::Any:
out << "Any ";
break;
case Association::WholeMesh:
out << "Mesh ";
case Association::WholeDataSet:
out << "WholeDataSet ";
break;
case Association::Points:
out << "Points ";
@ -97,6 +97,12 @@ void Field::PrintSummary(std::ostream& out) const
case Association::Cells:
out << "Cells ";
break;
case Association::Partitions:
out << "Partitions ";
break;
case Association::Global:
out << "Global ";
break;
}
this->Data.PrintSummary(out);
}

35
vtkm/cont/Field.h
View File

@ -34,13 +34,18 @@ public:
enum struct Association
{
Any,
WholeMesh,
WholeDataSet,
Points,
Cells,
Partitions,
Global,
ANY VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::Any.") = Any,
WHOLE_MESH VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::WholeMesh.") = WholeMesh,
WHOLE_MESH VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::WholeDataSet.") =
WholeDataSet,
POINTS VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::Points.") = Points,
CELL_SET VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::Cells.") = Cells
CELL_SET VTKM_DEPRECATED(1.8, "Use vtkm::cont::Field::Association::Cells.") = Cells,
WholeMesh VTKM_DEPRECATED(1.9, "Use vtkm::cont::Field::Association::WholeDataSet.") =
WholeDataSet
};
VTKM_CONT
@ -65,9 +70,27 @@ public:
VTKM_CONT Field& operator=(const vtkm::cont::Field& src);
VTKM_CONT Field& operator=(vtkm::cont::Field&& src) noexcept;
VTKM_CONT bool IsFieldCell() const { return this->FieldAssociation == Association::Cells; }
VTKM_CONT bool IsFieldPoint() const { return this->FieldAssociation == Association::Points; }
VTKM_CONT bool IsFieldGlobal() const { return this->FieldAssociation == Association::WholeMesh; }
VTKM_CONT bool IsCellField() const { return this->FieldAssociation == Association::Cells; }
VTKM_CONT bool IsPointField() const { return this->FieldAssociation == Association::Points; }
VTKM_CONT bool IsWholeDataSetField() const
{
return this->FieldAssociation == Association::WholeDataSet;
}
VTKM_CONT bool IsPartitionsField() const
{
return this->FieldAssociation == Association::Partitions;
}
VTKM_CONT bool IsGlobalField() const { return this->FieldAssociation == Association::Global; }
VTKM_DEPRECATED(1.9, "Use IsCellField.")
VTKM_CONT bool IsFieldCell() const { return this->IsCellField(); }
VTKM_DEPRECATED(1.9, "Use IsPointField.")
VTKM_CONT bool IsFieldPoint() const { return this->IsPointField(); }
VTKM_DEPRECATED(1.9, "Use IsWholeDataSetField. Note that meaning of `Global` has changed!")
VTKM_CONT bool IsFieldGlobal() const
{
return this->FieldAssociation == Association::WholeDataSet;
}
/// Returns true if the array of the field has a value type that matches something in
/// `VTKM_FIELD_TYPE_LIST` and a storage that matches something in `VTKM_FIELD_STORAGE_LIST`.

36
vtkm/cont/PartitionedDataSet.cxx
View File

@ -13,7 +13,6 @@
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/EnvironmentTracker.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Field.h>
#include <vtkm/cont/PartitionedDataSet.h>
#include <vtkm/internal/Configure.h>
@ -34,12 +33,6 @@ PartitionedDataSet::PartitionedDataSet(const vtkm::cont::DataSet& ds)
this->Partitions.insert(this->Partitions.end(), ds);
}
VTKM_CONT
PartitionedDataSet::PartitionedDataSet(const vtkm::cont::PartitionedDataSet& src)
{
this->Partitions = src.GetPartitions();
}
VTKM_CONT
PartitionedDataSet::PartitionedDataSet(const std::vector<vtkm::cont::DataSet>& partitions)
{
@ -53,21 +46,8 @@ PartitionedDataSet::PartitionedDataSet(vtkm::Id size)
}
VTKM_CONT
PartitionedDataSet::PartitionedDataSet() {}
VTKM_CONT
PartitionedDataSet::~PartitionedDataSet() {}
VTKM_CONT
PartitionedDataSet& PartitionedDataSet::operator=(const vtkm::cont::PartitionedDataSet& src)
{
this->Partitions = src.GetPartitions();
return *this;
}
VTKM_CONT
vtkm::cont::Field PartitionedDataSet::GetField(const std::string& field_name,
int partition_index) const
vtkm::cont::Field PartitionedDataSet::GetFieldFromPartition(const std::string& field_name,
int partition_index) const
{
assert(partition_index >= 0);
assert(static_cast<std::size_t>(partition_index) < this->Partitions.size());
@ -143,6 +123,12 @@ void PartitionedDataSet::ReplacePartition(vtkm::Id index, const vtkm::cont::Data
}
}
VTKM_CONT
void PartitionedDataSet::CopyPartitions(const vtkm::cont::PartitionedDataSet& source)
{
this->Partitions = source.Partitions;
}
VTKM_CONT
void PartitionedDataSet::PrintSummary(std::ostream& stream) const
{
@ -153,6 +139,12 @@ void PartitionedDataSet::PrintSummary(std::ostream& stream) const
stream << "Partition " << part << ":\n";
this->Partitions[part].PrintSummary(stream);
}
stream << " Fields[" << this->GetNumberOfFields() << "]\n";
for (vtkm::Id index = 0; index < this->GetNumberOfFields(); index++)
{
this->GetField(index).PrintSummary(stream);
}
}
}
} // namespace vtkm::cont

142
vtkm/cont/PartitionedDataSet.h
View File

@ -15,6 +15,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/Field.h>
#include <vtkm/cont/internal/FieldCollection.h>
namespace vtkm
{
@ -35,9 +36,7 @@ public:
/// Create a new PartitionedDataSet containng a single DataSet @a ds.
VTKM_CONT
PartitionedDataSet(const vtkm::cont::DataSet& ds);
/// Create a new PartitionedDataSet with the existing one @a src.
VTKM_CONT
PartitionedDataSet(const vtkm::cont::PartitionedDataSet& src);
/// Create a new PartitionedDataSet with a DataSet vector @a partitions.
VTKM_CONT
explicit PartitionedDataSet(const std::vector<vtkm::cont::DataSet>& partitions);
@ -46,16 +45,17 @@ public:
explicit PartitionedDataSet(vtkm::Id size);
VTKM_CONT
PartitionedDataSet();
PartitionedDataSet() = default;
VTKM_CONT
PartitionedDataSet& operator=(const vtkm::cont::PartitionedDataSet& src);
VTKM_DEPRECATED(1.9, "Renamed to GetFieldFromPartition.")
VTKM_CONT vtkm::cont::Field GetField(const std::string& field_name, int partition_index) const
{
return this->GetFieldFromPartition(field_name, partition_index);
}
VTKM_CONT
~PartitionedDataSet();
/// Get the field @a field_name from partition @a partition_index.
VTKM_CONT
vtkm::cont::Field GetField(const std::string& field_name, int partition_index) const;
vtkm::cont::Field GetFieldFromPartition(const std::string& field_name, int partition_index) const;
/// Get number of DataSet objects stored in this PartitionedDataSet.
VTKM_CONT
@ -91,6 +91,126 @@ public:
VTKM_CONT
void AppendPartitions(const std::vector<vtkm::cont::DataSet>& partitions);
//@{
/// Methods to Add and Get fields on a PartitionedDataSet
VTKM_CONT
vtkm::IdComponent GetNumberOfFields() const { return this->Fields.GetNumberOfFields(); }
//Fields on partitions.
VTKM_CONT void AddField(const Field& field) { this->Fields.AddField(field); }
template <typename T, typename Storage>
VTKM_CONT void AddGlobalField(const std::string& fieldName,
const vtkm::cont::ArrayHandle<T, Storage>& field)
{
this->AddField(vtkm::cont::Field(fieldName, vtkm::cont::Field::Association::Global, field));
}
template <typename T>
VTKM_CONT void AddGlobalField(const std::string& fieldName, const std::vector<T>& field)
{
this->AddField(
make_Field(fieldName, vtkm::cont::Field::Association::Global, field, vtkm::CopyFlag::On));
}
template <typename T>
VTKM_CONT void AddGlobalField(const std::string& fieldName, const T* field, const vtkm::Id& n)
{
this->AddField(
make_Field(fieldName, vtkm::cont::Field::Association::Global, field, n, vtkm::CopyFlag::On));
}
template <typename T, typename Storage>
VTKM_CONT void AddPartitionsField(const std::string& fieldName,
const vtkm::cont::ArrayHandle<T, Storage>& field)
{
this->AddField(vtkm::cont::Field(fieldName, vtkm::cont::Field::Association::Partitions, field));
}
template <typename T>
VTKM_CONT void AddPartitionsField(const std::string& fieldName, const std::vector<T>& field)
{
this->AddField(
make_Field(fieldName, vtkm::cont::Field::Association::Partitions, field, vtkm::CopyFlag::On));
}
template <typename T>
VTKM_CONT void AddPartitionsField(const std::string& fieldName, const T* field, const vtkm::Id& n)
{
this->AddField(make_Field(
fieldName, vtkm::cont::Field::Association::Partitions, field, n, vtkm::CopyFlag::On));
}
VTKM_CONT
const vtkm::cont::Field& GetField(vtkm::Id index) const { return this->Fields.GetField(index); }
VTKM_CONT
vtkm::cont::Field& GetField(vtkm::Id index) { return this->Fields.GetField(index); }
VTKM_CONT
const vtkm::cont::Field& GetField(
const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const
{
return this->Fields.GetField(name, assoc);
}
VTKM_CONT
vtkm::cont::Field& GetField(
const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any)
{
return this->Fields.GetField(name, assoc);
}
VTKM_CONT
const vtkm::cont::Field& GetGlobalField(const std::string& name) const
{
return this->GetField(name, vtkm::cont::Field::Association::Global);
}
VTKM_CONT
const vtkm::cont::Field& GetPartitionsField(const std::string& name) const
{
return this->GetField(name, vtkm::cont::Field::Association::Partitions);
}
VTKM_CONT
vtkm::cont::Field& GetGlobalField(const std::string& name)
{
return this->GetField(name, vtkm::cont::Field::Association::Global);
}
VTKM_CONT
vtkm::cont::Field& GetPartitionsField(const std::string& name)
{
return this->GetField(name, vtkm::cont::Field::Association::Partitions);
}
VTKM_CONT
bool HasField(const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const
{
return this->Fields.HasField(name, assoc);
}
VTKM_CONT
bool HasGlobalField(const std::string& name) const
{
return (this->Fields.GetFieldIndex(name, vtkm::cont::Field::Association::Global) != -1);
}
VTKM_CONT
bool HasPartitionsField(const std::string& name) const
{
return (this->Fields.GetFieldIndex(name, vtkm::cont::Field::Association::Partitions) != -1);
}
//@}
/// Copies the partitions from the source. The fields on the PartitionedDataSet are not copied.
VTKM_CONT
void CopyPartitions(const vtkm::cont::PartitionedDataSet& source);
VTKM_CONT
void PrintSummary(std::ostream& stream) const;
@ -109,8 +229,12 @@ public:
VTKM_CONT
const_iterator cend() const noexcept { return this->Partitions.cend(); }
//@}
private:
std::vector<vtkm::cont::DataSet> Partitions;
vtkm::cont::internal::FieldCollection Fields{ vtkm::cont::Field::Association::Partitions,
vtkm::cont::Field::Association::Global };
};
}
} // namespace vtkm::cont

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

@ -25,6 +25,7 @@ set(headers
DeviceAdapterMemoryManager.h
DeviceAdapterMemoryManagerShared.h
DeviceAdapterListHelpers.h
FieldCollection.h
FunctorsGeneral.h
IteratorFromArrayPortal.h
KXSort.h

86
vtkm/cont/internal/FieldCollection.cxx Normal file
View File

@ -0,0 +1,86 @@
//============================================================================
// 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.
//============================================================================
#include <vtkm/cont/internal/FieldCollection.h>
namespace vtkm
{
namespace cont
{
namespace internal
{
VTKM_CONT void FieldCollection::AddField(const Field& field)
{
if (this->ValidAssoc.find(field.GetAssociation()) == this->ValidAssoc.end())
{
throw vtkm::cont::ErrorBadValue("Invalid association for field: " + field.GetName());
}
this->Fields[{ field.GetName(), field.GetAssociation() }] = field;
}
const vtkm::cont::Field& FieldCollection::GetField(vtkm::Id index) const
{
VTKM_ASSERT((index >= 0) && (index < this->GetNumberOfFields()));
auto it = this->Fields.cbegin();
std::advance(it, index);
return it->second;
}
vtkm::cont::Field& FieldCollection::GetField(vtkm::Id index)
{
VTKM_ASSERT((index >= 0) && (index < this->GetNumberOfFields()));
auto it = this->Fields.begin();
std::advance(it, index);
return it->second;
}
vtkm::Id FieldCollection::GetFieldIndex(const std::string& name,
vtkm::cont::Field::Association assoc) const
{
// Find the field with the given name and association. If the association is
// `vtkm::cont::Field::Association::Any`, then the `Fields` object has a
// special comparator that will match the field to any association.
const auto it = this->Fields.find({ name, assoc });
if (it != this->Fields.end())
{
return static_cast<vtkm::Id>(std::distance(this->Fields.begin(), it));
}
return -1;
}
const vtkm::cont::Field& FieldCollection::GetField(const std::string& name,
vtkm::cont::Field::Association assoc) const
{
auto idx = this->GetFieldIndex(name, assoc);
if (idx == -1)
{
throw vtkm::cont::ErrorBadValue("No field with requested name: " + name);
}
return this->GetField(idx);
}
vtkm::cont::Field& FieldCollection::GetField(const std::string& name,
vtkm::cont::Field::Association assoc)
{
auto idx = this->GetFieldIndex(name, assoc);
if (idx == -1)
{
throw vtkm::cont::ErrorBadValue("No field with requested name: " + name);
}
return this->GetField(idx);
}
}
}
} //vtkm::cont::internal

103
vtkm/cont/internal/FieldCollection.h Normal file
View File

@ -0,0 +1,103 @@
//============================================================================
// 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_internal_FieldCollection_h
#define vtk_m_cont_internal_FieldCollection_h
#include <set>
#include <vtkm/cont/Field.h>
namespace vtkm
{
namespace cont
{
namespace internal
{
class VTKM_CONT_EXPORT FieldCollection
{
public:
VTKM_CONT
FieldCollection(std::initializer_list<vtkm::cont::Field::Association> validAssoc)
{
auto it = this->ValidAssoc.begin();
for (const auto& item : validAssoc)
it = this->ValidAssoc.insert(it, item);
}
VTKM_CONT
FieldCollection(std::set<vtkm::cont::Field::Association>&& validAssoc)
: ValidAssoc(std::move(validAssoc))
{
}
VTKM_CONT
void Clear() { this->Fields.clear(); }
VTKM_CONT
vtkm::IdComponent GetNumberOfFields() const
{
return static_cast<vtkm::IdComponent>(this->Fields.size());
}
VTKM_CONT void AddField(const Field& field);
VTKM_CONT
const vtkm::cont::Field& GetField(vtkm::Id index) const;
VTKM_CONT
vtkm::cont::Field& GetField(vtkm::Id index);
VTKM_CONT
bool HasField(const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const
{
return (this->GetFieldIndex(name, assoc) != -1);
}
VTKM_CONT
vtkm::Id GetFieldIndex(
const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const;
VTKM_CONT
const vtkm::cont::Field& GetField(
const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any) const;
VTKM_CONT
vtkm::cont::Field& GetField(
const std::string& name,
vtkm::cont::Field::Association assoc = vtkm::cont::Field::Association::Any);
private:
struct FieldCompare
{
using Key = std::pair<std::string, vtkm::cont::Field::Association>;
template <typename T>
bool operator()(const T& a, const T& b) const
{
if (a.first == b.first)
return a.second < b.second && a.second != vtkm::cont::Field::Association::Any &&
b.second != vtkm::cont::Field::Association::Any;
return a.first < b.first;
}
};
std::map<FieldCompare::Key, vtkm::cont::Field, FieldCompare> Fields;
std::set<vtkm::cont::Field::Association> ValidAssoc;
};
}
}
} // namespace vtkm::cont::internal
#endif //vtk_m_cont_internal_FieldCollection_h

111
vtkm/cont/testing/UnitTestPartitionedDataSet.cxx
View File

@ -38,7 +38,17 @@ static void PartitionedDataSetTest()
pds.AppendPartition(TDset1);
pds.AppendPartition(TDset2);
std::vector<vtkm::Id> ids = { 0, 1 };
std::vector<vtkm::FloatDefault> var = { 1, 2 };
auto idsField = vtkm::cont::make_Field(
"ids", vtkm::cont::Field::Association::Partitions, ids, vtkm::CopyFlag::On);
auto pdsVar = vtkm::cont::make_Field(
"pds_var", vtkm::cont::Field::Association::Partitions, ids, vtkm::CopyFlag::On);
pds.AddField(idsField);
pds.AddField(pdsVar);
VTKM_TEST_ASSERT(pds.GetNumberOfPartitions() == 2, "Incorrect number of partitions");
VTKM_TEST_ASSERT(pds.GetNumberOfFields() == 2, "Incorrect number of fields");
vtkm::cont::DataSet TestDSet = pds.GetPartition(0);
VTKM_TEST_ASSERT(TDset1.GetNumberOfFields() == TestDSet.GetNumberOfFields(),
@ -88,11 +98,20 @@ static void PartitionedDataSetTest()
"Local field value range info incorrect");
vtkm::Range SourceRange; //test the validity of member function GetField(FieldName, BlockId)
pds.GetField("cellvar", 0).GetRange(&SourceRange);
pds.GetFieldFromPartition("cellvar", 0).GetRange(&SourceRange);
vtkm::Range TestRange;
pds.GetPartition(0).GetField("cellvar").GetRange(&TestRange);
VTKM_TEST_ASSERT(TestRange == SourceRange, "Local field value info incorrect");
//test partition fields.
idsField.GetRange(&SourceRange);
pds.GetField("ids").GetRange(&TestRange);
VTKM_TEST_ASSERT(TestRange == SourceRange, "Partitions field values incorrect");
pdsVar.GetRange(&SourceRange);
pds.GetField("pds_var").GetRange(&TestRange);
VTKM_TEST_ASSERT(TestRange == SourceRange, "Global field values incorrect");
vtkm::cont::PartitionedDataSet testblocks1;
std::vector<vtkm::cont::DataSet> partitions = pds.GetPartitions();
testblocks1.AppendPartitions(partitions);
@ -119,6 +138,88 @@ static void PartitionedDataSetTest()
DataSet_Compare(TDset1, TestDSet);
}
static void PartitionedDataSetFieldTest()
{
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet TDset1 = testDataSet.Make2DUniformDataSet0();
vtkm::cont::DataSet TDset2 = testDataSet.Make3DUniformDataSet0();
constexpr vtkm::Id id0 = 0, id1 = 1;
constexpr vtkm::FloatDefault globalScalar = 1.0f;
for (int i = 0; i < 4; i++)
{
vtkm::cont::PartitionedDataSet pds({ TDset1, TDset2 });
std::vector<vtkm::Id> ids = { id0, id1 };
std::vector<vtkm::FloatDefault> gs = { globalScalar };
auto idsArr = vtkm::cont::make_ArrayHandle(ids, vtkm::CopyFlag::Off);
auto gsArr = vtkm::cont::make_ArrayHandle(gs, vtkm::CopyFlag::Off);
if (i == 0) //field
{
auto idField = vtkm::cont::make_Field(
"id", vtkm::cont::Field::Association::Partitions, ids, vtkm::CopyFlag::Off);
auto gScalar = vtkm::cont::make_Field(
"global_scalar", vtkm::cont::Field::Association::Global, gs, vtkm::CopyFlag::Off);
pds.AddField(idField);
pds.AddField(gScalar);
}
else if (i == 1) //array handle
{
pds.AddPartitionsField("id", idsArr);
pds.AddGlobalField("global_scalar", gsArr);
}
else if (i == 2) //std::vector
{
pds.AddPartitionsField("id", ids);
pds.AddGlobalField("global_scalar", gs);
}
else if (i == 3) //pointer
{
pds.AddPartitionsField("id", ids.data(), 2);
pds.AddGlobalField("global_scalar", gs.data(), 1);
}
//Validate each method.
VTKM_TEST_ASSERT(pds.GetNumberOfFields() == 2, "Wrong number of fields");
//Make sure fields are there and of the right type.
VTKM_TEST_ASSERT(pds.HasPartitionsField("id"), "id field misssing.");
VTKM_TEST_ASSERT(pds.HasGlobalField("global_scalar"), "global_scalar field misssing.");
for (int j = 0; j < 2; j++)
{
vtkm::cont::Field f0, f1;
if (j == 0)
{
f0 = pds.GetField("id");
f1 = pds.GetField("global_scalar");
}
else
{
f0 = pds.GetPartitionsField("id");
f1 = pds.GetGlobalField("global_scalar");
}
//Check the values.
auto portal0 = f0.GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>().ReadPortal();
auto portal1 =
f1.GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::FloatDefault>>().ReadPortal();
VTKM_TEST_ASSERT(portal0.GetNumberOfValues() == 2, "Wrong number of values in field");
VTKM_TEST_ASSERT(portal1.GetNumberOfValues() == 1, "Wrong number of values in field");
VTKM_TEST_ASSERT(portal0.Get(0) == id0 && portal0.Get(1) == id1, "Wrong field value");
VTKM_TEST_ASSERT(portal1.Get(0) == globalScalar, "Wrong field value");
}
}
}
void DataSet_Compare(vtkm::cont::DataSet& leftDataSet, vtkm::cont::DataSet& rightDataSet)
{
for (vtkm::Id j = 0; j < leftDataSet.GetNumberOfFields(); j++)
@ -132,7 +233,13 @@ void DataSet_Compare(vtkm::cont::DataSet& leftDataSet, vtkm::cont::DataSet& righ
return;
}
static void PartitionedDataSetTests()
{
PartitionedDataSetTest();
PartitionedDataSetFieldTest();
}
int UnitTestPartitionedDataSet(int argc, char* argv[])
{
return vtkm::cont::testing::Testing::Run(PartitionedDataSetTest, argc, argv);
return vtkm::cont::testing::Testing::Run(PartitionedDataSetTests, argc, argv);
}

2
vtkm/filter/FilterDataSet.h
View File

@ -44,7 +44,7 @@ public:
//From the field we can extract the association component
// Association::Any -> unable to map
// Association::WholeMesh -> (I think this is points)
// Association::WholeDataSet -> (I think this is points)
// Association::Points -> map using point mapping
// Association::Cells -> how do we map this?
template <typename DerivedPolicy>

2
vtkm/filter/FilterDataSetWithField.h
View File

@ -70,7 +70,7 @@ public:
//From the field we can extract the association component
// Association::Any -> unable to map
// Association::WholeMesh -> (I think this is points)
// Association::WholeDataSet -> (I think this is points)
// Association::Points -> map using point mapping
// Association::Cells -> how do we map this?
template <typename DerivedPolicy>

2
vtkm/filter/Lagrangian.hxx
View File

@ -333,7 +333,7 @@ inline VTKM_CONT bool Lagrangian::MapFieldOntoOutput(vtkm::cont::DataSet& result
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy>)
{
if (field.IsFieldGlobal())
if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

2
vtkm/filter/LagrangianStructures.hxx
View File

@ -176,7 +176,7 @@ inline VTKM_CONT bool LagrangianStructures::MapFieldOntoOutput(
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy>)
{
if (field.IsFieldGlobal())
if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

15
vtkm/filter/NewFilter.cxx
View File

@ -88,7 +88,7 @@ vtkm::cont::PartitionedDataSet NewFilter::DoExecutePartitions(
}
}
return output;
return this->CreateResult(input, output);
}
vtkm::cont::DataSet NewFilter::Execute(const vtkm::cont::DataSet& input)
@ -103,8 +103,7 @@ vtkm::cont::PartitionedDataSet NewFilter::Execute(const vtkm::cont::PartitionedD
(int)input.GetNumberOfPartitions(),
vtkm::cont::TypeToString<decltype(*this)>().c_str());
vtkm::cont::PartitionedDataSet output = this->DoExecutePartitions(input);
return output;
return this->DoExecutePartitions(input);
}
vtkm::cont::DataSet NewFilter::CreateResult(const vtkm::cont::DataSet& inDataSet) const
@ -118,6 +117,16 @@ vtkm::cont::DataSet NewFilter::CreateResult(const vtkm::cont::DataSet& inDataSet
return clone;
}
vtkm::cont::PartitionedDataSet NewFilter::CreateResult(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::cont::PartitionedDataSet& resultPartitions) const
{
auto fieldMapper = [](vtkm::cont::PartitionedDataSet& out, const vtkm::cont::Field& fieldToPass) {
out.AddField(fieldToPass);
};
return this->CreateResult(input, resultPartitions, fieldMapper);
}
vtkm::Id NewFilter::DetermineNumberOfThreads(const vtkm::cont::PartitionedDataSet& input)
{
vtkm::Id numDS = input.GetNumberOfPartitions();

48
vtkm/filter/NewFilter.h
View File

@ -327,6 +327,48 @@ protected:
///
VTKM_CONT vtkm::cont::DataSet CreateResult(const vtkm::cont::DataSet& inDataSet) const;
/// \brief Create the output data set for `DoExecute`.
///
/// This form of `CreateResult` will create an output PartitionedDataSet with the
/// same partitions and pass all PartitionedDataSet fields (as requested by the
/// `Filter` state).
///
/// \param[in] input The input data set being modified (usually the one passed into
/// `DoExecute`).
/// \param[in] resultPartitions The output data created by the filter. Fields from the input are
/// passed onto the return result partition as requested by the `Filter` state.
///
VTKM_CONT vtkm::cont::PartitionedDataSet CreateResult(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::cont::PartitionedDataSet& resultPartitions) const;
/// \brief Create the output data set for `DoExecute`.
///
/// This form of `CreateResult` will create an output PartitionedDataSet with the
/// same partitions and pass all PartitionedDataSet fields (as requested by the
/// `Filter` state).
///
/// \param[in] input The input data set being modified (usually the one passed into
/// `DoExecute`).
/// \param[in] resultPartitions The output data created by the filter. Fields from the input are
/// passed onto the return result partition as requested by the `Filter` state.
/// \param[in] fieldMapper A function or functor that takes a `PartitionedDataSet` as its first
/// argument and a `Field` as its second argument. The `PartitionedDataSet` is the data being
/// created and will eventually be returned by `CreateResult`. The `Field` comes from `input`.
///
template <typename FieldMapper>
VTKM_CONT vtkm::cont::PartitionedDataSet CreateResult(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::cont::PartitionedDataSet& resultPartitions,
FieldMapper&& fieldMapper) const
{
vtkm::cont::PartitionedDataSet output(resultPartitions.GetPartitions());
this->MapFieldsOntoOutput(input, output, fieldMapper);
return output;
}
/// \brief Create the output data set for `DoExecute`.
///
/// This form of `CreateResult` will create an output data set with the given `CellSet`. You must
@ -431,9 +473,9 @@ protected:
const vtkm::cont::PartitionedDataSet& inData);
private:
template <typename FieldMapper>
VTKM_CONT void MapFieldsOntoOutput(const vtkm::cont::DataSet& input,
vtkm::cont::DataSet& output,
template <typename DataSetType, typename FieldMapper>
VTKM_CONT void MapFieldsOntoOutput(const DataSetType& input,
DataSetType& output,
FieldMapper&& fieldMapper) const
{
for (vtkm::IdComponent cc = 0; cc < input.GetNumberOfFields(); ++cc)

4
vtkm/filter/clean_grid/CleanGrid.cxx
View File

@ -45,7 +45,7 @@ bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::filter::clean_grid::CleanGrid& self,
vtkm::filter::clean_grid::SharedStates& worklets)
{
if (field.IsFieldPoint() && (self.GetCompactPointFields() || self.GetMergePoints()))
if (field.IsPointField() && (self.GetCompactPointFields() || self.GetMergePoints()))
{
vtkm::cont::Field compactedField;
if (self.GetCompactPointFields())
@ -72,7 +72,7 @@ bool DoMapField(vtkm::cont::DataSet& result,
return true;
}
}
else if (field.IsFieldCell() && self.GetRemoveDegenerateCells())
else if (field.IsCellField() && self.GetRemoveDegenerateCells())
{
return vtkm::filter::MapFieldPermutation(
field, worklets.CellCompactor.GetValidCellIds(), result);

2
vtkm/filter/connected_components/ImageConnectivity.cxx
View File

@ -21,7 +21,7 @@ VTKM_CONT vtkm::cont::DataSet ImageConnectivity::DoExecute(const vtkm::cont::Dat
{
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorBadValue("Active field for ImageConnectivity must be a point field.");
}

8
vtkm/filter/contour/ClipWithField.cxx
View File

@ -41,7 +41,7 @@ bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
vtkm::worklet::Clip& worklet)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
auto resolve = [&](const auto& concrete) {
// use std::decay to remove const ref from the decltype of concrete.
@ -56,13 +56,13 @@ bool DoMapField(vtkm::cont::DataSet& result,
resolve);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
// Use the precompiled field permutation function.
vtkm::cont::ArrayHandle<vtkm::Id> permutation = worklet.GetCellMapOutputToInput();
return vtkm::filter::MapFieldPermutation(field, permutation, result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;
@ -78,7 +78,7 @@ bool DoMapField(vtkm::cont::DataSet& result,
vtkm::cont::DataSet ClipWithField::DoExecute(const vtkm::cont::DataSet& input)
{
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("Point field expected.");
}

6
vtkm/filter/contour/ClipWithImplicitFunction.cxx
View File

@ -41,7 +41,7 @@ bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
const vtkm::worklet::Clip& Worklet)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
auto resolve = [&](const auto& concrete) {
// use std::decay to remove const ref from the decltype of concrete.
@ -56,13 +56,13 @@ bool DoMapField(vtkm::cont::DataSet& result,
resolve);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
// Use the precompiled field permutation function.
vtkm::cont::ArrayHandle<vtkm::Id> permutation = Worklet.GetCellMapOutputToInput();
return vtkm::filter::MapFieldPermutation(field, permutation, result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

8
vtkm/filter/contour/Contour.cxx
View File

@ -43,7 +43,7 @@ VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
vtkm::worklet::Contour& worklet)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
auto functor = [&](const auto& concrete) {
auto fieldArray = worklet.ProcessPointField(concrete);
@ -54,13 +54,13 @@ VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
functor);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
// Use the precompiled field permutation function.
vtkm::cont::ArrayHandle<vtkm::Id> permutation = worklet.GetCellIdMap();
return vtkm::filter::MapFieldPermutation(field, permutation, result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;
@ -93,7 +93,7 @@ vtkm::cont::DataSet Contour::DoExecute(const vtkm::cont::DataSet& inDataSet)
vtkm::worklet::Contour worklet;
worklet.SetMergeDuplicatePoints(this->GetMergeDuplicatePoints());
if (!this->GetFieldFromDataSet(inDataSet).IsFieldPoint())
if (!this->GetFieldFromDataSet(inDataSet).IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("Point field expected.");
}

6
vtkm/filter/contour/MIRFilter.cxx
View File

@ -53,7 +53,7 @@ VTKM_CONT bool MIRFilter::DoMapField(
return false;
}
if (field.IsFieldPoint())
if (field.IsPointField())
{
auto resolve = [&](const auto& concrete) {
using T = typename std::decay_t<decltype(concrete)>::ValueType;
@ -67,7 +67,7 @@ VTKM_CONT bool MIRFilter::DoMapField(
resolve);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
return vtkm::filter::MapFieldPermutation(field, filterCellInterp, result);
}
@ -117,7 +117,7 @@ VTKM_CONT vtkm::cont::DataSet MIRFilter::DoExecute(const vtkm::cont::DataSet& in
vtkm::cont::Field or_len = input.GetField(this->len_name);
vtkm::cont::Field or_ids = input.GetField(this->id_name);
vtkm::cont::Field or_vfs = input.GetField(this->vf_name);
// TODO: Check all fields for 'IsFieldCell'
// TODO: Check all fields for 'IsCellField'
vtkm::cont::ArrayHandle<vtkm::FloatDefault> vfsdata_or, vfsdata;
vtkm::cont::ArrayHandle<vtkm::Id> idsdata_or, idsdata, lendata_or, lendata, posdata_or, posdata,
allids;

8
vtkm/filter/contour/testing/UnitTestMIRFilter.cxx
View File

@ -93,8 +93,8 @@ vtkm::cont::DataSet GetTestDataSet()
vtkm::cont::DataSet ds = dsb.Create(points, shapes, numberofInd, connections);
ds.AddField(vtkm::cont::Field("scatter_pos", vtkm::cont::Field::Association::Cells, offsets));
ds.AddField(vtkm::cont::Field("scatter_len", vtkm::cont::Field::Association::Cells, lengths));
ds.AddField(vtkm::cont::Field("scatter_ids", vtkm::cont::Field::Association::WholeMesh, ids));
ds.AddField(vtkm::cont::Field("scatter_vfs", vtkm::cont::Field::Association::WholeMesh, vfs));
ds.AddField(vtkm::cont::Field("scatter_ids", vtkm::cont::Field::Association::WholeDataSet, ids));
ds.AddField(vtkm::cont::Field("scatter_vfs", vtkm::cont::Field::Association::WholeDataSet, vfs));
return ds;
}
@ -201,9 +201,9 @@ void TestMIRVenn250()
data.AddField(vtkm::cont::Field("scatter_pos", vtkm::cont::Field::Association::Cells, offset));
data.AddField(vtkm::cont::Field("scatter_len", vtkm::cont::Field::Association::Cells, length));
data.AddField(
vtkm::cont::Field("scatter_ids", vtkm::cont::Field::Association::WholeMesh, matIds));
vtkm::cont::Field("scatter_ids", vtkm::cont::Field::Association::WholeDataSet, matIds));
data.AddField(
vtkm::cont::Field("scatter_vfs", vtkm::cont::Field::Association::WholeMesh, matVFs));
vtkm::cont::Field("scatter_vfs", vtkm::cont::Field::Association::WholeDataSet, matVFs));
vtkm::filter::contour::MIRFilter mir;
mir.SetIDWholeSetName("scatter_ids");

2
vtkm/filter/density_estimate/Entropy.cxx
View File

@ -42,7 +42,7 @@ VTKM_CONT vtkm::cont::DataSet Entropy::DoExecute(const vtkm::cont::DataSet& inDa
vtkm::cont::DataSet output;
output.AddField(
{ this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, entropy });
{ this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, entropy });
// The output is a "summary" of the input, no need to map fields
return output;

4
vtkm/filter/density_estimate/Histogram.cxx
View File

@ -215,7 +215,7 @@ VTKM_CONT vtkm::cont::DataSet Histogram::DoExecute(const vtkm::cont::DataSet& in
vtkm::cont::DataSet output;
output.AddField(
{ this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, binArray });
{ this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, binArray });
// The output is a "summary" of the input, no need to map fields
return output;
@ -265,7 +265,7 @@ VTKM_CONT void Histogram::PostExecute(const vtkm::cont::PartitionedDataSet&,
vtkm::cont::DataSet output;
vtkm::cont::Field rfield(
this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, helper.ReduceAll());
this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, helper.ReduceAll());
output.AddField(rfield);
result = vtkm::cont::PartitionedDataSet(output);

2
vtkm/filter/density_estimate/NDEntropy.cxx
View File

@ -42,7 +42,7 @@ VTKM_CONT vtkm::cont::DataSet NDEntropy::DoExecute(const vtkm::cont::DataSet& in
entropyHandle.WritePortal().Set(0, entropy);
vtkm::cont::DataSet outputData;
outputData.AddField({ "Entropy", vtkm::cont::Field::Association::WholeMesh, entropyHandle });
outputData.AddField({ "Entropy", vtkm::cont::Field::Association::WholeDataSet, entropyHandle });
// The output is a "summary" of the input, no need to map fields
return outputData;
}

4
vtkm/filter/density_estimate/NDHistogram.cxx
View File

@ -61,9 +61,9 @@ VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(const vtkm::cont::DataSet&
for (size_t i = 0; i < binIds.size(); i++)
{
outputData.AddField(
{ this->FieldNames[i], vtkm::cont::Field::Association::WholeMesh, binIds[i] });
{ this->FieldNames[i], vtkm::cont::Field::Association::WholeDataSet, binIds[i] });
}
outputData.AddField({ "Frequency", vtkm::cont::Field::Association::WholeMesh, freqs });
outputData.AddField({ "Frequency", vtkm::cont::Field::Association::WholeDataSet, freqs });
// The output is a "summary" of the input, no need to map fields
return outputData;
}

8
vtkm/filter/entity_extraction/ExternalFaces.cxx
View File

@ -47,7 +47,7 @@ vtkm::cont::DataSet ExternalFaces::GenerateOutput(const vtkm::cont::DataSet& inp
for (vtkm::Id fieldIdx = 0; fieldIdx < numFields && !hasCellFields; ++fieldIdx)
{
const auto& f = input.GetField(fieldIdx);
hasCellFields = f.IsFieldCell();
hasCellFields = f.IsCellField();
}
if (!hasCellFields)
@ -104,16 +104,16 @@ vtkm::cont::DataSet ExternalFaces::DoExecute(const vtkm::cont::DataSet& input)
bool ExternalFaces::MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
result.AddField(field);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
return vtkm::filter::MapFieldPermutation(field, this->Worklet->GetCellIdMap(), result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

6
vtkm/filter/entity_extraction/ExtractGeometry.cxx
View File

@ -20,17 +20,17 @@ bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
const vtkm::worklet::ExtractGeometry& worklet)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
result.AddField(field);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
vtkm::cont::ArrayHandle<vtkm::Id> permutation = worklet.GetValidCellIds();
return vtkm::filter::MapFieldPermutation(field, permutation, result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

4
vtkm/filter/entity_extraction/ExtractPoints.cxx
View File

@ -17,12 +17,12 @@ namespace
bool DoMapField(vtkm::cont::DataSet& result, const vtkm::cont::Field& field)
{
// point data is copied as is because it was not collapsed
if (field.IsFieldPoint())
if (field.IsPointField())
{
result.AddField(field);
return true;
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

6
vtkm/filter/entity_extraction/ExtractStructured.cxx
View File

@ -20,15 +20,15 @@ VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<vtkm::Id>& CellFieldMap,
const vtkm::cont::ArrayHandle<vtkm::Id>& PointFieldMap)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
return vtkm::filter::MapFieldPermutation(field, PointFieldMap, result);
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
return vtkm::filter::MapFieldPermutation(field, CellFieldMap, result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

6
vtkm/filter/entity_extraction/GhostCellRemove.cxx
View File

@ -277,17 +277,17 @@ bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
const vtkm::worklet::Threshold& worklet)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
//we copy the input handle to the result dataset, reusing the metadata
result.AddField(field);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
return vtkm::filter::MapFieldPermutation(field, worklet.GetValidCellIds(), result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

4
vtkm/filter/entity_extraction/Mask.cxx
View File

@ -17,12 +17,12 @@ VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
const vtkm::worklet::Mask& worklet)
{
if (field.IsFieldPoint() || field.IsFieldGlobal())
if (field.IsPointField() || field.IsWholeDataSetField())
{
result.AddField(field); // pass through
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
return vtkm::filter::MapFieldPermutation(field, worklet.GetValidCellIds(), result);
}

4
vtkm/filter/entity_extraction/MaskPoints.cxx
View File

@ -17,12 +17,12 @@ namespace
bool DoMapField(vtkm::cont::DataSet& result, const vtkm::cont::Field& field)
{
// point data is copied as is because it was not collapsed
if (field.IsFieldPoint())
if (field.IsPointField())
{
result.AddField(field);
return true;
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

4
vtkm/filter/entity_extraction/Threshold.cxx
View File

@ -48,13 +48,13 @@ bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
const vtkm::worklet::Threshold& worklet)
{
if (field.IsFieldPoint() || field.IsFieldGlobal())
if (field.IsPointField() || field.IsWholeDataSetField())
{
//we copy the input handle to the result dataset, reusing the metadata
result.AddField(field);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
return vtkm::filter::MapFieldPermutation(field, worklet.GetValidCellIds(), result);
}

6
vtkm/filter/entity_extraction/ThresholdPoints.cxx
View File

@ -81,12 +81,12 @@ private:
bool DoMapField(vtkm::cont::DataSet& result, const vtkm::cont::Field& field)
{
// point data is copied as is because it was not collapsed
if (field.IsFieldPoint())
if (field.IsPointField())
{
result.AddField(field);
return true;
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;
@ -138,7 +138,7 @@ VTKM_CONT vtkm::cont::DataSet ThresholdPoints::DoExecute(const vtkm::cont::DataS
const auto& field = this->GetFieldFromDataSet(input);
// field to threshold on must be a point field
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("Point field expected.");
}

2
vtkm/filter/field_conversion/CellAverage.cxx
View File

@ -22,7 +22,7 @@ namespace field_conversion
vtkm::cont::DataSet CellAverage::DoExecute(const vtkm::cont::DataSet& input)
{
const auto& field = GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("Point field expected.");
}

2
vtkm/filter/field_conversion/PointAverage.cxx
View File

@ -23,7 +23,7 @@ namespace field_conversion
vtkm::cont::DataSet PointAverage::DoExecute(const vtkm::cont::DataSet& input)
{
const auto& field = GetFieldFromDataSet(input);
if (!field.IsFieldCell())
if (!field.IsCellField())
{
throw vtkm::cont::ErrorFilterExecution("Cell field expected.");
}

2
vtkm/filter/flow/worklet/Field.h
View File

@ -152,7 +152,7 @@ public:
: FieldValues(fieldValues)
, Assoc(assoc)
{
if (assoc == Association::Any || assoc == Association::WholeMesh)
if (assoc != Association::Points && assoc != Association::Cells)
throw("Unsupported field association");
}

4
vtkm/filter/geometry_refinement/SplitSharpEdges.cxx
View File

@ -24,11 +24,11 @@ VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
const vtkm::worklet::SplitSharpEdges& worklet)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
return vtkm::filter::MapFieldPermutation(field, worklet.GetNewPointsIdArray(), result);
}
else if (field.IsFieldCell() || field.IsFieldGlobal())
else if (field.IsCellField() || field.IsWholeDataSetField())
{
result.AddField(field); // pass through
return true;

6
vtkm/filter/geometry_refinement/Tetrahedralize.cxx
View File

@ -18,20 +18,20 @@ VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
const vtkm::worklet::Tetrahedralize& worklet)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
// point data is copied as is because it was not collapsed
result.AddField(field);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
// cell data must be scattered to the cells created per input cell
vtkm::cont::ArrayHandle<vtkm::Id> permutation =
worklet.GetOutCellScatter().GetOutputToInputMap();
return vtkm::filter::MapFieldPermutation(field, permutation, result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

6
vtkm/filter/geometry_refinement/Triangulate.cxx
View File

@ -19,20 +19,20 @@ VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
const vtkm::worklet::Triangulate& worklet)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
// point data is copied as is because it was not collapsed
result.AddField(field);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
// cell data must be scattered to the cells created per input cell
vtkm::cont::ArrayHandle<vtkm::Id> permutation =
worklet.GetOutCellScatter().GetOutputToInputMap();
return vtkm::filter::MapFieldPermutation(field, permutation, result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

6
vtkm/filter/geometry_refinement/Tube.cxx
View File

@ -18,15 +18,15 @@ VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
const vtkm::worklet::Tube& worklet)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
return vtkm::filter::MapFieldPermutation(field, worklet.GetOutputPointSourceIndex(), result);
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
return vtkm::filter::MapFieldPermutation(field, worklet.GetOutputCellSourceIndex(), result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

6
vtkm/filter/geometry_refinement/VertexClustering.cxx
View File

@ -19,15 +19,15 @@ VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
const vtkm::worklet::VertexClustering& worklet)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
return vtkm::filter::MapFieldPermutation(field, worklet.GetPointIdMap(), result);
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
return vtkm::filter::MapFieldPermutation(field, worklet.GetCellIdMap(), result);
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

2
vtkm/filter/image_processing/ComputeMoments.cxx
View File

@ -42,7 +42,7 @@ VTKM_CONT ComputeMoments::ComputeMoments()
VTKM_CONT vtkm::cont::DataSet ComputeMoments::DoExecute(const vtkm::cont::DataSet& input)
{
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorBadValue("Active field for ComputeMoments must be a point field.");
}

2
vtkm/filter/image_processing/ImageDifference.cxx
View File

@ -49,7 +49,7 @@ VTKM_CONT vtkm::cont::DataSet ImageDifference::DoExecute(const vtkm::cont::DataS
this->ImageDiffWithinThreshold = true;
const auto& primaryField = this->GetFieldFromDataSet(input);
if (!primaryField.IsFieldPoint())
if (!primaryField.IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("Point field expected.");
}

2
vtkm/filter/image_processing/ImageMedian.cxx
View File

@ -90,7 +90,7 @@ namespace image_processing
VTKM_CONT vtkm::cont::DataSet ImageMedian::DoExecute(const vtkm::cont::DataSet& input)
{
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorBadValue("Active field for ImageMedian must be a point field.");
}

2
vtkm/filter/mesh_info/CellMeasures.cxx
View File

@ -31,7 +31,7 @@ VTKM_CONT CellMeasures::CellMeasures(IntegrationType m)
VTKM_CONT vtkm::cont::DataSet CellMeasures::DoExecute(const vtkm::cont::DataSet& input)
{
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("CellMeasures expects point field input.");
}

2
vtkm/filter/mesh_info/MeshQualityArea.cxx
View File

@ -143,7 +143,7 @@ vtkm::Float64 MeshQualityArea::ComputeAverageArea(const vtkm::cont::DataSet& inp
vtkm::cont::DataSet MeshQualityArea::DoExecute(const vtkm::cont::DataSet& input)
{
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorBadValue("Active field for MeshQuality must be point coordinates. "
"But the active field is not a point field.");

2
vtkm/filter/mesh_info/MeshQualityVolume.cxx
View File

@ -132,7 +132,7 @@ vtkm::Float64 MeshQualityVolume::ComputeAverageVolume(const vtkm::cont::DataSet&
vtkm::cont::DataSet MeshQualityVolume::DoExecute(const vtkm::cont::DataSet& input)
{
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorBadValue("Active field for MeshQuality must be point coordinates. "
"But the active field is not a point field.");

2
vtkm/filter/mesh_info/worklet/MeshQualityWorklet.h
View File

@ -82,7 +82,7 @@ struct MeshQualityWorklet : vtkm::worklet::WorkletVisitCellsWithPoints
VTKM_CONT vtkm::cont::UnknownArrayHandle Run(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field) const
{
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorBadValue("Active field for MeshQuality must be point coordinates. "
"But the active field is not a point field.");

6
vtkm/filter/resampling/Probe.cxx
View File

@ -28,7 +28,7 @@ bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::worklet::Probe& worklet,
vtkm::Float64 invalidValue)
{
if (field.IsFieldPoint())
if (field.IsPointField())
{
auto resolve = [&](const auto& concrete) {
using T = typename std::decay_t<decltype(concrete)>::ValueType;
@ -41,7 +41,7 @@ bool DoMapField(vtkm::cont::DataSet& result,
resolve);
return true;
}
else if (field.IsFieldCell())
else if (field.IsCellField())
{
vtkm::cont::Field outField;
if (vtkm::filter::MapFieldPermutation(field, worklet.GetCellIds(), outField, invalidValue))
@ -54,7 +54,7 @@ bool DoMapField(vtkm::cont::DataSet& result,
}
return false;
}
else if (field.IsFieldGlobal())
else if (field.IsWholeDataSetField())
{
result.AddField(field);
return true;

8
vtkm/filter/scalar_topology/ContourTreeUniform.cxx
View File

@ -74,7 +74,7 @@ ContourTreeMesh2D::ContourTreeMesh2D()
vtkm::cont::DataSet ContourTreeMesh2D::DoExecute(const vtkm::cont::DataSet& input)
{
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("ContourTreeMesh2D expects point field input.");
}
@ -96,7 +96,7 @@ vtkm::cont::DataSet ContourTreeMesh2D::DoExecute(const vtkm::cont::DataSet& inpu
this->CastAndCallScalarField(field, resolveType);
return this->CreateResultField(
input, this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, saddlePeak);
input, this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, saddlePeak);
}
//-----------------------------------------------------------------------------
@ -109,7 +109,7 @@ ContourTreeMesh3D::ContourTreeMesh3D()
vtkm::cont::DataSet ContourTreeMesh3D::DoExecute(const vtkm::cont::DataSet& input)
{
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("Point field expected.");
}
@ -132,7 +132,7 @@ vtkm::cont::DataSet ContourTreeMesh3D::DoExecute(const vtkm::cont::DataSet& inpu
this->CastAndCallScalarField(field, resolveType);
return this->CreateResultField(
input, this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, saddlePeak);
input, this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, saddlePeak);
}
} // namespace scalar_topology
} // namespace filter

8
vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx
View File

@ -121,7 +121,7 @@ vtkm::cont::DataSet ContourTreeAugmented::DoExecute(const vtkm::cont::DataSet& i
// Check that the field is Ok
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("Point field expected.");
}
@ -189,10 +189,10 @@ vtkm::cont::DataSet ContourTreeAugmented::DoExecute(const vtkm::cont::DataSet& i
// DataSet without any coordinate system etc.
result = this->CreateResultField(input,
this->GetOutputFieldName(),
vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::Field::Association::WholeDataSet,
sortedValues);
// vtkm::cont::Field rfield(
// this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, sortedValues);
// this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeDataSet, sortedValues);
// result.AddField(rfield);
// return result;
}
@ -446,7 +446,7 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(const vtkm::cont::Partitioned
// TODO the result we return for the parallel and serial case are different right now. This should be made consistent. However, only in the parallel case are we useing the result output
vtkm::cont::DataSet temp;
vtkm::cont::Field rfield(this->GetOutputFieldName(),
vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::Field::Association::WholeDataSet,
contourTreeMeshOut.SortedValues);
temp.AddField(rfield);
output = vtkm::cont::PartitionedDataSet(temp);

10
vtkm/filter/scalar_topology/ContourTreeUniformDistributed.cxx
View File

@ -531,7 +531,7 @@ vtkm::cont::PartitionedDataSet ContourTreeUniformDistributed::DoExecutePartition
const auto& dataset = input.GetPartition(blockNo);
const auto& field =
dataset.GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("Point field expected.");
}
@ -784,10 +784,10 @@ inline VTKM_CONT void ContourTreeUniformDistributed::ComputeVolumeMetric(
hierarchical_hyper_sweep_master.foreach (
[&](HyperSweepBlock* b, const vtkmdiy::Master::ProxyWithLink&) {
vtkm::cont::Field intrinsicVolumeField(
"IntrinsicVolume", vtkm::cont::Field::Association::WholeMesh, b->IntrinsicVolume);
"IntrinsicVolume", vtkm::cont::Field::Association::WholeDataSet, b->IntrinsicVolume);
hierarchicalTreeOutputDataSet[b->LocalBlockNo].AddField(intrinsicVolumeField);
vtkm::cont::Field dependentVolumeField(
"DependentVolume", vtkm::cont::Field::Association::WholeMesh, b->DependentVolume);
"DependentVolume", vtkm::cont::Field::Association::WholeDataSet, b->DependentVolume);
hierarchicalTreeOutputDataSet[b->LocalBlockNo].AddField(dependentVolumeField);
#ifdef DEBUG_PRINT
VTKM_LOG_S(this->TreeLogLevel, "Block " << b->GlobalBlockId);
@ -1210,7 +1210,7 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
auto vtkmGlobalBlockIdWP = vtkmGlobalBlockIdAH.WritePortal();
vtkmGlobalBlockIdWP.Set(0, blockData->GlobalBlockId);
vtkm::cont::Field vtkmGlobalBlockIdField(
"vtkmGlobalBlockId", vtkm::cont::Field::Association::WholeMesh, vtkmGlobalBlockIdAH);
"vtkmGlobalBlockId", vtkm::cont::Field::Association::WholeDataSet, vtkmGlobalBlockIdAH);
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(vtkmGlobalBlockIdField);
vtkm::cont::ArrayHandle<vtkm::Id> vtkmBlocksPerDimensionAH;
vtkmBlocksPerDimensionAH.Allocate(3);
@ -1219,7 +1219,7 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
vtkmBlocksPerDimensionWP.Set(1, this->BlocksPerDimension[1]);
vtkmBlocksPerDimensionWP.Set(2, this->BlocksPerDimension[2]);
vtkm::cont::Field vtkmBlocksPerDimensionField("vtkmBlocksPerDimension",
vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::Field::Association::WholeDataSet,
vtkmBlocksPerDimensionAH);
hierarchicalTreeOutputDataSet[blockData->LocalBlockNo].AddField(vtkmBlocksPerDimensionField);

2
vtkm/filter/scalar_topology/DistributedBranchDecompositionFilter.cxx
View File

@ -263,7 +263,7 @@ VTKM_CONT vtkm::cont::PartitionedDataSet DistributedBranchDecompositionFilter::D
branch_decomposition_master.foreach (
[&](BranchDecompositionBlock* b, const vtkmdiy::Master::ProxyWithLink&) {
vtkm::cont::Field branchRootField(
"BranchRoots", vtkm::cont::Field::Association::WholeMesh, b->BranchRoots);
"BranchRoots", vtkm::cont::Field::Association::WholeDataSet, b->BranchRoots);
outputDataSets[b->LocalBlockNo].AddField(branchRootField);
});

32
vtkm/filter/scalar_topology/worklet/contourtree_distributed/HierarchicalContourTree.h
View File

@ -1001,38 +1001,40 @@ template <typename FieldType>
void HierarchicalContourTree<FieldType>::AddToVTKMDataSet(vtkm::cont::DataSet& ds) const
{
// Create data set from output
vtkm::cont::Field regularNodeGlobalIdsField(
"RegularNodeGlobalIds", vtkm::cont::Field::Association::WholeMesh, this->RegularNodeGlobalIds);
vtkm::cont::Field regularNodeGlobalIdsField("RegularNodeGlobalIds",
vtkm::cont::Field::Association::WholeDataSet,
this->RegularNodeGlobalIds);
ds.AddField(regularNodeGlobalIdsField);
vtkm::cont::Field dataValuesField(
"DataValues", vtkm::cont::Field::Association::WholeMesh, this->DataValues);
"DataValues", vtkm::cont::Field::Association::WholeDataSet, this->DataValues);
ds.AddField(dataValuesField);
vtkm::cont::Field regularNodeSortOrderField(
"RegularNodeSortOrder", vtkm::cont::Field::Association::WholeMesh, this->RegularNodeSortOrder);
vtkm::cont::Field regularNodeSortOrderField("RegularNodeSortOrder",
vtkm::cont::Field::Association::WholeDataSet,
this->RegularNodeSortOrder);
ds.AddField(regularNodeSortOrderField);
vtkm::cont::Field regular2SupernodeField(
"Regular2Supernode", vtkm::cont::Field::Association::WholeMesh, this->Regular2Supernode);
"Regular2Supernode", vtkm::cont::Field::Association::WholeDataSet, this->Regular2Supernode);
ds.AddField(regular2SupernodeField);
vtkm::cont::Field superparentsField(
"Superparents", vtkm::cont::Field::Association::WholeMesh, this->Superparents);
"Superparents", vtkm::cont::Field::Association::WholeDataSet, this->Superparents);
ds.AddField(superparentsField);
vtkm::cont::Field supernodesField(
"Supernodes", vtkm::cont::Field::Association::WholeMesh, this->Supernodes);
"Supernodes", vtkm::cont::Field::Association::WholeDataSet, this->Supernodes);
ds.AddField(supernodesField);
vtkm::cont::Field superarcsField(
"Superarcs", vtkm::cont::Field::Association::WholeMesh, this->Superarcs);
"Superarcs", vtkm::cont::Field::Association::WholeDataSet, this->Superarcs);
ds.AddField(superarcsField);
vtkm::cont::Field hyperparentsField(
"Hyperparents", vtkm::cont::Field::Association::WholeMesh, this->Hyperparents);
"Hyperparents", vtkm::cont::Field::Association::WholeDataSet, this->Hyperparents);
ds.AddField(hyperparentsField);
vtkm::cont::Field super2HypernodeField(
"Super2Hypernode", vtkm::cont::Field::Association::WholeMesh, this->Super2Hypernode);
"Super2Hypernode", vtkm::cont::Field::Association::WholeDataSet, this->Super2Hypernode);
ds.AddField(super2HypernodeField);
vtkm::cont::Field whichRoundField(
"WhichRound", vtkm::cont::Field::Association::WholeMesh, this->WhichRound);
"WhichRound", vtkm::cont::Field::Association::WholeDataSet, this->WhichRound);
ds.AddField(whichRoundField);
vtkm::cont::Field whichIterationField(
"WhichIteration", vtkm::cont::Field::Association::WholeMesh, this->WhichIteration);
"WhichIteration", vtkm::cont::Field::Association::WholeDataSet, this->WhichIteration);
ds.AddField(whichIterationField);
// TODO/FIXME: See what other fields we need to add
vtkm::worklet::contourtree_augmented::IdArrayType firstSupernodePerIterationComponents;
@ -1042,12 +1044,12 @@ void HierarchicalContourTree<FieldType>::AddToVTKMDataSet(vtkm::cont::DataSet& d
firstSupernodePerIterationOffsets);
vtkm::cont::Field firstSupernodePerIterationComponentsField(
"FirstSupernodePerIterationComponents",
vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::Field::Association::WholeDataSet,
firstSupernodePerIterationComponents);
ds.AddField(firstSupernodePerIterationComponentsField);
vtkm::cont::Field firstSupernodePerIterationOffsetsField(
"FirstSupernodePerIterationOffsets",
vtkm::cont::Field::Association::WholeMesh,
vtkm::cont::Field::Association::WholeDataSet,
firstSupernodePerIterationOffsets);
ds.AddField(firstSupernodePerIterationOffsetsField);
// TODO/FIXME: It seems we may only need the counts for the first iteration, so check, which

60
vtkm/filter/testing/UnitTestPartitionedDataSetFilters.cxx
View File

@ -114,6 +114,66 @@ void TestPartitionedDataSetFilters()
cellAverage.SetActiveField("pointvar");
result = cellAverage.Execute(partitions);
Result_Verify<vtkm::FloatDefault>(result, cellAverage, partitions, std::string("pointvar"));
//Make sure that any Fields are propagated to the output.
//Test it with and without using SetFieldsToPass
std::vector<std::vector<std::string>> fieldsToPass;
fieldsToPass.push_back({});
fieldsToPass.push_back({ "ids" });
fieldsToPass.push_back({ "scalar" });
fieldsToPass.push_back({ "ids", "scalar" });
for (auto& fields : fieldsToPass)
{
partitionNum = 3;
partitions = PartitionedDataSetBuilder<vtkm::FloatDefault>(partitionNum, "pointvar");
std::vector<vtkm::Id> ids = { 0, 1, 2 };
std::vector<vtkm::FloatDefault> scalar = { 10.0f };
partitions.AddPartitionsField("ids", ids);
partitions.AddGlobalField("scalar", scalar);
//On second iteration, only allow "ids" to pass through.
cellAverage.GetFieldsToPass().ClearFields();
if (!fields.empty())
{
cellAverage.GetFieldsToPass().SetMode(vtkm::filter::FieldSelection::Mode::Select);
for (auto& f : fields)
cellAverage.GetFieldsToPass().AddField(f);
}
result = cellAverage.Execute(partitions);
if (fields.empty() || std::find(fields.begin(), fields.end(), "ids") != fields.end())
{
VTKM_TEST_ASSERT(result.HasPartitionsField("ids"), "Missing field on result");
auto field0 = result.GetField("ids");
auto portal0 =
field0.GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>().ReadPortal();
VTKM_TEST_ASSERT(portal0.GetNumberOfValues() == static_cast<vtkm::Id>(ids.size()),
"Wrong number of field values.");
for (std::size_t i = 0; i < ids.size(); i++)
VTKM_TEST_ASSERT(portal0.Get(static_cast<vtkm::Id>(i)) == ids[i], "Wrong field value.");
}
else
{
VTKM_TEST_ASSERT(!result.HasPartitionsField("ids"), "Field should not be on result");
}
if (fields.empty() || std::find(fields.begin(), fields.end(), "scalar") != fields.end())
{
VTKM_TEST_ASSERT(result.HasGlobalField("scalar"), "Missing field on result");
auto field1 = result.GetField("scalar");
auto portal1 =
field1.GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::FloatDefault>>().ReadPortal();
VTKM_TEST_ASSERT(portal1.GetNumberOfValues() == static_cast<vtkm::Id>(scalar.size()),
"Wrong number of field values.");
VTKM_TEST_ASSERT(portal1.Get(0) == scalar[0], "Wrong field value.");
}
else
{
VTKM_TEST_ASSERT(!result.HasGlobalField("scalar"), "Field should not be on result");
}
}
}
int UnitTestPartitionedDataSetFilters(int argc, char* argv[])

2
vtkm/filter/vector_analysis/Gradient.cxx
View File

@ -40,7 +40,7 @@ namespace vector_analysis
vtkm::cont::DataSet Gradient::DoExecute(const vtkm::cont::DataSet& inputDataSet)
{
const auto& field = this->GetFieldFromDataSet(inputDataSet);
if (!field.IsFieldPoint())
if (!field.IsPointField())
{
throw vtkm::cont::ErrorFilterExecution("Point field expected.");
}

2
vtkm/io/VTKDataSetReaderBase.cxx
View File

@ -499,7 +499,7 @@ void VTKDataSetReaderBase::AddField(const std::string& name,
switch (association)
{
case vtkm::cont::Field::Association::Points:
case vtkm::cont::Field::Association::WholeMesh:
case vtkm::cont::Field::Association::WholeDataSet:
this->DataSet.AddField(vtkm::cont::Field(name, association, data));
break;
case vtkm::cont::Field::Association::Cells:

2
vtkm/io/VTKDataSetWriter.cxx
View File

@ -353,7 +353,7 @@ void WriteCellFields(std::ostream& out,
for (vtkm::Id f = 0; f < dataSet.GetNumberOfFields(); f++)
{
const vtkm::cont::Field field = dataSet.GetField(f);
if (!field.IsFieldCell())
if (!field.IsCellField())
{
continue;
}

12
vtkm/io/testing/UnitTestVTKDataSetReader.cxx
View File

@ -395,7 +395,7 @@ void TestReadingFishTank()
// And if we open the file in Paraview, we can observe the bounds [0, 156.905].
const vtkm::cont::Field& vec_magnitude = ds.GetField("vec_magnitude");
VTKM_TEST_ASSERT(vec_magnitude.GetName() == "vec_magnitude");
VTKM_TEST_ASSERT(vec_magnitude.IsFieldPoint());
VTKM_TEST_ASSERT(vec_magnitude.IsPointField());
vtkm::Range mag_range;
vec_magnitude.GetRange(&mag_range);
@ -405,7 +405,7 @@ void TestReadingFishTank()
// This info was gleaned from the Paraview Information panel:
const vtkm::cont::Field& vec = ds.GetField("vec");
VTKM_TEST_ASSERT(vec.GetName() == "vec");
VTKM_TEST_ASSERT(vec.IsFieldPoint());
VTKM_TEST_ASSERT(vec.IsPointField());
// Bounds from Information panel:
// [-65.3147, 86.267], [-88.0325, 78.7217], [-67.0969, 156.867]
const vtkm::cont::ArrayHandle<vtkm::Range>& vecRanges = vec.GetRange();
@ -460,7 +460,7 @@ void TestReadingDoublePrecisionFishTank()
// This info was gleaned from the Paraview Information panel:
const vtkm::cont::Field& vec = ds.GetField("vec");
VTKM_TEST_ASSERT(vec.GetName() == "vec");
VTKM_TEST_ASSERT(vec.IsFieldPoint());
VTKM_TEST_ASSERT(vec.IsPointField());
// Bounds from Information panel:
// [-65.3147, 86.267], [-88.0325, 78.7217], [-67.0969, 156.867]
const vtkm::cont::ArrayHandle<vtkm::Range>& vecRanges = vec.GetRange();
@ -508,7 +508,7 @@ void TestReadingASCIIFishTank()
const vtkm::cont::Field& vec = ds.GetField("vec");
VTKM_TEST_ASSERT(vec.GetName() == "vec");
VTKM_TEST_ASSERT(vec.IsFieldPoint());
VTKM_TEST_ASSERT(vec.IsPointField());
// Bounds from Paraview information panel:
// [-65.3147, 86.267], [-88.0325, 78.7217], [-67.0969, 156.867]
const vtkm::cont::ArrayHandle<vtkm::Range>& vecRanges = vec.GetRange();
@ -561,7 +561,7 @@ void TestReadingFusion()
// vec_magnitude [0, 3.73778]
vtkm::cont::Field vec_magnitude = ds.GetField("vec_magnitude");
VTKM_TEST_ASSERT(vec_magnitude.GetName() == "vec_magnitude");
VTKM_TEST_ASSERT(vec_magnitude.IsFieldPoint());
VTKM_TEST_ASSERT(vec_magnitude.IsPointField());
vtkm::Range mag_range;
vec_magnitude.GetRange(&mag_range);
@ -571,7 +571,7 @@ void TestReadingFusion()
vtkm::cont::Field vec = ds.GetField("vec");
VTKM_TEST_ASSERT(vec.GetName() == "vec");
VTKM_TEST_ASSERT(vec.IsFieldPoint());
VTKM_TEST_ASSERT(vec.IsPointField());
const vtkm::cont::ArrayHandle<vtkm::Range>& vecRanges = vec.GetRange();
VTKM_TEST_ASSERT(vecRanges.GetNumberOfValues() == 3);
auto vecRangesReadPortal = vecRanges.ReadPortal();

2
vtkm/rendering/MapperWireframer.cxx
View File

@ -245,7 +245,7 @@ void MapperWireframer::RenderCells(const vtkm::cont::UnknownCellSet& inCellSet,
if (is1D)
{
const bool isSupportedField = inScalarField.IsFieldPoint();
const bool isSupportedField = inScalarField.IsPointField();
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue(

4
vtkm/rendering/Wireframer.h
View File

@ -529,12 +529,12 @@ private:
xOffset = static_cast<vtkm::Id>(_x);
}
const bool isSupportedField = ScalarField.IsFieldCell() || ScalarField.IsFieldPoint();
const bool isSupportedField = ScalarField.IsCellField() || ScalarField.IsPointField();
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue("Field not associated with cell set or points");
}
const bool isAssocPoints = ScalarField.IsFieldPoint();
const bool isAssocPoints = ScalarField.IsPointField();
{
vtkm::cont::Token token;

4
vtkm/rendering/raytracing/ConnectivityTracer.cxx
View File

@ -205,12 +205,12 @@ void ConnectivityTracer::SetVolumeData(const vtkm::cont::Field& scalarField,
Coords = coords;
MeshConnIsConstructed = false;
const bool isSupportedField = ScalarField.IsFieldCell() || ScalarField.IsFieldPoint();
const bool isSupportedField = ScalarField.IsCellField() || ScalarField.IsPointField();
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue("Field not accociated with cell set or points");
}
FieldAssocPoints = ScalarField.IsFieldPoint();
FieldAssocPoints = ScalarField.IsPointField();
this->Integrator = Volume;

2
vtkm/rendering/raytracing/CylinderIntersector.cxx
View File

@ -476,7 +476,7 @@ void CylinderIntersector::IntersectionDataImp(Ray<Precision>& rays,
ShapeIntersector::IntersectionPoint(rays);
// TODO: if this is nodes of a mesh, support points
const bool isSupportedField = scalarField.IsFieldCell() || scalarField.IsFieldPoint();
const bool isSupportedField = scalarField.IsCellField() || scalarField.IsPointField();
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue("Field not accociated with a cell set");

2
vtkm/rendering/raytracing/GlyphIntersector.cxx
View File

@ -587,7 +587,7 @@ void GlyphIntersector::IntersectionDataImp(Ray<Precision>& rays,
{
ShapeIntersector::IntersectionPoint(rays);
const bool isSupportedField = scalarField.IsFieldCell() || scalarField.IsFieldPoint();
const bool isSupportedField = scalarField.IsCellField() || scalarField.IsPointField();
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue(

2
vtkm/rendering/raytracing/GlyphIntersectorVector.cxx
View File

@ -664,7 +664,7 @@ void GlyphIntersectorVector::IntersectionDataImp(Ray<Precision>& rays,
{
ShapeIntersector::IntersectionPoint(rays);
const bool isSupportedField = field.IsFieldCell() || field.IsFieldPoint();
const bool isSupportedField = field.IsCellField() || field.IsPointField();
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue(

4
vtkm/rendering/raytracing/QuadIntersector.cxx
View File

@ -501,7 +501,7 @@ void QuadIntersector::IntersectionDataImp(Ray<Precision>& rays,
ShapeIntersector::IntersectionPoint(rays);
// TODO: if this is nodes of a mesh, support points
const bool isSupportedField = scalarField.IsFieldCell() || scalarField.IsFieldPoint();
const bool isSupportedField = scalarField.IsCellField() || scalarField.IsPointField();
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue("Field not accociated with a cell set");
@ -510,7 +510,7 @@ void QuadIntersector::IntersectionDataImp(Ray<Precision>& rays,
vtkm::worklet::DispatcherMapField<detail::CalculateNormals>(detail::CalculateNormals())
.Invoke(rays.HitIdx, rays.Dir, rays.NormalX, rays.NormalY, rays.NormalZ, CoordsHandle, QuadIds);
if (scalarField.IsFieldPoint())
if (scalarField.IsPointField())
{
vtkm::worklet::DispatcherMapField<detail::GetLerpedScalar<Precision>>(
detail::GetLerpedScalar<Precision>(vtkm::Float32(scalarRange.Min),

2
vtkm/rendering/raytracing/SphereIntersector.cxx
View File

@ -351,7 +351,7 @@ void SphereIntersector::IntersectionDataImp(Ray<Precision>& rays,
{
ShapeIntersector::IntersectionPoint(rays);
const bool isSupportedField = scalarField.IsFieldCell() || scalarField.IsFieldPoint();
const bool isSupportedField = scalarField.IsCellField() || scalarField.IsPointField();
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue(

4
vtkm/rendering/raytracing/TriangleIntersector.cxx
View File

@ -356,12 +356,12 @@ public:
const vtkm::cont::Field scalarField,
const vtkm::Range& scalarRange)
{
const bool isSupportedField = scalarField.IsFieldCell() || scalarField.IsFieldPoint();
const bool isSupportedField = scalarField.IsCellField() || scalarField.IsPointField();
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue("Field not accociated with cell set or points");
}
const bool isAssocPoints = scalarField.IsFieldPoint();
const bool isAssocPoints = scalarField.IsPointField();
// Find the triangle normal
vtkm::worklet::DispatcherMapField<CalculateNormals>(CalculateNormals())

4
vtkm/rendering/raytracing/VolumeRendererStructured.cxx
View File

@ -829,12 +829,12 @@ void VolumeRendererStructured::RenderOnDevice(vtkm::rendering::raytracing::Ray<P
logger->AddLogData("calc_ray_start", time);
timer.Start();
const bool isSupportedField = ScalarField->IsFieldCell() || ScalarField->IsFieldPoint();
const bool isSupportedField = ScalarField->IsCellField() || ScalarField->IsPointField();
if (!isSupportedField)
{
throw vtkm::cont::ErrorBadValue("Field not accociated with cell set or points");
}
const bool isAssocPoints = ScalarField->IsFieldPoint();
const bool isAssocPoints = ScalarField->IsPointField();
if (IsUniformDataSet)
{