From 86f3ffa76e5607a52578837e8dd573ffa14368b8 Mon Sep 17 00:00:00 2001
From: Matthew Letter <mletter@sanida.gov>
Date: Tue, 15 May 2018 16:47:22 -0600
Subject: [PATCH] Updated gradient scalar output to use new execution obejct

gradient scalar output now has a prepare for execution function for creating the execution object based on the device adaptor.
---
 vtkm/worklet/Gradient.h                |  23 ++--
 vtkm/worklet/gradient/GradientOutput.h | 153 +++++++++++++++++++------
 2 files changed, 128 insertions(+), 48 deletions(-)

diff --git a/vtkm/worklet/Gradient.h b/vtkm/worklet/Gradient.h
index fd888d7d7..e003cf87e 100644
--- a/vtkm/worklet/Gradient.h
+++ b/vtkm/worklet/Gradient.h
@@ -129,7 +129,7 @@ struct GradientOutputFields : public vtkm::cont::ExecutionObjectBase
   template <typename DeviceAdapter>
   struct ExecutionTypes
   {
-    using Portal = vtkm::exec::GradientOutput<T, DeviceAdapter>;
+    using Portal = vtkm::exec::GradientOutput<T>;
   };
 
   GradientOutputFields()
@@ -181,18 +181,17 @@ struct GradientOutputFields : public vtkm::cont::ExecutionObjectBase
   bool GetComputeGradient() const { return StoreGradient; }
 
   //todo fix this for scalar
-  template <typename DeviceAdapter>
-  vtkm::exec::GradientOutput<T, DeviceAdapter> PrepareForOutput(vtkm::Id size, DeviceAdapter)
+  vtkm::exec::GradientOutput<T> PrepareForOutput(vtkm::Id size)
   {
-    vtkm::exec::GradientOutput<T, DeviceAdapter> portal(this->StoreGradient,
-                                                        this->ComputeDivergence,
-                                                        this->ComputeVorticity,
-                                                        this->ComputeQCriterion,
-                                                        this->Gradient,
-                                                        this->Divergence,
-                                                        this->Vorticity,
-                                                        this->QCriterion,
-                                                        size);
+    vtkm::exec::GradientOutput<T> portal(this->StoreGradient,
+                                         this->ComputeDivergence,
+                                         this->ComputeVorticity,
+                                         this->ComputeQCriterion,
+                                         this->Gradient,
+                                         this->Divergence,
+                                         this->Vorticity,
+                                         this->QCriterion,
+                                         size);
     return portal;
   }
 
diff --git a/vtkm/worklet/gradient/GradientOutput.h b/vtkm/worklet/gradient/GradientOutput.h
index cdaa544b7..dedc468aa 100644
--- a/vtkm/worklet/gradient/GradientOutput.h
+++ b/vtkm/worklet/gradient/GradientOutput.h
@@ -37,9 +37,8 @@ namespace vtkm
 {
 namespace exec
 {
-
 template <typename T, typename DeviceAdapter>
-struct GradientScalarOutput : public vtkm::cont::ExecutionObjectBase
+struct GradientScalarOutputExecutionObject
 {
   using ValueType = vtkm::Vec<T, 3>;
   using BaseTType = typename vtkm::BaseComponent<T>::Type;
@@ -51,17 +50,9 @@ struct GradientScalarOutput : public vtkm::cont::ExecutionObjectBase
     using Portal = typename ExecutionTypes::Portal;
   };
 
-  GradientScalarOutput() = default;
+  GradientScalarOutputExecutionObject() = default;
 
-  GradientScalarOutput(bool,
-                       bool,
-                       bool,
-                       bool,
-                       vtkm::cont::ArrayHandle<ValueType>& gradient,
-                       vtkm::cont::ArrayHandle<BaseTType>&,
-                       vtkm::cont::ArrayHandle<vtkm::Vec<BaseTType, 3>>&,
-                       vtkm::cont::ArrayHandle<BaseTType>&,
-                       vtkm::Id size)
+  GradientScalarOutputExecutionObject(vtkm::cont::ArrayHandle<ValueType> gradient, vtkm::Id size)
   {
     this->GradientPortal = gradient.PrepareForOutput(size, DeviceAdapter());
   }
@@ -76,8 +67,40 @@ struct GradientScalarOutput : public vtkm::cont::ExecutionObjectBase
   typename PortalTypes::Portal GradientPortal;
 };
 
+template <typename T>
+struct GradientScalarOutput : public vtkm::cont::ExecutionObjectBase
+{
+  using ValueType = vtkm::Vec<T, 3>;
+  using BaseTType = typename vtkm::BaseComponent<T>::Type;
+  template <typename Device>
+
+  VTKM_CONT vtkm::exec::GradientScalarOutputExecutionObject<T, Device> PrepareForExecution(
+    Device) const
+  {
+    return vtkm::exec::GradientScalarOutputExecutionObject<T, Device>(this->Gradient, this->Size);
+  }
+
+  GradientScalarOutput() = default;
+
+  GradientScalarOutput(bool,
+                       bool,
+                       bool,
+                       bool,
+                       vtkm::cont::ArrayHandle<ValueType>& gradient,
+                       vtkm::cont::ArrayHandle<BaseTType>&,
+                       vtkm::cont::ArrayHandle<vtkm::Vec<BaseTType, 3>>&,
+                       vtkm::cont::ArrayHandle<BaseTType>&,
+                       vtkm::Id size)
+    : Size(size)
+    , Gradient(gradient)
+  {
+  }
+  vtkm::Id Size;
+  vtkm::cont::ArrayHandle<ValueType> Gradient;
+};
+
 template <typename T, typename DeviceAdapter>
-struct GradientVecOutput : public vtkm::cont::ExecutionObjectBase
+struct GradientVecOutputExecutionObject
 {
   using ValueType = vtkm::Vec<T, 3>;
   using BaseTType = typename vtkm::BaseComponent<T>::Type;
@@ -90,17 +113,17 @@ struct GradientVecOutput : public vtkm::cont::ExecutionObjectBase
     using Portal = typename ExecutionTypes::Portal;
   };
 
-  GradientVecOutput() = default;
+  GradientVecOutputExecutionObject() = default;
 
-  GradientVecOutput(bool g,
-                    bool d,
-                    bool v,
-                    bool q,
-                    vtkm::cont::ArrayHandle<ValueType>& gradient,
-                    vtkm::cont::ArrayHandle<BaseTType>& divergence,
-                    vtkm::cont::ArrayHandle<vtkm::Vec<BaseTType, 3>>& vorticity,
-                    vtkm::cont::ArrayHandle<BaseTType>& qcriterion,
-                    vtkm::Id size)
+  GradientVecOutputExecutionObject(bool g,
+                                   bool d,
+                                   bool v,
+                                   bool q,
+                                   vtkm::cont::ArrayHandle<ValueType> gradient,
+                                   vtkm::cont::ArrayHandle<BaseTType> divergence,
+                                   vtkm::cont::ArrayHandle<vtkm::Vec<BaseTType, 3>> vorticity,
+                                   vtkm::cont::ArrayHandle<BaseTType> qcriterion,
+                                   vtkm::Id size)
   {
     this->SetGradient = g;
     this->SetDivergence = d;
@@ -168,24 +191,79 @@ struct GradientVecOutput : public vtkm::cont::ExecutionObjectBase
   typename PortalTypes<BaseTType>::Portal QCriterionPortal;
 };
 
-template <typename T, typename DeviceAdapter>
-struct GradientOutput : public GradientScalarOutput<T, DeviceAdapter>
+template <typename T>
+struct GradientVecOutput : public vtkm::cont::ExecutionObjectBase
 {
-  using GradientScalarOutput<T, DeviceAdapter>::GradientScalarOutput;
+  using ValueType = vtkm::Vec<T, 3>;
+  using BaseTType = typename vtkm::BaseComponent<T>::Type;
+
+  template <typename Device>
+  VTKM_CONT vtkm::exec::GradientVecOutputExecutionObject<T, Device> PrepareForExecution(
+    Device) const
+  {
+    return vtkm::exec::GradientVecOutputExecutionObject<T, Device>(this->G,
+                                                                   this->D,
+                                                                   this->V,
+                                                                   this->Q,
+                                                                   this->Gradient,
+                                                                   this->Divergence,
+                                                                   this->Vorticity,
+                                                                   this->Qcriterion,
+                                                                   this->Size);
+  }
+
+  GradientVecOutput() = default;
+
+  GradientVecOutput(bool g,
+                    bool d,
+                    bool v,
+                    bool q,
+                    vtkm::cont::ArrayHandle<ValueType>& gradient,
+                    vtkm::cont::ArrayHandle<BaseTType>& divergence,
+                    vtkm::cont::ArrayHandle<vtkm::Vec<BaseTType, 3>>& vorticity,
+                    vtkm::cont::ArrayHandle<BaseTType>& qcriterion,
+                    vtkm::Id size)
+  {
+    this->G = g;
+    this->D = d;
+    this->V = v;
+    this->Q = q;
+    this->Gradient = gradient;
+    this->Divergence = divergence;
+    this->Vorticity = vorticity;
+    this->Qcriterion = qcriterion;
+    this->Size = size;
+  }
+
+  bool G;
+  bool D;
+  bool V;
+  bool Q;
+  vtkm::cont::ArrayHandle<ValueType> Gradient;
+  vtkm::cont::ArrayHandle<BaseTType> Divergence;
+  vtkm::cont::ArrayHandle<vtkm::Vec<BaseTType, 3>> Vorticity;
+  vtkm::cont::ArrayHandle<BaseTType> Qcriterion;
+  vtkm::Id Size;
 };
 
-template <typename DeviceAdapter>
-struct GradientOutput<vtkm::Vec<vtkm::Float32, 3>, DeviceAdapter>
-  : public GradientVecOutput<vtkm::Vec<vtkm::Float32, 3>, DeviceAdapter>
+template <typename T>
+struct GradientOutput : public GradientScalarOutput<T>
 {
-  using GradientVecOutput<vtkm::Vec<vtkm::Float32, 3>, DeviceAdapter>::GradientVecOutput;
+  using GradientScalarOutput<T>::GradientScalarOutput;
 };
 
-template <typename DeviceAdapter>
-struct GradientOutput<vtkm::Vec<vtkm::Float64, 3>, DeviceAdapter>
-  : public GradientVecOutput<vtkm::Vec<vtkm::Float64, 3>, DeviceAdapter>
+template <>
+struct GradientOutput<vtkm::Vec<vtkm::Float32, 3>>
+  : public GradientVecOutput<vtkm::Vec<vtkm::Float32, 3>>
 {
-  using GradientVecOutput<vtkm::Vec<vtkm::Float64, 3>, DeviceAdapter>::GradientVecOutput;
+  using GradientVecOutput<vtkm::Vec<vtkm::Float32, 3>>::GradientVecOutput;
+};
+
+template <>
+struct GradientOutput<vtkm::Vec<vtkm::Float64, 3>>
+  : public GradientVecOutput<vtkm::Vec<vtkm::Float64, 3>>
+{
+  using GradientVecOutput<vtkm::Vec<vtkm::Float64, 3>>::GradientVecOutput;
 };
 }
 } // namespace vtkm::exec
@@ -210,7 +288,9 @@ struct TransportTagGradientOut
 template <typename ContObjectType, typename Device>
 struct Transport<vtkm::cont::arg::TransportTagGradientOut, ContObjectType, Device>
 {
-  using ExecObjectType = vtkm::exec::GradientOutput<typename ContObjectType::ValueType, Device>;
+  using ExecObjectFacotryType = vtkm::exec::GradientOutput<typename ContObjectType::ValueType>;
+  using ExecObjectType =
+    decltype(std::declval<ExecObjectFacotryType>().PrepareForExecution(Device()));
 
   template <typename InputDomainType>
   VTKM_CONT ExecObjectType operator()(ContObjectType object,
@@ -218,7 +298,8 @@ struct Transport<vtkm::cont::arg::TransportTagGradientOut, ContObjectType, Devic
                                       vtkm::Id vtkmNotUsed(inputRange),
                                       vtkm::Id outputRange) const
   {
-    return object.PrepareForOutput(outputRange, Device());
+    ExecObjectFacotryType ExecutionObjectFacotry = object.PrepareForOutput(outputRange);
+    return ExecutionObjectFacotry.PrepareForExecution(Device());
   }
 };
 }