From 2d30e6d45a659d64865f7b7db14e0e38a9716245 Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <morelandkd@ornl.gov>
Date: Mon, 31 Oct 2022 11:22:37 -0600
Subject: [PATCH] Coordinate systems are stored as Fields

Previously, `DataSet` managed `CoordinateSystem`s separately from `Field`s.
However, a `CoordinateSystem` is really just a `Field` with some special
attributes. Thus, coordiante systems are now just listed along with the
rest of the fields, and the coordinate systems are simply strings that
point back to the appropriate field. (This was actually the original
concept for `DataSet`, but the coordinate systems were separated from
fields for some now obsolete reasons.)
---
 docs/changelog/coords-are-fields.md           |  29 ++++
 tutorial/extract_edges.cxx                    |   2 +-
 vtkm/cont/CoordinateSystem.cxx                |  10 ++
 vtkm/cont/CoordinateSystem.h                  |   3 +
 vtkm/cont/DataSet.cxx                         | 135 ++++++++++++------
 vtkm/cont/DataSet.h                           | 130 +++++++++++------
 .../UnitTestDataSetBuilderCurvilinear.cxx     |   2 +-
 .../UnitTestDataSetBuilderExplicit.cxx        |   2 +-
 .../UnitTestDataSetBuilderRectilinear.cxx     |   2 +-
 .../testing/UnitTestDataSetBuilderUniform.cxx |   2 +-
 vtkm/cont/testing/UnitTestDataSetExplicit.cxx |   2 +-
 .../testing/UnitTestDataSetRectilinear.cxx    |   4 +-
 vtkm/cont/testing/UnitTestDataSetUniform.cxx  |   4 +-
 .../testing/UnitTestPartitionedDataSet.cxx    |   5 +
 vtkm/filter/NewFilter.cxx                     |  13 +-
 vtkm/filter/NewFilter.h                       | 119 ++++++++++++---
 vtkm/filter/NewFilterField.h                  |   7 +-
 .../clean_grid/testing/UnitTestCleanGrid.cxx  |   2 +-
 vtkm/filter/contour/Contour.cxx               |   4 +-
 vtkm/filter/contour/MIRFilter.cxx             |   3 +-
 .../testing/UnitTestClipWithFieldFilter.cxx   |   2 +-
 ...UnitTestClipWithImplicitFunctionFilter.cxx |   4 +-
 .../contour/testing/UnitTestContourFilter.cxx |   4 +-
 .../entity_extraction/ExternalFaces.cxx       |   2 +-
 .../entity_extraction/ExtractGeometry.cxx     |   2 +-
 .../entity_extraction/ExtractPoints.cxx       |   3 +-
 .../entity_extraction/ExtractStructured.cxx   |  44 ++++--
 .../entity_extraction/GhostCellRemove.cxx     |   2 +-
 vtkm/filter/entity_extraction/Mask.cxx        |   2 +-
 vtkm/filter/entity_extraction/MaskPoints.cxx  |   3 +-
 vtkm/filter/entity_extraction/Threshold.cxx   |   2 +-
 .../entity_extraction/ThresholdPoints.cxx     |   3 +-
 .../testing/UnitTestThresholdFilter.cxx       |  12 +-
 .../testing/UnitTestThresholdPointsFilter.cxx |   2 +-
 .../worklet/ExtractStructured.h               |  41 +-----
 .../CylindricalCoordinateTransform.cxx        |  34 +++--
 .../CylindricalCoordinateTransform.h          |   2 +
 .../filter/field_transform/PointTransform.cxx |   5 +-
 .../SphericalCoordinateTransform.cxx          |  35 +++--
 .../SphericalCoordinateTransform.h            |   2 +
 vtkm/filter/flow/Lagrangian.cxx               |   2 +-
 vtkm/filter/flow/LagrangianStructures.cxx     |   4 +-
 .../flow/testing/UnitTestLagrangianFilter.cxx |   2 +-
 .../geometry_refinement/VertexClustering.cxx  |   4 +-
 vtkm/filter/resampling/Probe.cxx              |   4 +-
 vtkm/filter/resampling/Probe.h                |   2 +-
 vtkm/io/VTKDataSetWriter.cxx                  |   6 +
 vtkm/io/testing/UnitTestBOVDataSetReader.cxx  |   4 +-
 vtkm/io/testing/UnitTestVTKDataSetReader.cxx  |  28 ++--
 vtkm/io/testing/UnitTestVTKDataSetWriter.cxx  |   7 +
 vtkm/rendering/ConnectivityProxy.cxx          |  17 +--
 vtkm/rendering/ConnectivityProxy.h            |   2 +-
 vtkm/rendering/MapperGlyphScalar.cxx          |   2 +-
 vtkm/rendering/MapperGlyphVector.cxx          |   2 +-
 vtkm/rendering/MapperWireframer.cxx           |   2 +-
 55 files changed, 511 insertions(+), 263 deletions(-)
 create mode 100644 docs/changelog/coords-are-fields.md

diff --git a/docs/changelog/coords-are-fields.md b/docs/changelog/coords-are-fields.md
new file mode 100644
index 000000000..06d2261d1
--- /dev/null
+++ b/docs/changelog/coords-are-fields.md
@@ -0,0 +1,29 @@
+# Coordiante systems are stored as Fields
+
+Previously, `DataSet` managed `CoordinateSystem`s separately from `Field`s.
+However, a `CoordinateSystem` is really just a `Field` with some special
+attributes. Thus, coordiante systems are now just listed along with the
+rest of the fields, and the coordinate systems are simply strings that
+point back to the appropriate field. (This was actually the original
+concept for `DataSet`, but the coordinate systems were separated from
+fields for some now obsolete reasons.)
+
+This change should not be very noticible, but there are a few consequences
+that should be noted.
+
+1. The `GetCoordinateSystem` methods no longer return a reference to a
+   `CoordinateSystem` object. This is because the `CoordinateSystem` object
+   is made on the fly from the field.
+2. When mapping fields in filters, the coordinate systems get mapped as
+   part of this process. This has allowed us to remove some of the special
+   cases needed to set the coordinate system in the output.
+3. If a filter is generating a coordinate system in a special way
+   (different than mapping other point fields), then it can use the special
+   `CreateResultCoordianteSystem` method to attach this custom coordinate
+   system to the output.
+4. The `DataSet::GetCoordianteSystems()` method to get a `vector<>` of all
+   coordiante systems is removed. `DataSet` no longer internally has this
+   structure. Although it could be built, the only reason for its existance
+   was to support passing coordinate systems in filters. Now that this is
+   done autmoatically, the method is no longer needed.
+
diff --git a/tutorial/extract_edges.cxx b/tutorial/extract_edges.cxx
index ee31224ed..15f8247eb 100644
--- a/tutorial/extract_edges.cxx
+++ b/tutorial/extract_edges.cxx
@@ -195,7 +195,7 @@ VTKM_CONT vtkm::cont::DataSet ExtractEdges::DoExecute(const vtkm::cont::DataSet&
   auto mapper = [&](auto& outDataSet, const auto& f) {
     DoMapField(outDataSet, f, outputToInputCellMap, cellToEdgeKeys);
   };
-  return this->CreateResult(inData, outCellSet, inData.GetCoordinateSystems(), mapper);
+  return this->CreateResult(inData, outCellSet, mapper);
 }
 
 int main(int argc, char** argv)
diff --git a/vtkm/cont/CoordinateSystem.cxx b/vtkm/cont/CoordinateSystem.cxx
index 44badd57b..b4128e296 100644
--- a/vtkm/cont/CoordinateSystem.cxx
+++ b/vtkm/cont/CoordinateSystem.cxx
@@ -11,6 +11,7 @@
 #include <vtkm/cont/ArrayHandleCompositeVector.h>
 #include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
 #include <vtkm/cont/CoordinateSystem.h>
+#include <vtkm/cont/ErrorBadValue.h>
 
 namespace vtkm
 {
@@ -22,6 +23,15 @@ VTKM_CONT CoordinateSystem::CoordinateSystem()
 {
 }
 
+VTKM_CONT CoordinateSystem::CoordinateSystem(const vtkm::cont::Field& src)
+  : Superclass(src)
+{
+  if (src.GetAssociation() != vtkm::cont::Field::Association::Points)
+  {
+    throw vtkm::cont::ErrorBadValue("CoordinateSystems can only be point field.");
+  }
+}
+
 VTKM_CONT CoordinateSystem::CoordinateSystem(std::string name,
                                              const vtkm::cont::UnknownArrayHandle& data)
   : Superclass(name, Association::Points, data)
diff --git a/vtkm/cont/CoordinateSystem.h b/vtkm/cont/CoordinateSystem.h
index 7f1a2ff06..34b8008d1 100644
--- a/vtkm/cont/CoordinateSystem.h
+++ b/vtkm/cont/CoordinateSystem.h
@@ -31,6 +31,9 @@ public:
   VTKM_CONT
   CoordinateSystem();
 
+  // It's OK for regular _point_ fields to become a CoordinateSystem object.
+  VTKM_CONT CoordinateSystem(const vtkm::cont::Field& src);
+
   VTKM_CONT CoordinateSystem(std::string name, const vtkm::cont::UnknownArrayHandle& data);
 
   template <typename T, typename Storage>
diff --git a/vtkm/cont/DataSet.cxx b/vtkm/cont/DataSet.cxx
index 26ae43976..f2bdb0693 100644
--- a/vtkm/cont/DataSet.cxx
+++ b/vtkm/cont/DataSet.cxx
@@ -9,8 +9,11 @@
 //============================================================================
 
 #include <vtkm/cont/DataSet.h>
+#include <vtkm/cont/ErrorBadValue.h>
 #include <vtkm/cont/Logging.h>
 
+#include <algorithm>
+
 namespace
 {
 
@@ -84,7 +87,7 @@ VTKM_CONT void SetGlobalGhostCellFieldName(const std::string& name) noexcept
 
 void DataSet::Clear()
 {
-  this->CoordSystems.clear();
+  this->CoordSystemNames.clear();
   this->Fields.Clear();
   this->CellSet = this->CellSet.NewInstance();
 }
@@ -158,10 +161,31 @@ const vtkm::cont::Field& DataSet::GetGhostCellField() const
   }
 }
 
-void DataSet::AddCoordinateSystem(const vtkm::cont::CoordinateSystem& cs)
+vtkm::IdComponent DataSet::AddCoordinateSystem(const vtkm::cont::CoordinateSystem& cs)
 {
-  CheckFieldSize(this->CellSet, cs);
-  this->CoordSystems.push_back(cs);
+  this->AddField(cs);
+  return this->AddCoordinateSystem(cs.GetName());
+}
+
+vtkm::IdComponent DataSet::AddCoordinateSystem(const std::string& pointFieldName)
+{
+  // Check to see if we already have this coordinate system.
+  vtkm::IdComponent index = this->GetCoordinateSystemIndex(pointFieldName);
+  if (index >= 0)
+  {
+    return index;
+  }
+
+  // Check to make sure this is a valid point field.
+  if (!this->HasPointField(pointFieldName))
+  {
+    throw vtkm::cont::ErrorBadValue("Cannot set point field named `" + pointFieldName +
+                                    "` as a coordinate system because it does not exist.");
+  }
+
+  // Add the field to the list of coordinates.
+  this->CoordSystemNames.push_back(pointFieldName);
+  return static_cast<vtkm::IdComponent>(this->CoordSystemNames.size() - 1);
 }
 
 void DataSet::SetCellSetImpl(const vtkm::cont::UnknownCellSet& cellSet)
@@ -211,67 +235,82 @@ void DataSet::SetGhostCellField(const vtkm::cont::UnknownArrayHandle& field)
   this->SetGhostCellField(GetGlobalGhostCellFieldName(), field);
 }
 
-void DataSet::CopyStructure(const vtkm::cont::DataSet& source)
+void DataSet::CopyPartsFromExcept(const vtkm::cont::DataSet& source,
+                                  vtkm::cont::DataSet::Parts partMask)
 {
-  this->CoordSystems = source.CoordSystems;
-  this->CellSet = source.CellSet;
-  this->GhostCellName = source.GhostCellName;
+  if ((partMask & vtkm::cont::DataSet::Parts::CellSet) == vtkm::cont::DataSet::Parts::None)
+  {
+    this->CellSet = source.CellSet;
+  }
+  if ((partMask & vtkm::cont::DataSet::Parts::GhostCellName) == vtkm::cont::DataSet::Parts::None)
+  {
+    this->GhostCellName = source.GhostCellName;
+  }
+
+  if ((partMask & vtkm::cont::DataSet::Parts::Fields) == vtkm::cont::DataSet::Parts::None)
+  {
+    vtkm::IdComponent numFields = source.GetNumberOfFields();
+    for (vtkm::IdComponent fIndex = 0; fIndex < numFields; ++fIndex)
+    {
+      this->AddField(source.GetField(fIndex));
+    }
+  }
+
+  if ((partMask & vtkm::cont::DataSet::Parts::Coordinates) == vtkm::cont::DataSet::Parts::None)
+  {
+    vtkm::IdComponent numCoords = source.GetNumberOfCoordinateSystems();
+    for (vtkm::IdComponent cIndex = 0; cIndex < numCoords; ++cIndex)
+    {
+      std::string coordName = source.GetCoordinateSystemName(cIndex);
+      if (this->HasPointField(coordName))
+      {
+        this->AddCoordinateSystem(coordName);
+      }
+      else
+      {
+        this->AddCoordinateSystem(source.GetCoordinateSystem(cIndex));
+      }
+    }
+  }
 
   CheckFieldSizes(this->CellSet, this->Fields);
 }
 
-const vtkm::cont::CoordinateSystem& DataSet::GetCoordinateSystem(vtkm::Id index) const
+vtkm::cont::CoordinateSystem DataSet::GetCoordinateSystem(vtkm::Id index) const
 {
   VTKM_ASSERT((index >= 0) && (index < this->GetNumberOfCoordinateSystems()));
-  return this->CoordSystems[static_cast<std::size_t>(index)];
+  return this->GetPointField(this->CoordSystemNames[static_cast<std::size_t>(index)]);
 }
 
-vtkm::cont::CoordinateSystem& DataSet::GetCoordinateSystem(vtkm::Id index)
+vtkm::IdComponent DataSet::GetCoordinateSystemIndex(const std::string& name) const
 {
-  VTKM_ASSERT((index >= 0) && (index < this->GetNumberOfCoordinateSystems()));
-  return this->CoordSystems[static_cast<std::size_t>(index)];
-}
-
-vtkm::Id DataSet::GetCoordinateSystemIndex(const std::string& name) const
-{
-  vtkm::Id index = -1;
-  for (auto i = this->CoordSystems.begin(); i != this->CoordSystems.end(); ++i)
+  auto nameIter = std::find(this->CoordSystemNames.begin(), this->CoordSystemNames.end(), name);
+  if (nameIter != this->CoordSystemNames.end())
   {
-    if (i->GetName() == name)
-    {
-      index = static_cast<vtkm::Id>(std::distance(this->CoordSystems.begin(), i));
-      break;
-    }
+    return static_cast<vtkm::IdComponent>(std::distance(this->CoordSystemNames.begin(), nameIter));
+  }
+  else
+  {
+    return -1;
   }
-  return index;
 }
 
-const vtkm::cont::CoordinateSystem& DataSet::GetCoordinateSystem(const std::string& name) const
+const std::string& DataSet::GetCoordinateSystemName(vtkm::Id index) const
+{
+  VTKM_ASSERT((index >= 0) && (index < this->GetNumberOfCoordinateSystems()));
+  return this->CoordSystemNames[static_cast<std::size_t>(index)];
+}
+
+vtkm::cont::CoordinateSystem DataSet::GetCoordinateSystem(const std::string& name) const
 {
   vtkm::Id index = this->GetCoordinateSystemIndex(name);
   if (index < 0)
   {
     std::string error_message("No coordinate system with the name " + name +
                               " valid names are: \n");
-    for (const auto& cs : this->CoordSystems)
+    for (const auto& csn : this->CoordSystemNames)
     {
-      error_message += cs.GetName() + "\n";
-    }
-    throw vtkm::cont::ErrorBadValue(error_message);
-  }
-  return this->GetCoordinateSystem(index);
-}
-
-vtkm::cont::CoordinateSystem& DataSet::GetCoordinateSystem(const std::string& name)
-{
-  vtkm::Id index = this->GetCoordinateSystemIndex(name);
-  if (index < 0)
-  {
-    std::string error_message("No coordinate system with the name " + name +
-                              " valid names are: \n");
-    for (const auto& cs : this->CoordSystems)
-    {
-      error_message += cs.GetName() + "\n";
+      error_message += csn + "\n";
     }
     throw vtkm::cont::ErrorBadValue(error_message);
   }
@@ -281,11 +320,13 @@ vtkm::cont::CoordinateSystem& DataSet::GetCoordinateSystem(const std::string& na
 void DataSet::PrintSummary(std::ostream& out) const
 {
   out << "DataSet:\n";
-  out << "  CoordSystems[" << this->CoordSystems.size() << "]\n";
-  for (std::size_t index = 0; index < this->CoordSystems.size(); index++)
+  out << "  CoordSystems[" << this->CoordSystemNames.size() << "]\n";
+  out << "   ";
+  for (const auto& csn : this->CoordSystemNames)
   {
-    this->CoordSystems[index].PrintSummary(out);
+    out << " " << csn;
   }
+  out << "\n";
 
   out << "  CellSet \n";
   this->GetCellSet().PrintSummary(out);
diff --git a/vtkm/cont/DataSet.h b/vtkm/cont/DataSet.h
index a23ae3381..36fb0fd2a 100644
--- a/vtkm/cont/DataSet.h
+++ b/vtkm/cont/DataSet.h
@@ -44,6 +44,19 @@ public:
 
   vtkm::cont::DataSet& operator=(const vtkm::cont::DataSet&) = default;
 
+  /// \brief An enumeration that can be used to refer to the parts of a `DataSet`.
+  ///
+  /// The items can be or'ed together (`|`) to refer to multiple parts.
+  enum struct Parts : vtkm::UInt32
+  {
+    None = 0x00,
+    CellSet = 0x01,
+    Fields = 0x02,
+    Coordinates = 0x04,
+    GhostCellName = 0x08,
+    All = 0xFF
+  };
+
   VTKM_CONT void Clear();
 
   /// Get the number of cells contained in this DataSet
@@ -259,8 +272,21 @@ public:
   }
 
 
+  /// \brief Adds the given `CoordinateSystem` to the `DataSet`.
+  ///
+  /// The coordinate system will also be added as a point field of the same name.
+  ///
+  /// \returns the index assigned to the added coordinate system.
   VTKM_CONT
-  void AddCoordinateSystem(const vtkm::cont::CoordinateSystem& cs);
+  vtkm::IdComponent AddCoordinateSystem(const vtkm::cont::CoordinateSystem& cs);
+
+  /// \brief Marks the point field with the given name as a coordinate system.
+  ///
+  /// If no such point field exists or the point field is of the wrong format, an exception
+  /// will be throw.
+  ///
+  /// \returns the index assigned to the added coordinate system.
+  VTKM_CONT vtkm::IdComponent AddCoordinateSystem(const std::string& pointFieldName);
 
   VTKM_CONT
   bool HasCoordinateSystem(const std::string& name) const
@@ -269,34 +295,20 @@ public:
   }
 
   VTKM_CONT
-  const vtkm::cont::CoordinateSystem& GetCoordinateSystem(vtkm::Id index = 0) const;
+  vtkm::cont::CoordinateSystem GetCoordinateSystem(vtkm::Id index = 0) const;
 
-  VTKM_CONT
-  vtkm::cont::CoordinateSystem& GetCoordinateSystem(vtkm::Id index = 0);
-
-  /// Returns the index for the first CoordinateSystem whose
+  /// Returns the index for the CoordinateSystem whose
   /// name matches the provided string.
   /// Will return -1 if no match is found
   VTKM_CONT
-  vtkm::Id GetCoordinateSystemIndex(const std::string& name) const;
+  vtkm::IdComponent GetCoordinateSystemIndex(const std::string& name) const;
 
-  /// Returns the first CoordinateSystem that matches the provided name.
+  VTKM_CONT const std::string& GetCoordinateSystemName(vtkm::Id index = 0) const;
+
+  /// Returns the CoordinateSystem that matches the provided name.
   /// Will throw an exception if no match is found
-  ///@{
   VTKM_CONT
-  const vtkm::cont::CoordinateSystem& GetCoordinateSystem(const std::string& name) const;
-
-  VTKM_CONT
-  vtkm::cont::CoordinateSystem& GetCoordinateSystem(const std::string& name);
-  ///@}
-
-  /// Returns an `std::vector` of `CoordinateSystem`s held in this `DataSet`.
-  ///
-  VTKM_CONT
-  std::vector<vtkm::cont::CoordinateSystem> GetCoordinateSystems() const
-  {
-    return this->CoordSystems;
-  }
+  vtkm::cont::CoordinateSystem GetCoordinateSystem(const std::string& name) const;
 
   template <typename CellSetType>
   VTKM_CONT void SetCellSet(const CellSetType& cellSet)
@@ -317,13 +329,35 @@ public:
   VTKM_CONT
   vtkm::IdComponent GetNumberOfCoordinateSystems() const
   {
-    return static_cast<vtkm::IdComponent>(this->CoordSystems.size());
+    return static_cast<vtkm::IdComponent>(this->CoordSystemNames.size());
   }
 
   /// Copies the structure i.e. coordinates systems and cellset from the source
   /// dataset. The fields are left unchanged.
+  VTKM_DEPRECATED(2.0, "Use CopyPartsFromExcept(source, vtkm::cont::DataSet::Parts::Fields)")
   VTKM_CONT
-  void CopyStructure(const vtkm::cont::DataSet& source);
+  void CopyStructure(const vtkm::cont::DataSet& source)
+  {
+    this->CopyPartsFromExcept(source, vtkm::cont::DataSet::Parts::Fields);
+  }
+
+  /// \brief Copy parts from a source data set.
+  ///
+  /// Data from the `source` `DataSet` are copied into this `DataSet`. Where possible,
+  /// parts like `Field`s and `CoordinateSystem`s from the source are added. Parts that
+  /// only have one instance in the `DataSet`, such as the `CellSet`, are replaced.
+  ///
+  /// By default, all parts are copied. A `partMask` is provided that
+  /// specifies which parts _not_ to copy. For example, to copy only the structure
+  /// but not any of the fields, specify to not copy the fields or coordinates as so.
+  ///
+  /// ```cpp
+  /// dest.CopyPartsFromExcept(
+  ///   src, vtkm::cont::DataSet::Parts::Fields | vtkm::cont::DataSet::Parts::Coordinates);
+  /// ```
+  ///
+  VTKM_CONT
+  void CopyPartsFromExcept(const vtkm::cont::DataSet& source, vtkm::cont::DataSet::Parts partMask);
 
   /// \brief Convert the structures in this data set to expected types.
   ///
@@ -344,7 +378,7 @@ public:
   void PrintSummary(std::ostream& out) const;
 
 private:
-  std::vector<vtkm::cont::CoordinateSystem> CoordSystems;
+  std::vector<std::string> CoordSystemNames;
   vtkm::cont::internal::FieldCollection Fields{ vtkm::cont::Field::Association::WholeDataSet,
                                                 vtkm::cont::Field::Association::Points,
                                                 vtkm::cont::Field::Association::Cells };
@@ -355,6 +389,20 @@ private:
   VTKM_CONT void SetCellSetImpl(const vtkm::cont::UnknownCellSet& cellSet);
 };
 
+VTKM_CONT inline vtkm::cont::DataSet::Parts operator|(vtkm::cont::DataSet::Parts lhs,
+                                                      vtkm::cont::DataSet::Parts rhs)
+{
+  using T = std::underlying_type_t<vtkm::cont::DataSet::Parts>;
+  return static_cast<vtkm::cont::DataSet::Parts>(static_cast<T>(lhs) | static_cast<T>(rhs));
+}
+
+VTKM_CONT inline vtkm::cont::DataSet::Parts operator&(vtkm::cont::DataSet::Parts lhs,
+                                                      vtkm::cont::DataSet::Parts rhs)
+{
+  using T = std::underlying_type_t<vtkm::cont::DataSet::Parts>;
+  return static_cast<vtkm::cont::DataSet::Parts>(static_cast<T>(lhs) & static_cast<T>(rhs));
+}
+
 } // namespace cont
 } // namespace vtkm
 
@@ -396,13 +444,6 @@ public:
   {
     const auto& dataset = serializable.DataSet;
 
-    vtkm::IdComponent numberOfCoordinateSystems = dataset.GetNumberOfCoordinateSystems();
-    vtkmdiy::save(bb, numberOfCoordinateSystems);
-    for (vtkm::IdComponent i = 0; i < numberOfCoordinateSystems; ++i)
-    {
-      vtkmdiy::save(bb, dataset.GetCoordinateSystem(i));
-    }
-
     vtkmdiy::save(bb, dataset.GetCellSet().ResetCellSetList(CellSetTypesList{}));
 
     vtkm::IdComponent numberOfFields = dataset.GetNumberOfFields();
@@ -411,6 +452,13 @@ public:
     {
       vtkmdiy::save(bb, dataset.GetField(i));
     }
+
+    vtkm::IdComponent numberOfCoordinateSystems = dataset.GetNumberOfCoordinateSystems();
+    vtkmdiy::save(bb, numberOfCoordinateSystems);
+    for (vtkm::IdComponent i = 0; i < numberOfCoordinateSystems; ++i)
+    {
+      vtkmdiy::save(bb, dataset.GetCoordinateSystemName(i));
+    }
   }
 
   static VTKM_CONT void load(BinaryBuffer& bb, Type& serializable)
@@ -418,15 +466,6 @@ public:
     auto& dataset = serializable.DataSet;
     dataset = {}; // clear
 
-    vtkm::IdComponent numberOfCoordinateSystems = 0;
-    vtkmdiy::load(bb, numberOfCoordinateSystems);
-    for (vtkm::IdComponent i = 0; i < numberOfCoordinateSystems; ++i)
-    {
-      vtkm::cont::CoordinateSystem coords;
-      vtkmdiy::load(bb, coords);
-      dataset.AddCoordinateSystem(coords);
-    }
-
     vtkm::cont::UncertainCellSet<CellSetTypesList> cells;
     vtkmdiy::load(bb, cells);
     dataset.SetCellSet(cells);
@@ -439,6 +478,15 @@ public:
       vtkmdiy::load(bb, field);
       dataset.AddField(field);
     }
+
+    vtkm::IdComponent numberOfCoordinateSystems = 0;
+    vtkmdiy::load(bb, numberOfCoordinateSystems);
+    for (vtkm::IdComponent i = 0; i < numberOfCoordinateSystems; ++i)
+    {
+      std::string coordName;
+      vtkmdiy::load(bb, coordName);
+      dataset.AddCoordinateSystem(coordName);
+    }
   }
 };
 
diff --git a/vtkm/cont/testing/UnitTestDataSetBuilderCurvilinear.cxx b/vtkm/cont/testing/UnitTestDataSetBuilderCurvilinear.cxx
index 222ebb572..e60c8f9a8 100644
--- a/vtkm/cont/testing/UnitTestDataSetBuilderCurvilinear.cxx
+++ b/vtkm/cont/testing/UnitTestDataSetBuilderCurvilinear.cxx
@@ -29,7 +29,7 @@ void ValidateDataSet(const vtkm::cont::DataSet& ds,
 {
   //Verify basics..
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Wrong number of fields.");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Wrong number of fields.");
   VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1, "Wrong number of coordinate systems.");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == numPoints, "Wrong number of coordinates.");
   VTKM_TEST_ASSERT(ds.GetNumberOfCells() == numCells, "Wrong number of cells.");
diff --git a/vtkm/cont/testing/UnitTestDataSetBuilderExplicit.cxx b/vtkm/cont/testing/UnitTestDataSetBuilderExplicit.cxx
index 6acb61586..641444f37 100644
--- a/vtkm/cont/testing/UnitTestDataSetBuilderExplicit.cxx
+++ b/vtkm/cont/testing/UnitTestDataSetBuilderExplicit.cxx
@@ -37,7 +37,7 @@ void ValidateDataSet(const vtkm::cont::DataSet& ds,
                      const vtkm::Bounds& bounds)
 {
   //Verify basics..
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Wrong number of fields.");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Wrong number of fields.");
   VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1, "Wrong number of coordinate systems.");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == numPoints, "Wrong number of coordinates.");
   VTKM_TEST_ASSERT(ds.GetNumberOfCells() == numCells, "Wrong number of cells.");
diff --git a/vtkm/cont/testing/UnitTestDataSetBuilderRectilinear.cxx b/vtkm/cont/testing/UnitTestDataSetBuilderRectilinear.cxx
index b9c97785d..dd0d2a04e 100644
--- a/vtkm/cont/testing/UnitTestDataSetBuilderRectilinear.cxx
+++ b/vtkm/cont/testing/UnitTestDataSetBuilderRectilinear.cxx
@@ -30,7 +30,7 @@ void ValidateDataSet(const vtkm::cont::DataSet& ds,
 {
   //Verify basics..
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Wrong number of fields.");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Wrong number of fields.");
   VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1, "Wrong number of coordinate systems.");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == numPoints, "Wrong number of coordinates.");
   VTKM_TEST_ASSERT(ds.GetNumberOfCells() == numCells, "Wrong number of cells.");
diff --git a/vtkm/cont/testing/UnitTestDataSetBuilderUniform.cxx b/vtkm/cont/testing/UnitTestDataSetBuilderUniform.cxx
index c35fa48bf..a7195b7be 100644
--- a/vtkm/cont/testing/UnitTestDataSetBuilderUniform.cxx
+++ b/vtkm/cont/testing/UnitTestDataSetBuilderUniform.cxx
@@ -31,7 +31,7 @@ void ValidateDataSet(const vtkm::cont::DataSet& ds,
 {
   //Verify basics..
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Wrong number of fields.");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Wrong number of fields.");
   VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1, "Wrong number of coordinate systems.");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == numPoints, "Wrong number of coordinates.");
   VTKM_TEST_ASSERT(ds.GetNumberOfCells() == numCells, "Wrong number of cells.");
diff --git a/vtkm/cont/testing/UnitTestDataSetExplicit.cxx b/vtkm/cont/testing/UnitTestDataSetExplicit.cxx
index 56abcf63a..0fc67d86f 100644
--- a/vtkm/cont/testing/UnitTestDataSetExplicit.cxx
+++ b/vtkm/cont/testing/UnitTestDataSetExplicit.cxx
@@ -44,7 +44,7 @@ void TestDataSet_Explicit()
   vtkm::cont::testing::MakeTestDataSet tds;
   vtkm::cont::DataSet ds = tds.Make3DExplicitDataSet0();
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Incorrect number of fields");
 
   // test various field-getting methods and associations
   const vtkm::cont::Field& f1 = ds.GetField("pointvar");
diff --git a/vtkm/cont/testing/UnitTestDataSetRectilinear.cxx b/vtkm/cont/testing/UnitTestDataSetRectilinear.cxx
index 68b8f8588..f1aa27f25 100644
--- a/vtkm/cont/testing/UnitTestDataSetRectilinear.cxx
+++ b/vtkm/cont/testing/UnitTestDataSetRectilinear.cxx
@@ -42,7 +42,7 @@ static void TwoDimRectilinearTest()
   vtkm::cont::CellSetStructured<2> cellSet;
   dataSet.GetCellSet().AsCellSet(cellSet);
 
-  VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 3, "Incorrect number of fields");
   VTKM_TEST_ASSERT(dataSet.GetNumberOfCoordinateSystems() == 1,
                    "Incorrect number of coordinate systems");
   VTKM_TEST_ASSERT(cellSet.GetNumberOfPoints() == 6, "Incorrect number of points");
@@ -128,7 +128,7 @@ static void ThreeDimRectilinearTest()
   vtkm::cont::CellSetStructured<3> cellSet;
   dataSet.GetCellSet().AsCellSet(cellSet);
 
-  VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 3, "Incorrect number of fields");
 
   VTKM_TEST_ASSERT(dataSet.GetNumberOfCoordinateSystems() == 1,
                    "Incorrect number of coordinate systems");
diff --git a/vtkm/cont/testing/UnitTestDataSetUniform.cxx b/vtkm/cont/testing/UnitTestDataSetUniform.cxx
index f97dfc775..ff400c015 100644
--- a/vtkm/cont/testing/UnitTestDataSetUniform.cxx
+++ b/vtkm/cont/testing/UnitTestDataSetUniform.cxx
@@ -43,7 +43,7 @@ static void TwoDimUniformTest()
   vtkm::cont::CellSetStructured<2> cellSet;
   dataSet.GetCellSet().AsCellSet(cellSet);
 
-  VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 3, "Incorrect number of fields");
   VTKM_TEST_ASSERT(dataSet.GetNumberOfCoordinateSystems() == 1,
                    "Incorrect number of coordinate systems");
   VTKM_TEST_ASSERT(cellSet.GetNumberOfPoints() == 6, "Incorrect number of points");
@@ -132,7 +132,7 @@ static void ThreeDimUniformTest()
   vtkm::cont::CellSetStructured<3> cellSet;
   dataSet.GetCellSet().AsCellSet(cellSet);
 
-  VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 3, "Incorrect number of fields");
 
   VTKM_TEST_ASSERT(dataSet.GetNumberOfCoordinateSystems() == 1,
                    "Incorrect number of coordinate systems");
diff --git a/vtkm/cont/testing/UnitTestPartitionedDataSet.cxx b/vtkm/cont/testing/UnitTestPartitionedDataSet.cxx
index 49a336669..78c1c760c 100644
--- a/vtkm/cont/testing/UnitTestPartitionedDataSet.cxx
+++ b/vtkm/cont/testing/UnitTestPartitionedDataSet.cxx
@@ -224,6 +224,11 @@ void DataSet_Compare(vtkm::cont::DataSet& leftDataSet, vtkm::cont::DataSet& righ
 {
   for (vtkm::Id j = 0; j < leftDataSet.GetNumberOfFields(); j++)
   {
+    if (leftDataSet.HasCoordinateSystem(leftDataSet.GetField(j).GetName()))
+    {
+      // Skip coordinate systems, which have a different array type.
+      continue;
+    }
     vtkm::cont::ArrayHandle<vtkm::Float32> lDataArray;
     leftDataSet.GetField(j).GetData().AsArrayHandle(lDataArray);
     vtkm::cont::ArrayHandle<vtkm::Float32> rDataArray;
diff --git a/vtkm/filter/NewFilter.cxx b/vtkm/filter/NewFilter.cxx
index cea0a3dd7..77b6ba396 100644
--- a/vtkm/filter/NewFilter.cxx
+++ b/vtkm/filter/NewFilter.cxx
@@ -109,11 +109,14 @@ vtkm::cont::PartitionedDataSet NewFilter::Execute(const vtkm::cont::PartitionedD
 vtkm::cont::DataSet NewFilter::CreateResult(const vtkm::cont::DataSet& inDataSet) const
 {
   vtkm::cont::DataSet clone;
-  clone.CopyStructure(inDataSet);
-  this->MapFieldsOntoOutput(
-    inDataSet, clone, [](vtkm::cont::DataSet& out, const vtkm::cont::Field& fieldToPass) {
-      out.AddField(fieldToPass);
-    });
+  clone.CopyPartsFromExcept(
+    inDataSet, vtkm::cont::DataSet::Parts::Fields | vtkm::cont::DataSet::Parts::Coordinates);
+  this->MapFieldsOntoOutput(inDataSet,
+                            this->GetFieldsToPass(),
+                            clone,
+                            [](vtkm::cont::DataSet& out, const vtkm::cont::Field& fieldToPass) {
+                              out.AddField(fieldToPass);
+                            });
   return clone;
 }
 
diff --git a/vtkm/filter/NewFilter.h b/vtkm/filter/NewFilter.h
index 1b2458cda..44654f965 100644
--- a/vtkm/filter/NewFilter.h
+++ b/vtkm/filter/NewFilter.h
@@ -150,7 +150,7 @@ namespace filter
 ///   };
 ///   // This passes coordinate systems directly from input to output. If the points of
 ///   // the cell set change at all, they will have to be mapped by hand.
-///   return this->CreateResult(input, outCellSet, input.GetCoordinateSystems(), mapper);
+///   return this->CreateResult(input, outCellSet, mapper);
 /// }
 /// \endcode
 ///
@@ -188,15 +188,15 @@ namespace filter
 ///   // thus making it thread-safe.
 ///   SharedStates states;
 ///
-///   vtkm::cont::DataSet output;
-///   output = ... // Generation of the new DataSet and store interpolation parameters in `states`
+///   vtkm::cont::CellSetExplicit<> cellSet;
+///   cellSet = ... // Generation of the new DataSet and store interpolation parameters in `states`
 ///
 ///   // Lambda capture of `states`, effectively passing the shared states to the Mapper.
 ///   auto mapper = [&states](auto& outputDs, const auto& inputField) {
 ///      auto outputField = ... // Use `states` for mapping input field to output field
 ///      output.AddField(outputField);
 ///   };
-///   this->MapFieldsOntoOutput(input, output, mapper);
+///   this->CreateOutput(input, cellSet, mapper);
 ///
 ///   return output;
 /// }
@@ -292,6 +292,21 @@ public:
   vtkm::filter::FieldSelection& GetFieldsToPass() { return this->FieldsToPass; }
   ///@}
 
+  ///@{
+  /// \brief Specify whether to always pass coordinate systems.
+  ///
+  /// `CoordinateSystem`s in a `DataSet` are really just point fields marked as being a
+  /// coordinate system. Thus, a coordinate system is passed if and only if the associated
+  /// field is passed.
+  ///
+  /// By default, the filter will pass all fields associated with a coordinate system
+  /// regardless of the `FieldsToPass` marks the field as passing. If this option is set
+  /// to `false`, then coordinate systems will only be passed if it is marked so by
+  /// `FieldsToPass`.
+  VTKM_CONT void SetPassCoordinateSystems(bool flag) { this->PassCoordinateSystems = flag; }
+  VTKM_CONT bool GetPassCoordinateSystems() const { return this->PassCoordinateSystems; }
+  ///@}
+
   ///@{
   /// Executes the filter on the input and produces a result dataset.
   ///
@@ -357,7 +372,6 @@ protected:
   ///     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,
@@ -365,7 +379,7 @@ protected:
     FieldMapper&& fieldMapper) const
   {
     vtkm::cont::PartitionedDataSet output(resultPartitions.GetPartitions());
-    this->MapFieldsOntoOutput(input, output, fieldMapper);
+    this->MapFieldsOntoOutput(input, this->GetFieldsToPass(), output, fieldMapper);
     return output;
   }
 
@@ -376,9 +390,6 @@ protected:
   /// being created and a `Field` from the input and then applies any necessary transformations to
   /// the field array and adds it to the `DataSet`.
   ///
-  /// This form of `CreateResult` returns a `DataSet` with _no_ coordinate systems. The calling
-  /// program must add any necessary `CoordinateSystem`s.
-  ///
   /// \param[in] inDataSet The input data set being modified (usually the one passed
   ///     into `DoExecute`). The returned `DataSet` is filled with fields of `inDataSet`
   ///     (as selected by the `FieldsToPass` state of the filter).
@@ -396,8 +407,12 @@ protected:
                                              FieldMapper&& fieldMapper) const
   {
     vtkm::cont::DataSet outDataSet;
+    outDataSet.CopyPartsFromExcept(inDataSet,
+                                   vtkm::cont::DataSet::Parts::Fields |
+                                     vtkm::cont::DataSet::Parts::Coordinates |
+                                     vtkm::cont::DataSet::Parts::CellSet);
     outDataSet.SetCellSet(resultCellSet);
-    this->MapFieldsOntoOutput(inDataSet, outDataSet, fieldMapper);
+    this->MapFieldsOntoOutput(inDataSet, this->GetFieldsToPass(), outDataSet, fieldMapper);
     return outDataSet;
   }
 
@@ -436,6 +451,7 @@ protected:
     return outDataSet;
   }
 
+  ///@{
   /// \brief Create the output data set for `DoExecute`.
   ///
   /// This form of `CreateResult` will create an output data set with the given `CellSet`
@@ -457,31 +473,89 @@ protected:
   ///     the function should do nothing.
   ///
   template <typename FieldMapper>
-  VTKM_CONT vtkm::cont::DataSet CreateResult(const vtkm::cont::DataSet& inDataSet,
-                                             const vtkm::cont::UnknownCellSet& resultCellSet,
-                                             const vtkm::cont::CoordinateSystem& resultCoordSystem,
-                                             FieldMapper&& fieldMapper) const
+  VTKM_CONT vtkm::cont::DataSet CreateResultCoordinateSystem(
+    const vtkm::cont::DataSet& inDataSet,
+    const vtkm::cont::UnknownCellSet& resultCellSet,
+    const vtkm::cont::CoordinateSystem& resultCoordSystem,
+    FieldMapper&& fieldMapper) const
   {
-    return this->CreateResult(inDataSet,
-                              resultCellSet,
-                              std::vector<vtkm::cont::CoordinateSystem>{ resultCoordSystem },
-                              fieldMapper);
+    vtkm::cont::DataSet outDataSet;
+    outDataSet.CopyPartsFromExcept(inDataSet,
+                                   vtkm::cont::DataSet::Parts::Fields |
+                                     vtkm::cont::DataSet::Parts::Coordinates |
+                                     vtkm::cont::DataSet::Parts::CellSet);
+    outDataSet.SetCellSet(resultCellSet);
+    outDataSet.AddCoordinateSystem(resultCoordSystem);
+    vtkm::filter::FieldSelection fieldSelection = this->GetFieldsToPass();
+    fieldSelection.AddField(resultCoordSystem, vtkm::filter::FieldSelection::Mode::Exclude);
+    this->MapFieldsOntoOutput(inDataSet, fieldSelection, outDataSet, fieldMapper);
+    return outDataSet;
   }
 
+  template <typename FieldMapper>
+  VTKM_CONT vtkm::cont::DataSet CreateResultCoordinateSystem(
+    const vtkm::cont::DataSet& inDataSet,
+    const vtkm::cont::UnknownCellSet& resultCellSet,
+    const std::string& coordsName,
+    const vtkm::cont::UnknownArrayHandle& coordsData,
+    FieldMapper&& fieldMapper) const
+  {
+    return this->CreateResultCoordinateSystem(
+      inDataSet,
+      resultCellSet,
+      vtkm::cont::CoordinateSystem{ coordsName, coordsData },
+      fieldMapper);
+  }
+  ///@}
+
   VTKM_CONT virtual vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) = 0;
   VTKM_CONT virtual vtkm::cont::PartitionedDataSet DoExecutePartitions(
     const vtkm::cont::PartitionedDataSet& inData);
 
 private:
-  template <typename DataSetType, typename FieldMapper>
-  VTKM_CONT void MapFieldsOntoOutput(const DataSetType& input,
-                                     DataSetType& output,
+  template <typename FieldMapper>
+  VTKM_CONT void MapFieldsOntoOutput(const vtkm::cont::DataSet& input,
+                                     const vtkm::filter::FieldSelection& fieldSelection,
+                                     vtkm::cont::DataSet& output,
                                      FieldMapper&& fieldMapper) const
   {
     for (vtkm::IdComponent cc = 0; cc < input.GetNumberOfFields(); ++cc)
     {
       auto field = input.GetField(cc);
-      if (this->GetFieldsToPass().IsFieldSelected(field))
+      if (fieldSelection.IsFieldSelected(field))
+      {
+        fieldMapper(output, field);
+      }
+    }
+
+    for (vtkm::IdComponent csIndex = 0; csIndex < input.GetNumberOfCoordinateSystems(); ++csIndex)
+    {
+      auto coords = input.GetCoordinateSystem(csIndex);
+      if (!output.HasCoordinateSystem(coords.GetName()))
+      {
+        if (!output.HasPointField(coords.GetName()) &&
+            (this->GetPassCoordinateSystems() || this->GetFieldsToPass().IsFieldSelected(coords)))
+        {
+          fieldMapper(output, coords);
+        }
+        if (output.HasPointField(coords.GetName()))
+        {
+          output.AddCoordinateSystem(coords.GetName());
+        }
+      }
+    }
+  }
+
+  template <typename FieldMapper>
+  VTKM_CONT void MapFieldsOntoOutput(const vtkm::cont::PartitionedDataSet& input,
+                                     const vtkm::filter::FieldSelection& fieldSelection,
+                                     vtkm::cont::PartitionedDataSet& output,
+                                     FieldMapper&& fieldMapper) const
+  {
+    for (vtkm::IdComponent cc = 0; cc < input.GetNumberOfFields(); ++cc)
+    {
+      auto field = input.GetField(cc);
+      if (fieldSelection.IsFieldSelected(field))
       {
         fieldMapper(output, field);
       }
@@ -493,6 +567,7 @@ private:
 
 
   vtkm::filter::FieldSelection FieldsToPass = vtkm::filter::FieldSelection::Mode::All;
+  bool PassCoordinateSystems = true;
   bool RunFilterWithMultipleThreads = false;
   vtkm::Id NumThreadsPerCPU = 4;
   vtkm::Id NumThreadsPerGPU = 8;
diff --git a/vtkm/filter/NewFilterField.h b/vtkm/filter/NewFilterField.h
index 0c5f8ba9c..49c24b32b 100644
--- a/vtkm/filter/NewFilterField.h
+++ b/vtkm/filter/NewFilterField.h
@@ -133,7 +133,12 @@ protected:
   {
     if (this->UseCoordinateSystemAsField[index])
     {
-      return input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex(index));
+      // Note that we cannot use input.GetCoordinateSystem because that does not return
+      // a reference to a field. Instead, get the field name for the coordinate system
+      // and return the field.
+      const std::string& coordSystemName =
+        input.GetCoordinateSystemName(this->GetActiveCoordinateSystemIndex(index));
+      return input.GetPointField(coordSystemName);
     }
     else
     {
diff --git a/vtkm/filter/clean_grid/testing/UnitTestCleanGrid.cxx b/vtkm/filter/clean_grid/testing/UnitTestCleanGrid.cxx
index 2145a34ce..740e6d9dc 100644
--- a/vtkm/filter/clean_grid/testing/UnitTestCleanGrid.cxx
+++ b/vtkm/filter/clean_grid/testing/UnitTestCleanGrid.cxx
@@ -76,7 +76,7 @@ void TestPointMerging()
   //filter for uniform data always does point merging
   vtkm::cont::ArrayHandle<vtkm::Vec3f> newcoords;
   vtkm::cont::ArrayCopy(baseData.GetCoordinateSystem().GetData(), newcoords);
-  baseData.GetCoordinateSystem().SetData(newcoords);
+  baseData.AddPointField(baseData.GetCoordinateSystemName(), newcoords);
 
   vtkm::filter::contour::Contour marchingCubes;
   marchingCubes.SetIsoValue(0.05);
diff --git a/vtkm/filter/contour/Contour.cxx b/vtkm/filter/contour/Contour.cxx
index d16778bc9..4dbb51149 100644
--- a/vtkm/filter/contour/Contour.cxx
+++ b/vtkm/filter/contour/Contour.cxx
@@ -144,8 +144,8 @@ vtkm::cont::DataSet Contour::DoExecute(const vtkm::cont::DataSet& inDataSet)
       resolveFieldType);
 
   auto mapper = [&](auto& result, const auto& f) { DoMapField(result, f, worklet); };
-  vtkm::cont::DataSet output = this->CreateResult(
-    inDataSet, outputCells, vtkm::cont::CoordinateSystem{ "coordinates", vertices }, mapper);
+  vtkm::cont::DataSet output = this->CreateResultCoordinateSystem(
+    inDataSet, outputCells, inputCoords.GetName(), vertices, mapper);
 
   if (this->GenerateNormals)
   {
diff --git a/vtkm/filter/contour/MIRFilter.cxx b/vtkm/filter/contour/MIRFilter.cxx
index dcac6fb44..ea2e18dfc 100644
--- a/vtkm/filter/contour/MIRFilter.cxx
+++ b/vtkm/filter/contour/MIRFilter.cxx
@@ -335,7 +335,8 @@ VTKM_CONT vtkm::cont::DataSet MIRFilter::DoExecute(const vtkm::cont::DataSet& in
   auto mapper = [&](auto& outDataSet, const auto& f) {
     this->DoMapField(outDataSet, f, filterCellInterp, MIRWeights, MIRIDs);
   };
-  auto output = this->CreateResult(input, saved.GetCellSet(), saved.GetCoordinateSystems(), mapper);
+  auto output = this->CreateResultCoordinateSystem(
+    input, saved.GetCellSet(), saved.GetCoordinateSystem(), mapper);
   output.AddField(saved.GetField(this->GetOutputFieldName()));
 
   return output;
diff --git a/vtkm/filter/contour/testing/UnitTestClipWithFieldFilter.cxx b/vtkm/filter/contour/testing/UnitTestClipWithFieldFilter.cxx
index bef6f0975..3e854f9d0 100644
--- a/vtkm/filter/contour/testing/UnitTestClipWithFieldFilter.cxx
+++ b/vtkm/filter/contour/testing/UnitTestClipWithFieldFilter.cxx
@@ -63,7 +63,7 @@ void TestClipExplicit()
 
   VTKM_TEST_ASSERT(outputData.GetNumberOfCoordinateSystems() == 1,
                    "Wrong number of coordinate systems in the output dataset");
-  VTKM_TEST_ASSERT(outputData.GetNumberOfFields() == 1,
+  VTKM_TEST_ASSERT(outputData.GetNumberOfFields() == 2,
                    "Wrong number of fields in the output dataset");
 
   auto temp = outputData.GetField("scalars").GetData();
diff --git a/vtkm/filter/contour/testing/UnitTestClipWithImplicitFunctionFilter.cxx b/vtkm/filter/contour/testing/UnitTestClipWithImplicitFunctionFilter.cxx
index 36feba3e4..d8f0e834b 100644
--- a/vtkm/filter/contour/testing/UnitTestClipWithImplicitFunctionFilter.cxx
+++ b/vtkm/filter/contour/testing/UnitTestClipWithImplicitFunctionFilter.cxx
@@ -62,7 +62,7 @@ void TestClipStructured(vtkm::Float64 offset)
 
   VTKM_TEST_ASSERT(outputData.GetNumberOfCoordinateSystems() == 1,
                    "Wrong number of coordinate systems in the output dataset");
-  VTKM_TEST_ASSERT(outputData.GetNumberOfFields() == 1,
+  VTKM_TEST_ASSERT(outputData.GetNumberOfFields() == 2,
                    "Wrong number of fields in the output dataset");
   VTKM_TEST_ASSERT(outputData.GetNumberOfCells() == 8,
                    "Wrong number of cells in the output dataset");
@@ -98,7 +98,7 @@ void TestClipStructuredInverted()
   clip.SetFieldsToPass("scalars");
   auto outputData = clip.Execute(ds);
 
-  VTKM_TEST_ASSERT(outputData.GetNumberOfFields() == 1,
+  VTKM_TEST_ASSERT(outputData.GetNumberOfFields() == 2,
                    "Wrong number of fields in the output dataset");
   VTKM_TEST_ASSERT(outputData.GetNumberOfCells() == 4,
                    "Wrong number of cells in the output dataset");
diff --git a/vtkm/filter/contour/testing/UnitTestContourFilter.cxx b/vtkm/filter/contour/testing/UnitTestContourFilter.cxx
index d99445d68..9d93c8ea8 100644
--- a/vtkm/filter/contour/testing/UnitTestContourFilter.cxx
+++ b/vtkm/filter/contour/testing/UnitTestContourFilter.cxx
@@ -50,7 +50,7 @@ public:
       VTKM_TEST_ASSERT(result.GetNumberOfCoordinateSystems() == 1,
                        "Wrong number of coordinate systems in the output dataset");
       //since normals is on we have one field
-      VTKM_TEST_ASSERT(result.GetNumberOfFields() == 1,
+      VTKM_TEST_ASSERT(result.GetNumberOfFields() == 2,
                        "Wrong number of fields in the output dataset");
     }
 
@@ -61,7 +61,7 @@ public:
       const bool isMapped = result.HasField("tangle");
       VTKM_TEST_ASSERT(isMapped, "mapping should pass");
 
-      VTKM_TEST_ASSERT(result.GetNumberOfFields() == 3,
+      VTKM_TEST_ASSERT(result.GetNumberOfFields() == 4,
                        "Wrong number of fields in the output dataset");
 
       //verify the cellvar result
diff --git a/vtkm/filter/entity_extraction/ExternalFaces.cxx b/vtkm/filter/entity_extraction/ExternalFaces.cxx
index d5711c6da..9c2d4a527 100644
--- a/vtkm/filter/entity_extraction/ExternalFaces.cxx
+++ b/vtkm/filter/entity_extraction/ExternalFaces.cxx
@@ -60,7 +60,7 @@ vtkm::cont::DataSet ExternalFaces::GenerateOutput(const vtkm::cont::DataSet& inp
     // New Design: We are still using the old MapFieldOntoOutput to demonstrate the transition
     this->MapFieldOntoOutput(result, f);
   };
-  return this->CreateResult(input, outCellSet, input.GetCoordinateSystems(), mapper);
+  return this->CreateResult(input, outCellSet, mapper);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/vtkm/filter/entity_extraction/ExtractGeometry.cxx b/vtkm/filter/entity_extraction/ExtractGeometry.cxx
index 9361c115f..4e2d0229d 100644
--- a/vtkm/filter/entity_extraction/ExtractGeometry.cxx
+++ b/vtkm/filter/entity_extraction/ExtractGeometry.cxx
@@ -70,7 +70,7 @@ vtkm::cont::DataSet ExtractGeometry::DoExecute(const vtkm::cont::DataSet& input)
 
   // create the output dataset
   auto mapper = [&](auto& result, const auto& f) { DoMapField(result, f, worklet); };
-  return this->CreateResult(input, outCells, input.GetCoordinateSystems(), mapper);
+  return this->CreateResult(input, outCells, mapper);
 }
 
 } // namespace entity_extraction
diff --git a/vtkm/filter/entity_extraction/ExtractPoints.cxx b/vtkm/filter/entity_extraction/ExtractPoints.cxx
index 4f0c95d50..25648b383 100644
--- a/vtkm/filter/entity_extraction/ExtractPoints.cxx
+++ b/vtkm/filter/entity_extraction/ExtractPoints.cxx
@@ -59,8 +59,7 @@ vtkm::cont::DataSet ExtractPoints::DoExecute(const vtkm::cont::DataSet& input)
 
   // create the output dataset
   auto mapper = [&](auto& result, const auto& f) { DoMapField(result, f); };
-  vtkm::cont::DataSet output =
-    this->CreateResult(input, outCellSet, input.GetCoordinateSystems(), mapper);
+  vtkm::cont::DataSet output = this->CreateResult(input, outCellSet, mapper);
 
   // compact the unused points in the output dataset
   if (this->CompactPoints)
diff --git a/vtkm/filter/entity_extraction/ExtractStructured.cxx b/vtkm/filter/entity_extraction/ExtractStructured.cxx
index 399ab9b3e..a1962fb51 100644
--- a/vtkm/filter/entity_extraction/ExtractStructured.cxx
+++ b/vtkm/filter/entity_extraction/ExtractStructured.cxx
@@ -15,27 +15,45 @@
 
 namespace
 {
-VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
+VTKM_CONT void DoMapField(vtkm::cont::DataSet& result,
                           const vtkm::cont::Field& field,
                           const vtkm::cont::ArrayHandle<vtkm::Id>& CellFieldMap,
-                          const vtkm::cont::ArrayHandle<vtkm::Id>& PointFieldMap)
+                          const vtkm::cont::ArrayHandle<vtkm::Id>& PointFieldMap,
+                          const vtkm::worklet::ExtractStructured& worklet)
 {
   if (field.IsPointField())
   {
-    return vtkm::filter::MapFieldPermutation(field, PointFieldMap, result);
+    vtkm::cont::UnknownArrayHandle array = field.GetData();
+    using UniformCoordinatesArrayHandle =
+      vtkm::worklet::ExtractStructured::UniformCoordinatesArrayHandle;
+    using RectilinearCoordinatesArrayHandle =
+      vtkm::worklet::ExtractStructured::RectilinearCoordinatesArrayHandle;
+    if (array.CanConvert<UniformCoordinatesArrayHandle>())
+    {
+      // Special case that is more efficient for uniform coordinate arrays.
+      UniformCoordinatesArrayHandle newCoords =
+        worklet.MapCoordinatesUniform(array.AsArrayHandle<UniformCoordinatesArrayHandle>());
+      result.AddField(vtkm::cont::Field(field.GetName(), field.GetAssociation(), newCoords));
+    }
+    else if (array.CanConvert<RectilinearCoordinatesArrayHandle>())
+    {
+      // Special case that is more efficient for uniform coordinate arrays.
+      RectilinearCoordinatesArrayHandle newCoords =
+        worklet.MapCoordinatesRectilinear(array.AsArrayHandle<RectilinearCoordinatesArrayHandle>());
+      result.AddField(vtkm::cont::Field(field.GetName(), field.GetAssociation(), newCoords));
+    }
+    else
+    {
+      vtkm::filter::MapFieldPermutation(field, PointFieldMap, result);
+    }
   }
   else if (field.IsCellField())
   {
-    return vtkm::filter::MapFieldPermutation(field, CellFieldMap, result);
+    vtkm::filter::MapFieldPermutation(field, CellFieldMap, result);
   }
   else if (field.IsWholeDataSetField())
   {
     result.AddField(field);
-    return true;
-  }
-  else
-  {
-    return false;
   }
 }
 } // anonymous namespace
@@ -50,7 +68,6 @@ namespace entity_extraction
 vtkm::cont::DataSet ExtractStructured::DoExecute(const vtkm::cont::DataSet& input)
 {
   const vtkm::cont::UnknownCellSet& cells = input.GetCellSet();
-  const vtkm::cont::CoordinateSystem& coordinates = input.GetCoordinateSystem();
 
   vtkm::worklet::ExtractStructured worklet;
   auto cellset = worklet.Run(cells.ResetCellSetList<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(),
@@ -59,9 +76,6 @@ vtkm::cont::DataSet ExtractStructured::DoExecute(const vtkm::cont::DataSet& inpu
                              this->IncludeBoundary,
                              this->IncludeOffset);
 
-  auto coords = worklet.MapCoordinates(coordinates);
-  vtkm::cont::CoordinateSystem outputCoordinates(coordinates.GetName(), coords);
-
   // Create map arrays for mapping fields. Could potentially save some time to first check to see
   // if these arrays would be used.
   auto CellFieldMap =
@@ -70,9 +84,9 @@ vtkm::cont::DataSet ExtractStructured::DoExecute(const vtkm::cont::DataSet& inpu
     worklet.ProcessPointField(vtkm::cont::ArrayHandleIndex(input.GetNumberOfPoints()));
 
   auto mapper = [&](auto& result, const auto& f) {
-    DoMapField(result, f, CellFieldMap, PointFieldMap);
+    DoMapField(result, f, CellFieldMap, PointFieldMap, worklet);
   };
-  return this->CreateResult(input, cellset, outputCoordinates, mapper);
+  return this->CreateResult(input, cellset, mapper);
 }
 
 } // namespace entity_extraction
diff --git a/vtkm/filter/entity_extraction/GhostCellRemove.cxx b/vtkm/filter/entity_extraction/GhostCellRemove.cxx
index 546e898b7..1d6a8ffb7 100644
--- a/vtkm/filter/entity_extraction/GhostCellRemove.cxx
+++ b/vtkm/filter/entity_extraction/GhostCellRemove.cxx
@@ -367,7 +367,7 @@ VTKM_CONT vtkm::cont::DataSet GhostCellRemove::DoExecute(const vtkm::cont::DataS
   }
 
   auto mapper = [&](auto& result, const auto& f) { DoMapField(result, f, worklet); };
-  return this->CreateResult(input, cellOut, input.GetCoordinateSystems(), mapper);
+  return this->CreateResult(input, cellOut, mapper);
 }
 
 }
diff --git a/vtkm/filter/entity_extraction/Mask.cxx b/vtkm/filter/entity_extraction/Mask.cxx
index 44dc79b19..b7f89d467 100644
--- a/vtkm/filter/entity_extraction/Mask.cxx
+++ b/vtkm/filter/entity_extraction/Mask.cxx
@@ -51,7 +51,7 @@ VTKM_CONT vtkm::cont::DataSet Mask::DoExecute(const vtkm::cont::DataSet& input)
 
   // create the output dataset
   auto mapper = [&](auto& result, const auto& f) { DoMapField(result, f, worklet); };
-  return this->CreateResult(input, cellOut, input.GetCoordinateSystems(), mapper);
+  return this->CreateResult(input, cellOut, mapper);
 }
 } // namespace entity_extraction
 } // namespace filter
diff --git a/vtkm/filter/entity_extraction/MaskPoints.cxx b/vtkm/filter/entity_extraction/MaskPoints.cxx
index 564656f3e..7b8f977d7 100644
--- a/vtkm/filter/entity_extraction/MaskPoints.cxx
+++ b/vtkm/filter/entity_extraction/MaskPoints.cxx
@@ -56,8 +56,7 @@ VTKM_CONT vtkm::cont::DataSet MaskPoints::DoExecute(const vtkm::cont::DataSet& i
 
   // create the output dataset
   auto mapper = [&](auto& result, const auto& f) { DoMapField(result, f); };
-  vtkm::cont::DataSet output =
-    this->CreateResult(input, outCellSet, input.GetCoordinateSystems(), mapper);
+  vtkm::cont::DataSet output = this->CreateResult(input, outCellSet, mapper);
 
   // compact the unused points in the output dataset
   if (this->CompactPoints)
diff --git a/vtkm/filter/entity_extraction/Threshold.cxx b/vtkm/filter/entity_extraction/Threshold.cxx
index 8a86c5a8a..1d3c5765a 100644
--- a/vtkm/filter/entity_extraction/Threshold.cxx
+++ b/vtkm/filter/entity_extraction/Threshold.cxx
@@ -148,7 +148,7 @@ vtkm::cont::DataSet Threshold::DoExecute(const vtkm::cont::DataSet& input)
   vtkm::ListForEach(callWithArrayBaseComponent, vtkm::TypeListScalarAll{});
 
   auto mapper = [&](auto& result, const auto& f) { DoMapField(result, f, worklet); };
-  return this->CreateResult(input, cellOut, input.GetCoordinateSystems(), mapper);
+  return this->CreateResult(input, cellOut, mapper);
 }
 } // namespace entity_extraction
 } // namespace filter
diff --git a/vtkm/filter/entity_extraction/ThresholdPoints.cxx b/vtkm/filter/entity_extraction/ThresholdPoints.cxx
index 173e4af3d..ecceddc0a 100644
--- a/vtkm/filter/entity_extraction/ThresholdPoints.cxx
+++ b/vtkm/filter/entity_extraction/ThresholdPoints.cxx
@@ -174,8 +174,7 @@ VTKM_CONT vtkm::cont::DataSet ThresholdPoints::DoExecute(const vtkm::cont::DataS
 
   // create the output dataset
   auto mapper = [&](auto& result, const auto& f) { DoMapField(result, f); };
-  vtkm::cont::DataSet output =
-    this->CreateResult(input, outCellSet, input.GetCoordinateSystems(), mapper);
+  vtkm::cont::DataSet output = this->CreateResult(input, outCellSet, mapper);
 
   // compact the unused points in the output dataset
   if (this->CompactPoints)
diff --git a/vtkm/filter/entity_extraction/testing/UnitTestThresholdFilter.cxx b/vtkm/filter/entity_extraction/testing/UnitTestThresholdFilter.cxx
index 8ace0db57..9ade1efb0 100644
--- a/vtkm/filter/entity_extraction/testing/UnitTestThresholdFilter.cxx
+++ b/vtkm/filter/entity_extraction/testing/UnitTestThresholdFilter.cxx
@@ -49,7 +49,7 @@ public:
 
     if (returnAllInRange)
     {
-      VTKM_TEST_ASSERT(output.GetNumberOfFields() == 1,
+      VTKM_TEST_ASSERT(output.GetNumberOfFields() == 2,
                        "Wrong number of fields in the output dataset");
 
       vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
@@ -61,7 +61,7 @@ public:
     }
     else
     {
-      VTKM_TEST_ASSERT(output.GetNumberOfFields() == 1,
+      VTKM_TEST_ASSERT(output.GetNumberOfFields() == 2,
                        "Wrong number of fields in the output dataset");
 
       vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
@@ -105,7 +105,7 @@ public:
 
     if (returnAllInRange)
     {
-      VTKM_TEST_ASSERT(output.GetNumberOfFields() == 1,
+      VTKM_TEST_ASSERT(output.GetNumberOfFields() == 2,
                        "Wrong number of fields in the output dataset");
 
       vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
@@ -119,7 +119,7 @@ public:
     }
     else
     {
-      VTKM_TEST_ASSERT(output.GetNumberOfFields() == 1,
+      VTKM_TEST_ASSERT(output.GetNumberOfFields() == 2,
                        "Wrong number of fields in the output dataset");
 
       vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
@@ -150,7 +150,7 @@ public:
     threshold.SetFieldsToPass("cellvar");
     auto output = threshold.Execute(dataset);
 
-    VTKM_TEST_ASSERT(output.GetNumberOfFields() == 1,
+    VTKM_TEST_ASSERT(output.GetNumberOfFields() == 2,
                      "Wrong number of fields in the output dataset");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
@@ -180,7 +180,7 @@ public:
     threshold.SetFieldsToPass("cellvar");
     auto output = threshold.Execute(dataset);
 
-    VTKM_TEST_ASSERT(output.GetNumberOfFields() == 1,
+    VTKM_TEST_ASSERT(output.GetNumberOfFields() == 2,
                      "Wrong number of fields in the output dataset");
 
     vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
diff --git a/vtkm/filter/entity_extraction/testing/UnitTestThresholdPointsFilter.cxx b/vtkm/filter/entity_extraction/testing/UnitTestThresholdPointsFilter.cxx
index 2a7b7eeaa..3c751b99b 100644
--- a/vtkm/filter/entity_extraction/testing/UnitTestThresholdPointsFilter.cxx
+++ b/vtkm/filter/entity_extraction/testing/UnitTestThresholdPointsFilter.cxx
@@ -97,7 +97,7 @@ public:
     thresholdPoints.SetActiveField("pointvar");
     thresholdPoints.SetFieldsToPass("pointvar");
     auto output = thresholdPoints.Execute(dataset);
-    VTKM_TEST_ASSERT(output.GetNumberOfFields() == 1,
+    VTKM_TEST_ASSERT(output.GetNumberOfFields() == 2,
                      "Wrong number of fields in the output dataset");
     VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 0), "Wrong result for ThresholdPoints");
   }
diff --git a/vtkm/filter/entity_extraction/worklet/ExtractStructured.h b/vtkm/filter/entity_extraction/worklet/ExtractStructured.h
index 50b46aef8..f312422cd 100644
--- a/vtkm/filter/entity_extraction/worklet/ExtractStructured.h
+++ b/vtkm/filter/entity_extraction/worklet/ExtractStructured.h
@@ -415,7 +415,6 @@ public:
     return output;
   }
 
-private:
   using UniformCoordinatesArrayHandle = vtkm::cont::ArrayHandleUniformPointCoordinates;
 
   using RectilinearCoordinatesArrayHandle =
@@ -424,7 +423,8 @@ private:
                                             vtkm::cont::ArrayHandle<vtkm::FloatDefault>>;
 
 
-  UniformCoordinatesArrayHandle MapCoordinatesUniform(const UniformCoordinatesArrayHandle& coords)
+  UniformCoordinatesArrayHandle MapCoordinatesUniform(
+    const UniformCoordinatesArrayHandle& coords) const
   {
     using CoordsArray = vtkm::cont::ArrayHandleUniformPointCoordinates;
     using CoordType = CoordsArray::ValueType;
@@ -444,7 +444,7 @@ private:
   }
 
   RectilinearCoordinatesArrayHandle MapCoordinatesRectilinear(
-    const RectilinearCoordinatesArrayHandle& coords)
+    const RectilinearCoordinatesArrayHandle& coords) const
   {
     // For structured datasets, the cellsets are of different types based on
     // its dimensionality, but the coordinates are always 3 dimensional.
@@ -479,41 +479,6 @@ private:
     return vtkm::cont::make_ArrayHandleCartesianProduct(xyzs[0], xyzs[1], xyzs[2]);
   }
 
-  struct MapCoordinatesFunctor
-  {
-    template <typename T, typename S>
-    VTKM_CONT void operator()(const vtkm::cont::ArrayHandle<T, S>& coords,
-                              ExtractStructured& self,
-                              vtkm::cont::UnknownArrayHandle& output) const
-    {
-      output = self.ProcessPointField(coords);
-    }
-
-    VTKM_CONT void operator()(const UniformCoordinatesArrayHandle::Superclass& coords,
-                              ExtractStructured& self,
-                              vtkm::cont::UnknownArrayHandle& output) const
-    {
-      output = self.MapCoordinatesUniform(coords);
-    }
-
-    VTKM_CONT void operator()(const RectilinearCoordinatesArrayHandle::Superclass& coords,
-                              ExtractStructured& self,
-                              vtkm::cont::UnknownArrayHandle& output) const
-    {
-      output = self.MapCoordinatesRectilinear(coords);
-    }
-  };
-
-  friend MapCoordinatesFunctor;
-
-public:
-  vtkm::cont::UnknownArrayHandle MapCoordinates(const vtkm::cont::CoordinateSystem& coordinates)
-  {
-    vtkm::cont::UnknownArrayHandle output;
-    vtkm::cont::CastAndCall(coordinates, MapCoordinatesFunctor{}, *this, output);
-    return output;
-  }
-
 public:
   template <typename T, typename Storage>
   vtkm::cont::ArrayHandle<T> ProcessPointField(
diff --git a/vtkm/filter/field_transform/CylindricalCoordinateTransform.cxx b/vtkm/filter/field_transform/CylindricalCoordinateTransform.cxx
index 739876232..98a553c0b 100644
--- a/vtkm/filter/field_transform/CylindricalCoordinateTransform.cxx
+++ b/vtkm/filter/field_transform/CylindricalCoordinateTransform.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ErrorBadValue.h>
 #include <vtkm/filter/field_transform/CylindricalCoordinateTransform.h>
 #include <vtkm/filter/field_transform/worklet/CoordinateSystemTransform.h>
 
@@ -18,10 +19,21 @@ namespace filter
 namespace field_transform
 {
 
+CylindricalCoordinateTransform::CylindricalCoordinateTransform()
+{
+  this->SetUseCoordinateSystemAsField(true);
+}
+
 vtkm::cont::DataSet CylindricalCoordinateTransform::DoExecute(const vtkm::cont::DataSet& inDataSet)
 {
   vtkm::cont::UnknownArrayHandle outArray;
 
+  const vtkm::cont::Field& inField = this->GetFieldFromDataSet(inDataSet);
+  if (!inField.IsPointField())
+  {
+    throw vtkm::cont::ErrorBadValue("CylindricalCoordinateTransform only applies to point data.");
+  }
+
   auto resolveType = [&](const auto& concrete) {
     // use std::decay to remove const ref from the decltype of concrete.
     using T = typename std::decay_t<decltype(concrete)>::ValueType;
@@ -32,15 +44,21 @@ vtkm::cont::DataSet CylindricalCoordinateTransform::DoExecute(const vtkm::cont::
       this->Invoke(vtkm::worklet::CylToCar{}, concrete, result);
     outArray = result;
   };
-  this->CastAndCallVecField<3>(this->GetFieldFromDataSet(inDataSet), resolveType);
+  this->CastAndCallVecField<3>(inField, resolveType);
 
-  vtkm::cont::DataSet outDataSet =
-    this->CreateResult(inDataSet,
-                       inDataSet.GetCellSet(),
-                       vtkm::cont::CoordinateSystem("coordinates", outArray),
-                       [](vtkm::cont::DataSet& out, const vtkm::cont::Field& fieldToPass) {
-                         out.AddField(fieldToPass);
-                       });
+  std::string coordinateName = this->GetOutputFieldName();
+  if (coordinateName.empty())
+  {
+    coordinateName = inField.GetName();
+  }
+
+  vtkm::cont::DataSet outDataSet = this->CreateResultCoordinateSystem(
+    inDataSet,
+    inDataSet.GetCellSet(),
+    vtkm::cont::CoordinateSystem(coordinateName, outArray),
+    [](vtkm::cont::DataSet& out, const vtkm::cont::Field& fieldToPass) {
+      out.AddField(fieldToPass);
+    });
   return outDataSet;
 }
 
diff --git a/vtkm/filter/field_transform/CylindricalCoordinateTransform.h b/vtkm/filter/field_transform/CylindricalCoordinateTransform.h
index 260300b4a..2e11b6ed3 100644
--- a/vtkm/filter/field_transform/CylindricalCoordinateTransform.h
+++ b/vtkm/filter/field_transform/CylindricalCoordinateTransform.h
@@ -27,6 +27,8 @@ class VTKM_FILTER_FIELD_TRANSFORM_EXPORT CylindricalCoordinateTransform
   : public vtkm::filter::NewFilterField
 {
 public:
+  VTKM_CONT CylindricalCoordinateTransform();
+
   VTKM_CONT void SetCartesianToCylindrical() { CartesianToCylindrical = true; }
   VTKM_CONT void SetCylindricalToCartesian() { CartesianToCylindrical = false; }
 
diff --git a/vtkm/filter/field_transform/PointTransform.cxx b/vtkm/filter/field_transform/PointTransform.cxx
index c1babc4d5..0acd6d6de 100644
--- a/vtkm/filter/field_transform/PointTransform.cxx
+++ b/vtkm/filter/field_transform/PointTransform.cxx
@@ -51,8 +51,9 @@ VTKM_CONT vtkm::cont::DataSet PointTransform::DoExecute(const vtkm::cont::DataSe
   const auto& field = this->GetFieldFromDataSet(inDataSet);
   this->CastAndCallVecField<3>(field, resolveType);
 
-  vtkm::cont::DataSet outData = this->CreateResultField(
-    inDataSet, this->GetOutputFieldName(), field.GetAssociation(), outArray);
+  auto passMapper = [](auto& d, const auto& f) { d.AddField(f); };
+  vtkm::cont::DataSet outData = this->CreateResultCoordinateSystem(
+    inDataSet, inDataSet.GetCellSet(), this->GetOutputFieldName(), outArray, passMapper);
 
   if (this->GetChangeCoordinateSystem())
   {
diff --git a/vtkm/filter/field_transform/SphericalCoordinateTransform.cxx b/vtkm/filter/field_transform/SphericalCoordinateTransform.cxx
index 1a571dd80..af1730050 100644
--- a/vtkm/filter/field_transform/SphericalCoordinateTransform.cxx
+++ b/vtkm/filter/field_transform/SphericalCoordinateTransform.cxx
@@ -8,6 +8,7 @@
 //  PURPOSE.  See the above copyright notice for more information.
 //============================================================================
 
+#include <vtkm/cont/ErrorBadValue.h>
 #include <vtkm/filter/field_transform/SphericalCoordinateTransform.h>
 #include <vtkm/filter/field_transform/worklet/CoordinateSystemTransform.h>
 
@@ -17,10 +18,22 @@ namespace filter
 {
 namespace field_transform
 {
+
+SphericalCoordinateTransform::SphericalCoordinateTransform()
+{
+  this->SetUseCoordinateSystemAsField(true);
+}
+
 vtkm::cont::DataSet SphericalCoordinateTransform::DoExecute(const vtkm::cont::DataSet& inDataSet)
 {
   vtkm::cont::UnknownArrayHandle outArray;
 
+  const vtkm::cont::Field& inField = this->GetFieldFromDataSet(inDataSet);
+  if (!inField.IsPointField())
+  {
+    throw vtkm::cont::ErrorBadValue("SphericalCoordinateTransform only applies to point data.");
+  }
+
   auto resolveType = [&](const auto& concrete) {
     // use std::decay to remove const ref from the decltype of concrete.
     using T = typename std::decay_t<decltype(concrete)>::ValueType;
@@ -31,15 +44,21 @@ vtkm::cont::DataSet SphericalCoordinateTransform::DoExecute(const vtkm::cont::Da
       this->Invoke(vtkm::worklet::SphereToCar{}, concrete, result);
     outArray = result;
   };
-  this->CastAndCallVecField<3>(this->GetFieldFromDataSet(inDataSet), resolveType);
+  this->CastAndCallVecField<3>(inField, resolveType);
 
-  vtkm::cont::DataSet outDataSet =
-    this->CreateResult(inDataSet,
-                       inDataSet.GetCellSet(),
-                       vtkm::cont::CoordinateSystem("coordinates", outArray),
-                       [](vtkm::cont::DataSet& out, const vtkm::cont::Field& fieldToPass) {
-                         out.AddField(fieldToPass);
-                       });
+  std::string coordinateName = this->GetOutputFieldName();
+  if (coordinateName.empty())
+  {
+    coordinateName = inField.GetName();
+  }
+
+  vtkm::cont::DataSet outDataSet = this->CreateResultCoordinateSystem(
+    inDataSet,
+    inDataSet.GetCellSet(),
+    vtkm::cont::CoordinateSystem(coordinateName, outArray),
+    [](vtkm::cont::DataSet& out, const vtkm::cont::Field& fieldToPass) {
+      out.AddField(fieldToPass);
+    });
   return outDataSet;
 }
 } // namespace field_transform
diff --git a/vtkm/filter/field_transform/SphericalCoordinateTransform.h b/vtkm/filter/field_transform/SphericalCoordinateTransform.h
index b599ef86d..e76cfa78a 100644
--- a/vtkm/filter/field_transform/SphericalCoordinateTransform.h
+++ b/vtkm/filter/field_transform/SphericalCoordinateTransform.h
@@ -25,6 +25,8 @@ class VTKM_FILTER_FIELD_TRANSFORM_EXPORT SphericalCoordinateTransform
   : public vtkm::filter::NewFilterField
 {
 public:
+  VTKM_CONT SphericalCoordinateTransform();
+
   VTKM_CONT void SetCartesianToSpherical() { CartesianToSpherical = true; }
   VTKM_CONT void SetSphericalToCartesian() { CartesianToSpherical = false; }
 
diff --git a/vtkm/filter/flow/Lagrangian.cxx b/vtkm/filter/flow/Lagrangian.cxx
index b1fba866c..19a1fc7f8 100644
--- a/vtkm/filter/flow/Lagrangian.cxx
+++ b/vtkm/filter/flow/Lagrangian.cxx
@@ -262,7 +262,7 @@ VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(const vtkm::cont::DataSet& i
     auto fieldmapper = [&](vtkm::cont::DataSet& dataset, const vtkm::cont::Field& fieldToPass) {
       MapField(dataset, fieldToPass);
     };
-    outputData = this->CreateResult(input, outCellSet, outCoords, fieldmapper);
+    outputData = this->CreateResultCoordinateSystem(input, outCellSet, outCoords, fieldmapper);
     outputData.AddPointField("valid", this->BasisParticlesValidity);
     outputData.AddPointField("displacement", basisParticlesDisplacement);
 
diff --git a/vtkm/filter/flow/LagrangianStructures.cxx b/vtkm/filter/flow/LagrangianStructures.cxx
index a9f330e07..e1cea5861 100644
--- a/vtkm/filter/flow/LagrangianStructures.cxx
+++ b/vtkm/filter/flow/LagrangianStructures.cxx
@@ -174,8 +174,8 @@ VTKM_CONT vtkm::cont::DataSet LagrangianStructures::DoExecute(const vtkm::cont::
   auto fieldmapper = [&](vtkm::cont::DataSet& dataset, const vtkm::cont::Field& field) {
     MapField(dataset, field);
   };
-  vtkm::cont::DataSet output =
-    this->CreateResult(input, lcsInput.GetCellSet(), lcsInput.GetCoordinateSystem(), fieldmapper);
+  vtkm::cont::DataSet output = this->CreateResultCoordinateSystem(
+    input, lcsInput.GetCellSet(), lcsInput.GetCoordinateSystem(), fieldmapper);
   output.AddPointField(this->GetOutputFieldName(), outputField);
   return output;
 }
diff --git a/vtkm/filter/flow/testing/UnitTestLagrangianFilter.cxx b/vtkm/filter/flow/testing/UnitTestLagrangianFilter.cxx
index cd7699659..ddb850c83 100644
--- a/vtkm/filter/flow/testing/UnitTestLagrangianFilter.cxx
+++ b/vtkm/filter/flow/testing/UnitTestLagrangianFilter.cxx
@@ -69,7 +69,7 @@ void TestLagrangianFilterMultiStepInterval()
                          "Wrong number of coordinate systems in the output dataset.");
         VTKM_TEST_ASSERT(extractedBasisFlows.GetNumberOfPoints() == 512,
                          "Wrong number of basis flows extracted.");
-        VTKM_TEST_ASSERT(extractedBasisFlows.GetNumberOfFields() == 2, "Wrong number of fields.");
+        VTKM_TEST_ASSERT(extractedBasisFlows.GetNumberOfFields() == 3, "Wrong number of fields.");
       }
       else
       {
diff --git a/vtkm/filter/geometry_refinement/VertexClustering.cxx b/vtkm/filter/geometry_refinement/VertexClustering.cxx
index cb751e7f1..7effbe102 100644
--- a/vtkm/filter/geometry_refinement/VertexClustering.cxx
+++ b/vtkm/filter/geometry_refinement/VertexClustering.cxx
@@ -62,8 +62,8 @@ VTKM_CONT vtkm::cont::DataSet VertexClustering::DoExecute(const vtkm::cont::Data
               outCoords);
 
   auto mapper = [&](auto& result, const auto& f) { DoMapField(result, f, worklet); };
-  return this->CreateResult(
-    input, outCellSet, vtkm::cont::CoordinateSystem("coordinates", outCoords), mapper);
+  return this->CreateResultCoordinateSystem(
+    input, outCellSet, input.GetCoordinateSystem().GetName(), outCoords, mapper);
 }
 } // namespace geometry_refinement
 } // namespace filter
diff --git a/vtkm/filter/resampling/Probe.cxx b/vtkm/filter/resampling/Probe.cxx
index 3a59ef899..0c134ef3d 100644
--- a/vtkm/filter/resampling/Probe.cxx
+++ b/vtkm/filter/resampling/Probe.cxx
@@ -76,8 +76,8 @@ vtkm::cont::DataSet Probe::DoExecute(const vtkm::cont::DataSet& input)
   auto mapper = [&](auto& outDataSet, const auto& f) {
     DoMapField(outDataSet, f, worklet, this->InvalidValue);
   };
-  auto output = this->CreateResult(
-    input, this->Geometry.GetCellSet(), this->Geometry.GetCoordinateSystems(), mapper);
+  auto output = this->CreateResultCoordinateSystem(
+    input, this->Geometry.GetCellSet(), this->Geometry.GetCoordinateSystem(), mapper);
   output.AddField(vtkm::cont::make_FieldPoint("HIDDEN", worklet.GetHiddenPointsField()));
   output.AddField(
     vtkm::cont::make_FieldCell("HIDDEN", worklet.GetHiddenCellsField(output.GetCellSet())));
diff --git a/vtkm/filter/resampling/Probe.h b/vtkm/filter/resampling/Probe.h
index 2b896a260..9593bf88a 100644
--- a/vtkm/filter/resampling/Probe.h
+++ b/vtkm/filter/resampling/Probe.h
@@ -26,7 +26,7 @@ public:
   void SetGeometry(const vtkm::cont::DataSet& geometry)
   {
     this->Geometry = vtkm::cont::DataSet();
-    this->Geometry.CopyStructure(geometry);
+    this->Geometry.CopyPartsFromExcept(geometry, vtkm::cont::DataSet::Parts::Fields);
   }
 
   VTKM_CONT
diff --git a/vtkm/io/VTKDataSetWriter.cxx b/vtkm/io/VTKDataSetWriter.cxx
index 78650e6ee..daaf261dc 100644
--- a/vtkm/io/VTKDataSetWriter.cxx
+++ b/vtkm/io/VTKDataSetWriter.cxx
@@ -320,6 +320,12 @@ void WritePointFields(std::ostream& out,
       continue;
     }
 
+    if (field.GetName() == dataSet.GetCoordinateSystemName())
+    {
+      // Do not write out the first coordinate system as a field.
+      continue;
+    }
+
     vtkm::Id npoints = field.GetNumberOfValues();
     int ncomps = field.GetData().GetNumberOfComponentsFlat();
 
diff --git a/vtkm/io/testing/UnitTestBOVDataSetReader.cxx b/vtkm/io/testing/UnitTestBOVDataSetReader.cxx
index f1851ac90..606acd2de 100644
--- a/vtkm/io/testing/UnitTestBOVDataSetReader.cxx
+++ b/vtkm/io/testing/UnitTestBOVDataSetReader.cxx
@@ -45,7 +45,7 @@ void TestReadingBOVDataSet()
 
   auto const& ds = readBOVDataSet(bovFile.data());
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 1, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
   // See the .bov file: DATA SIZE: 50 50 50
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 50 * 50 * 50, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 50 * 50 * 50,
@@ -53,7 +53,7 @@ void TestReadingBOVDataSet()
   VTKM_TEST_ASSERT(ds.GetNumberOfCells() == 49 * 49 * 49, "Incorrect number of cells");
   // See the .bov file: VARIABLE: "var"
   VTKM_TEST_ASSERT(ds.HasField("var"), "Should have field 'var', but does not.");
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 1, "There is only one field in noise.bov");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "There is only one field in noise.bov");
   VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1,
                    "There is only one coordinate system in noise.bov");
 
diff --git a/vtkm/io/testing/UnitTestVTKDataSetReader.cxx b/vtkm/io/testing/UnitTestVTKDataSetReader.cxx
index 0d3dadadd..7270ddffc 100644
--- a/vtkm/io/testing/UnitTestVTKDataSetReader.cxx
+++ b/vtkm/io/testing/UnitTestVTKDataSetReader.cxx
@@ -53,7 +53,7 @@ void TestReadingPolyData(Format format)
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 5, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 6, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 8, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 8,
                    "Incorrect number of points (from cell set)");
@@ -70,7 +70,7 @@ void TestReadingPolyDataEmpty()
   VTKM_TEST_ASSERT(data.GetNumberOfPoints() == 8);
   VTKM_TEST_ASSERT(data.GetNumberOfCells() == 0);
   VTKM_TEST_ASSERT(data.GetCellSet().GetNumberOfPoints() == 8);
-  VTKM_TEST_ASSERT(data.GetNumberOfFields() == 1);
+  VTKM_TEST_ASSERT(data.GetNumberOfFields() == 2);
 }
 
 void TestReadingStructuredPoints(Format format)
@@ -81,7 +81,7 @@ void TestReadingStructuredPoints(Format format)
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 1, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 72, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 72,
                    "Incorrect number of points (from cell set)");
@@ -99,7 +99,7 @@ void TestReadingStructuredPointsVisIt(Format format)
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 1, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 64, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 64,
                    "Incorrect number of points (from cell set)");
@@ -116,7 +116,7 @@ void TestReadingUnstructuredGrid(Format format)
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 26, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 26,
                    "Incorrect number of points (from cell set)");
@@ -133,7 +133,7 @@ void TestReadingV5Format(Format format)
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 6, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 7, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 26, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 26,
                    "Incorrect number of points (from cell set)");
@@ -173,7 +173,7 @@ void TestReadingUnstructuredGridEmpty()
   VTKM_TEST_ASSERT(data.GetNumberOfPoints() == 26);
   VTKM_TEST_ASSERT(data.GetNumberOfCells() == 0);
   VTKM_TEST_ASSERT(data.GetCellSet().GetNumberOfPoints() == 26);
-  VTKM_TEST_ASSERT(data.GetNumberOfFields() == 2);
+  VTKM_TEST_ASSERT(data.GetNumberOfFields() == 3);
 }
 
 void TestReadingUnstructuredPixels()
@@ -291,7 +291,7 @@ void TestReadingUnstructuredGridVisIt(Format format)
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 26, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 26,
                    "Incorrect number of points (from cell set)");
@@ -309,7 +309,7 @@ void TestReadingRectilinearGrid1(Format format)
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 125, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 125,
                    "Incorrect number of points (from cell set)");
@@ -327,7 +327,7 @@ void TestReadingRectilinearGrid2(Format format)
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 24, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 24,
                    "Incorrect number of points (from cell set)");
@@ -343,7 +343,7 @@ void TestReadingStructuredGridASCII()
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 6, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 6,
                    "Incorrect number of points (from cell set)");
@@ -359,7 +359,7 @@ void TestReadingStructuredGridBin()
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 18, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 18,
                    "Incorrect number of points (from cell set)");
@@ -379,7 +379,7 @@ void TestReadingFishTank()
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 50 * 50 * 50, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 50 * 50 * 50,
                    "Incorrect number of points (from cell set)");
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 3, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.HasField("vec"), "The vtk file has a field 'vec', but the dataset does not.");
   VTKM_TEST_ASSERT(ds.HasField("vec_magnitude"),
                    "The vtk file has a field 'vec_magnitude', but the dataset does not.");
@@ -622,7 +622,7 @@ void TestSkppingStringFields(Format format)
 
   vtkm::cont::DataSet ds = readVTKDataSet(testFileName);
 
-  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 1, "Incorrect number of fields");
+  VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2, "Incorrect number of fields");
   VTKM_TEST_ASSERT(ds.GetNumberOfPoints() == 72, "Incorrect number of points");
   VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfPoints() == 72,
                    "Incorrect number of points (from cell set)");
diff --git a/vtkm/io/testing/UnitTestVTKDataSetWriter.cxx b/vtkm/io/testing/UnitTestVTKDataSetWriter.cxx
index 45f6436a3..06caecd69 100644
--- a/vtkm/io/testing/UnitTestVTKDataSetWriter.cxx
+++ b/vtkm/io/testing/UnitTestVTKDataSetWriter.cxx
@@ -112,6 +112,13 @@ void CheckWrittenReadData(const vtkm::cont::DataSet& originalData,
   for (vtkm::IdComponent fieldId = 0; fieldId < originalData.GetNumberOfFields(); ++fieldId)
   {
     vtkm::cont::Field originalField = originalData.GetField(fieldId);
+    if (originalField.IsPointField() &&
+        (originalField.GetName() == originalData.GetCoordinateSystemName()))
+    {
+      // Do not check the field that is the first coordinate system. It is likely to have
+      // changed name because VTK does not name coordinate systems.
+      continue;
+    }
     VTKM_TEST_ASSERT(fileData.HasField(originalField.GetName(), originalField.GetAssociation()));
     vtkm::cont::Field fileField =
       fileData.GetField(originalField.GetName(), originalField.GetAssociation());
diff --git a/vtkm/rendering/ConnectivityProxy.cxx b/vtkm/rendering/ConnectivityProxy.cxx
index 8ac1186d2..751b3ceab 100644
--- a/vtkm/rendering/ConnectivityProxy.cxx
+++ b/vtkm/rendering/ConnectivityProxy.cxx
@@ -39,20 +39,16 @@ protected:
   bool CompositeBackground;
 
 public:
-  InternalsType(vtkm::cont::DataSet& dataSet)
+  InternalsType(const vtkm::cont::DataSet& dataSet, const std::string& fieldName)
   {
     Dataset = dataSet;
     Cells = dataSet.GetCellSet();
     Coords = dataSet.GetCoordinateSystem();
     Mode = RenderMode::Volume;
     CompositeBackground = true;
-    //
-    // Just grab a default scalar field
-    //
-
-    if (Dataset.GetNumberOfFields() > 0)
+    if (!fieldName.empty())
     {
-      this->SetScalarField(Dataset.GetField(0).GetName());
+      this->SetScalarField(fieldName);
     }
   }
 
@@ -243,8 +239,9 @@ public:
 
 
 VTKM_CONT
-ConnectivityProxy::ConnectivityProxy(vtkm::cont::DataSet& dataSet)
-  : Internals(new InternalsType(dataSet))
+ConnectivityProxy::ConnectivityProxy(const vtkm::cont::DataSet& dataSet,
+                                     const std::string& fieldName)
+  : Internals(new InternalsType(dataSet, fieldName))
 {
 }
 
@@ -259,7 +256,7 @@ ConnectivityProxy::ConnectivityProxy(const vtkm::cont::UnknownCellSet& cellset,
   dataset.AddCoordinateSystem(coords);
   dataset.AddField(scalarField);
 
-  Internals = std::shared_ptr<InternalsType>(new InternalsType(dataset));
+  Internals = std::shared_ptr<InternalsType>(new InternalsType(dataset, scalarField.GetName()));
 }
 
 VTKM_CONT
diff --git a/vtkm/rendering/ConnectivityProxy.h b/vtkm/rendering/ConnectivityProxy.h
index 8aaa55cdd..de41793d2 100644
--- a/vtkm/rendering/ConnectivityProxy.h
+++ b/vtkm/rendering/ConnectivityProxy.h
@@ -31,7 +31,7 @@ using PartialVector32 = std::vector<vtkm::rendering::raytracing::PartialComposit
 class VTKM_RENDERING_EXPORT ConnectivityProxy
 {
 public:
-  ConnectivityProxy(vtkm::cont::DataSet& dataset);
+  ConnectivityProxy(const vtkm::cont::DataSet& dataset, const std::string& fieldName);
   ConnectivityProxy(const vtkm::cont::UnknownCellSet& cellset,
                     const vtkm::cont::CoordinateSystem& coords,
                     const vtkm::cont::Field& scalarField);
diff --git a/vtkm/rendering/MapperGlyphScalar.cxx b/vtkm/rendering/MapperGlyphScalar.cxx
index c175362d5..7943daaa4 100644
--- a/vtkm/rendering/MapperGlyphScalar.cxx
+++ b/vtkm/rendering/MapperGlyphScalar.cxx
@@ -363,7 +363,7 @@ void MapperGlyphScalar::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
   vtkm::cont::DataSet processedDataSet = this->FilterPoints(cellset, coords, scalarField);
   vtkm::cont::UnknownCellSet processedCellSet = processedDataSet.GetCellSet();
   vtkm::cont::CoordinateSystem processedCoords = processedDataSet.GetCoordinateSystem();
-  vtkm::cont::Field processedField = processedDataSet.GetField(0);
+  vtkm::cont::Field processedField = processedDataSet.GetField(scalarField.GetName());
 
   if (this->ScaleByValue)
   {
diff --git a/vtkm/rendering/MapperGlyphVector.cxx b/vtkm/rendering/MapperGlyphVector.cxx
index 873d1eaec..4152608ad 100644
--- a/vtkm/rendering/MapperGlyphVector.cxx
+++ b/vtkm/rendering/MapperGlyphVector.cxx
@@ -86,7 +86,7 @@ void MapperGlyphVector::RenderCells(const vtkm::cont::UnknownCellSet& cellset,
   vtkm::cont::DataSet processedDataSet = this->FilterPoints(cellset, coords, field);
   vtkm::cont::UnknownCellSet processedCellSet = processedDataSet.GetCellSet();
   vtkm::cont::CoordinateSystem processedCoords = processedDataSet.GetCoordinateSystem();
-  vtkm::cont::Field processedField = processedDataSet.GetField(0);
+  vtkm::cont::Field processedField = processedDataSet.GetField(field.GetName());
 
   if (this->ScaleByValue)
   {
diff --git a/vtkm/rendering/MapperWireframer.cxx b/vtkm/rendering/MapperWireframer.cxx
index 9f79c3913..73b91a051 100644
--- a/vtkm/rendering/MapperWireframer.cxx
+++ b/vtkm/rendering/MapperWireframer.cxx
@@ -303,7 +303,7 @@ void MapperWireframer::RenderCells(const vtkm::cont::UnknownCellSet& inCellSet,
     externalFaces.SetPassPolyData(true);
     vtkm::cont::DataSet output = externalFaces.Execute(dataSet);
     cellSet = output.GetCellSet();
-    actualField = output.GetField(0);
+    actualField = output.GetField(inScalarField.GetName());
   }
 
   // Extract unique edges from the cell set.