From 9aafb0d217c90f187d7bad29ecd1f5fb765db808 Mon Sep 17 00:00:00 2001 From: Yaqi Wang Date: Thu, 18 Apr 2019 23:06:07 -0600 Subject: [PATCH] a compilable stage with variable, coupleable, assembly and systems extended to array variable #6881 --- framework/include/base/Assembly.h | 26 +- framework/include/interfaces/Coupleable.h | 184 ++++- framework/include/problems/DisplacedProblem.h | 7 + framework/include/problems/FEProblemBase.h | 7 + framework/include/problems/SubProblem.h | 12 +- framework/include/systems/SystemBase.h | 17 +- framework/include/utils/Conversion.h | 3 + framework/include/utils/MooseTypes.h | 173 +++-- .../include/variables/MooseVariableBase.h | 20 +- .../include/variables/MooseVariableData.h | 131 ++-- framework/include/variables/MooseVariableFE.h | 148 ++-- .../include/variables/MooseVariableFEBase.h | 132 +--- .../include/variables/VariableWarehouse.h | 15 +- framework/src/interfaces/Coupleable.C | 353 +++++++++- framework/src/markers/Marker.C | 2 +- framework/src/outputs/AdvancedOutput.C | 45 +- .../src/postprocessors/NodalVariableValue.C | 7 +- framework/src/problems/DisplacedProblem.C | 19 + framework/src/problems/FEProblemBase.C | 61 +- framework/src/problems/SubProblem.C | 15 +- framework/src/systems/SystemBase.C | 65 +- framework/src/utils/Conversion.C | 19 + framework/src/variables/MooseVariableBase.C | 8 +- framework/src/variables/MooseVariableData.C | 663 +++++++++++++++++- framework/src/variables/MooseVariableFE.C | 137 +++- framework/src/variables/MooseVariableFEBase.C | 5 +- .../src/variables/MooseVariableInterface.C | 1 + framework/src/variables/VariableWarehouse.C | 42 +- .../ElementValueSampler.C | 2 +- .../vectorpostprocessors/NodalValueSampler.C | 4 +- test/tests/misc/check_error/tests | 2 +- 31 files changed, 1866 insertions(+), 459 deletions(-) diff --git a/framework/include/base/Assembly.h b/framework/include/base/Assembly.h index 919c92ca9527..69b3817e12cd 100644 --- a/framework/include/base/Assembly.h +++ b/framework/include/base/Assembly.h @@ -52,6 +52,7 @@ class MooseVariableFE; class MooseVariableScalar; typedef MooseVariableFE MooseVariable; typedef MooseVariableFE VectorMooseVariable; +typedef MooseVariableFE ArrayMooseVariable; class XFEMInterface; class SubProblem; @@ -905,6 +906,7 @@ class Assembly return _second_phi_face_neighbor; } + // Writeable references with vector variable VectorVariablePhiValue & phi(const VectorMooseVariable &) { return _vector_phi; } VectorVariablePhiGradient & gradPhi(const VectorMooseVariable &) { return _vector_grad_phi; } VectorVariablePhiSecond & secondPhi(const VectorMooseVariable &) { return _vector_second_phi; } @@ -934,7 +936,6 @@ class Assembly { return _vector_curl_phi_neighbor; } - VectorVariablePhiValue & phiFaceNeighbor(const VectorMooseVariable &) { return _vector_phi_face_neighbor; @@ -952,6 +953,29 @@ class Assembly return _vector_curl_phi_face_neighbor; } + // Writeable references with array variable + VariablePhiValue & phi(const ArrayMooseVariable &) { return _phi; } + VariablePhiGradient & gradPhi(const ArrayMooseVariable &) { return _grad_phi; } + VariablePhiSecond & secondPhi(const ArrayMooseVariable &) { return _second_phi; } + + VariablePhiValue & phiFace(const ArrayMooseVariable &) { return _phi_face; } + VariablePhiGradient & gradPhiFace(const ArrayMooseVariable &) { return _grad_phi_face; } + VariablePhiSecond & secondPhiFace(const ArrayMooseVariable &) { return _second_phi_face; } + + VariablePhiValue & phiNeighbor(const ArrayMooseVariable &) { return _phi_neighbor; } + VariablePhiGradient & gradPhiNeighbor(const ArrayMooseVariable &) { return _grad_phi_neighbor; } + VariablePhiSecond & secondPhiNeighbor(const ArrayMooseVariable &) { return _second_phi_neighbor; } + + VariablePhiValue & phiFaceNeighbor(const ArrayMooseVariable &) { return _phi_face_neighbor; } + VariablePhiGradient & gradPhiFaceNeighbor(const ArrayMooseVariable &) + { + return _grad_phi_face_neighbor; + } + VariablePhiSecond & secondPhiFaceNeighbor(const ArrayMooseVariable &) + { + return _second_phi_face_neighbor; + } + template const typename OutputTools::VariablePhiValue & fePhi(FEType type) const { diff --git a/framework/include/interfaces/Coupleable.h b/framework/include/interfaces/Coupleable.h index b637c97b7a6d..dcc49e53ecb5 100644 --- a/framework/include/interfaces/Coupleable.h +++ b/framework/include/interfaces/Coupleable.h @@ -110,6 +110,15 @@ class Coupleable return _coupled_vector_moose_vars; } + /** + * Get the list of array coupled variables + * @return The list of array coupled variables + */ + const std::vector & getCoupledArratMooseVars() const + { + return _coupled_array_moose_vars; + } + void addFEVariableCoupleableVectorTag(TagID tag) { _fe_coupleable_vector_tags.insert(tag); } void addFEVariableCoupleableMatrixTag(TagID tag) { _fe_coupleable_matrix_tags.insert(tag); } @@ -119,6 +128,12 @@ class Coupleable std::set & getFEVariableCoupleableMatrixTags() { return _fe_coupleable_matrix_tags; } protected: + /** + * A call-back function provided by the derived object for actions before coupling a variable + * with functions such as coupledValue. + */ + virtual void coupledCallback(const std::string & /*var_name*/, bool /*is_old*/) {} + /** * Returns true if a variables has been coupled as name. * @param var_name The name the kernel wants to refer to the variable as. @@ -134,8 +149,6 @@ class Coupleable */ unsigned int coupledComponents(const std::string & var_name); - virtual void coupledCallback(const std::string & var_name, bool is_old); - /** * Returns the index for a coupled variable by name * @param var_name Name of coupled variable @@ -208,6 +221,16 @@ class Coupleable virtual const VectorVariableValue & coupledVectorValue(const std::string & var_name, unsigned int comp = 0); + /** + * Returns value of a coupled array variable + * @param var_name Name of coupled vector variable + * @param comp Component number for vector of coupled vector variables + * @return Reference to a ArrayVariableValue for the coupled vector variable + * @see ArrayKernel::_u + */ + virtual const ArrayVariableValue & coupledArrayValue(const std::string & var_name, + unsigned int comp = 0); + /** * Returns a *writable* reference to a coupled variable. Note: you * should not have to use this very often (use coupledValue() @@ -254,7 +277,7 @@ class Coupleable * @param var_name Name of coupled variable * @param comp Component number for vector of coupled variables * @return Reference to a VectorVariableValue containing the old value of the coupled variable - * @see Kernel::_u_old + * @see VectorKernel::_u_old */ virtual const VectorVariableValue & coupledVectorValueOld(const std::string & var_name, unsigned int comp = 0); @@ -264,11 +287,31 @@ class Coupleable * @param var_name Name of coupled variable * @param comp Component number for vector of coupled variables * @return Reference to a VectorVariableValue containing the older value of the coupled variable - * @see Kernel::_u_older + * @see VectorKernel::_u_older */ virtual const VectorVariableValue & coupledVectorValueOlder(const std::string & var_name, unsigned int comp = 0); + /** + * Returns an old value from previous time step of a coupled array variable + * @param var_name Name of coupled variable + * @param comp Component number for vector of coupled variables + * @return Reference to a ArrayVariableValue containing the old value of the coupled variable + * @see ArrayKernel::_u_old + */ + virtual const ArrayVariableValue & coupledArrayValueOld(const std::string & var_name, + unsigned int comp = 0); + + /** + * Returns an old value from two time steps previous of a coupled array variable + * @param var_name Name of coupled variable + * @param comp Component number for vector of coupled variables + * @return Reference to a ArrayVariableValue containing the older value of the coupled variable + * @see ArrayKernel::_u_older + */ + virtual const ArrayVariableValue & coupledArrayValueOlder(const std::string & var_name, + unsigned int comp = 0); + /** * Returns gradient of a coupled variable * @param var_name Name of coupled variable @@ -401,6 +444,36 @@ class Coupleable virtual const VectorVariableGradient & coupledVectorGradientOlder(const std::string & var_name, unsigned int comp = 0); + /** + * Returns gradient of a coupled array variable + * @param var_name Name of coupled array variable + * @param comp Component number for vector of coupled array variables + * @return Reference to a VectorVariableGradient containing the gradient of the coupled array + * variable + */ + virtual const ArrayVariableGradient & coupledArrayGradient(const std::string & var_name, + unsigned int comp = 0); + + /** + * Returns an old gradient from previous time step of a coupled array variable + * @param var_name Name of coupled array variable + * @param comp Component number for vector of coupled array variables + * @return Reference to a VectorVariableGradient containing the old gradient of the coupled array + * variable + */ + virtual const ArrayVariableGradient & coupledArrayGradientOld(const std::string & var_name, + unsigned int comp = 0); + + /** + * Returns an old gradient from two time steps previous of a coupled array variable + * @param var_name Name of coupled array variable + * @param comp Component number for vector of coupled array variables + * @return Reference to a ArrayVariableGradient containing the older gradient of the coupled + * array variable + */ + virtual const ArrayVariableGradient & coupledArrayGradientOlder(const std::string & var_name, + unsigned int comp = 0); + /** * Returns curl of a coupled variable * @param var_name Name of coupled variable @@ -566,6 +639,46 @@ class Coupleable virtual const VectorVariableValue & coupledVectorDotDotOld(const std::string & var_name, unsigned int comp = 0); + /** + * Time derivative of a coupled array variable + * @param var_name Name of coupled array variable + * @param comp Component number for vector of coupled array variables + * @return Reference to a ArrayVariableValue containing the time derivative of the coupled + * variable + */ + virtual const ArrayVariableValue & coupledArrayDot(const std::string & var_name, + unsigned int comp = 0); + + /** + * Second time derivative of a coupled array variable + * @param var_name Name of coupled array variable + * @param comp Component number for vector of coupled array variables + * @return Reference to a ArrayVariableValue containing the time derivative of the coupled + * variable + */ + virtual const ArrayVariableValue & coupledArrayDotDot(const std::string & var_name, + unsigned int comp = 0); + + /** + * Old time derivative of a coupled array variable + * @param var_name Name of coupled array variable + * @param comp Component number for vector of coupled array variables + * @return Reference to a ArrayVariableValue containing the time derivative of the coupled + * variable + */ + virtual const ArrayVariableValue & coupledArrayDotOld(const std::string & var_name, + unsigned int comp = 0); + + /** + * Old second time derivative of a coupled array variable + * @param var_name Name of coupled array variable + * @param comp Component number for vector of coupled array variables + * @return Reference to a ArrayVariableValue containing the time derivative of the coupled + * variable + */ + virtual const ArrayVariableValue & coupledArrayDotDotOld(const std::string & var_name, + unsigned int comp = 0); + /** * Time derivative of a coupled variable with respect to the coefficients * @param var_name Name of coupled variable @@ -641,12 +754,6 @@ class Coupleable template const T & coupledNodalDot(const std::string & var_name, unsigned int comp = 0); - /** - * Get nodal default value - */ - template - const T & getNodalDefaultValue(const std::string & var_name, unsigned int comp = 0); - /** * Nodal values of second time derivative of a coupled variable * @param var_name Name of coupled variable @@ -745,6 +852,9 @@ class Coupleable /// Vector of vector coupled variables std::vector _coupled_vector_moose_vars; + /// Vector of array coupled variables + std::vector _coupled_array_moose_vars; + /// True if we provide coupling to nodal values bool _c_nodal; @@ -763,6 +873,9 @@ class Coupleable /// Will hold the default value for optional vector coupled variables. std::map _default_vector_value; + /// Will hold the default value for optional array coupled variables. + std::map _default_array_value; + /// Will hold the default value for optional vector coupled variables for automatic differentiation. std::map *> _ad_default_vector_value; @@ -817,6 +930,18 @@ class Coupleable /// This will always be zero because the default values for optionally coupled variables is always constant VectorVariableCurl _default_vector_curl; + /** + * This will always be zero because the default values for optionally coupled variables is always + * constant and this is used for time derivative info + */ + ArrayVariableValue _default_array_value_zero; + + /// This will always be zero because the default values for optionally coupled variables is always constant + ArrayVariableGradient _default_array_gradient; + + /// This will always be zero because the default values for optionally coupled variables is always constant + ArrayVariableCurl _default_array_curl; + /** * Check that the right kind of variable is being coupled in * @@ -854,6 +979,14 @@ class Coupleable */ VectorMooseVariable * getVectorVar(const std::string & var_name, unsigned int comp); + /** + * Extract pointer to a coupled array variable + * @param var_name Name of parameter desired + * @param comp Component number of multiple coupled variables + * @return Pointer to the desired variable + */ + ArrayMooseVariable * getArrayVar(const std::string & var_name, unsigned int comp); + /** * Checks to make sure that the current Executioner has set "_is_transient" when old/older values * are coupled in. @@ -865,15 +998,6 @@ class Coupleable /// Whether or not this object is a "neighbor" object: ie all of it's coupled values should be neighbor values bool _coupleable_neighbor; -private: - /** - * Helper method to return (and insert if necessary) the default value - * for an uncoupled variable. - * @param var_name the name of the variable for which to retrieve a default value - * @return a pointer to the associated VariableValue. - */ - VariableValue * getDefaultValue(const std::string & var_name, unsigned int comp); - public: /** * Helper method to return (and insert if necessary) the default value for Automatic @@ -921,6 +1045,14 @@ class Coupleable ADVariableSecond & getADDefaultSecond(); private: + /** + * Helper method to return (and insert if necessary) the default value + * for an uncoupled variable. + * @param var_name the name of the variable for which to retrieve a default value + * @return a pointer to the associated VariableValue. + */ + VariableValue * getDefaultValue(const std::string & var_name, unsigned int comp); + /** * Helper method to return (and insert if necessary) the default value * for an uncoupled vector variable. @@ -929,6 +1061,20 @@ class Coupleable */ VectorVariableValue * getDefaultVectorValue(const std::string & var_name); + /** + * Helper method to return (and insert if necessary) the default value + * for an uncoupled array variable. + * @param var_name the name of the vector variable for which to retrieve a default value + * @return a pointer to the associated VectorVariableValue. + */ + ArrayVariableValue * getDefaultArrayValue(const std::string & var_name); + + /** + * Get nodal default value + */ + template + const T & getNodalDefaultValue(const std::string & var_name, unsigned int comp = 0); + /// Maximum qps for any element in this system unsigned int _coupleable_max_qps; diff --git a/framework/include/problems/DisplacedProblem.h b/framework/include/problems/DisplacedProblem.h index 27c36d981a04..04ae35d2443e 100644 --- a/framework/include/problems/DisplacedProblem.h +++ b/framework/include/problems/DisplacedProblem.h @@ -124,6 +124,8 @@ class DisplacedProblem : public SubProblem virtual MooseVariable & getStandardVariable(THREAD_ID tid, const std::string & var_name) override; virtual VectorMooseVariable & getVectorVariable(THREAD_ID tid, const std::string & var_name) override; + virtual ArrayMooseVariable & getArrayVariable(THREAD_ID tid, + const std::string & var_name) override; virtual bool hasScalarVariable(const std::string & var_name) const override; virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, const std::string & var_name) override; @@ -133,6 +135,11 @@ class DisplacedProblem : public SubProblem const FEType & type, Real scale_factor, const std::set * const active_subdomains = NULL); + virtual void addArrayVariable(const std::string & var_name, + const FEType & type, + unsigned int components, + const std::vector & scale_factor, + const std::set * const active_subdomains = NULL); virtual void addAuxVariable(const std::string & var_name, const FEType & type, const std::set * const active_subdomains = NULL); diff --git a/framework/include/problems/FEProblemBase.h b/framework/include/problems/FEProblemBase.h index 7322a57687e8..6ea62c9d15a8 100644 --- a/framework/include/problems/FEProblemBase.h +++ b/framework/include/problems/FEProblemBase.h @@ -247,6 +247,8 @@ class FEProblemBase : public SubProblem, public Restartable virtual MooseVariable & getStandardVariable(THREAD_ID tid, const std::string & var_name) override; virtual VectorMooseVariable & getVectorVariable(THREAD_ID tid, const std::string & var_name) override; + virtual ArrayMooseVariable & getArrayVariable(THREAD_ID tid, + const std::string & var_name) override; virtual bool hasScalarVariable(const std::string & var_name) const override; virtual MooseVariableScalar & getScalarVariable(THREAD_ID tid, @@ -590,6 +592,11 @@ class FEProblemBase : public SubProblem, public Restartable const FEType & type, Real scale_factor, const std::set * const active_subdomains = NULL); + virtual void addArrayVariable(const std::string & var_name, + const FEType & type, + unsigned int components, + const std::vector & scale_factor, + const std::set * const active_subdomains = NULL); virtual void addScalarVariable(const std::string & var_name, Order order, Real scale_factor = 1., diff --git a/framework/include/problems/SubProblem.h b/framework/include/problems/SubProblem.h index 00f02c8fee68..d61230a68675 100644 --- a/framework/include/problems/SubProblem.h +++ b/framework/include/problems/SubProblem.h @@ -33,6 +33,7 @@ template class MooseVariableFE; typedef MooseVariableFE MooseVariable; typedef MooseVariableFE VectorMooseVariable; +typedef MooseVariableFE ArrayMooseVariable; class RestartableDataValue; class SystemBase; @@ -161,7 +162,7 @@ class SubProblem : public Problem */ virtual std::map & getMatrixTags() { return _matrix_tag_name_to_tag_id; } - // Variables ///// + /// Whether or not this problem has the variable virtual bool hasVariable(const std::string & var_name) const = 0; /** @@ -185,6 +186,15 @@ class SubProblem : public Problem /// Returns the variable reference for requested VectorMooseVariable which may be in any system virtual VectorMooseVariable & getVectorVariable(THREAD_ID tid, const std::string & var_name) = 0; + /// Returns the variable reference for requested ArrayMooseVariable which may be in any system + virtual ArrayMooseVariable & getArrayVariable(THREAD_ID tid, const std::string & var_name) = 0; + + /// Returns the variable name of a component of an array variable + static NonlinearVariableName arrayVariableComponent(const std::string & var_name, unsigned int i) + { + return var_name + "_" + std::to_string(i); + } + /// Returns a Boolean indicating whether any system contains a variable with the name provided virtual bool hasScalarVariable(const std::string & var_name) const = 0; diff --git a/framework/include/systems/SystemBase.h b/framework/include/systems/SystemBase.h index 25275f69988e..6a8402b9ed2f 100644 --- a/framework/include/systems/SystemBase.h +++ b/framework/include/systems/SystemBase.h @@ -361,7 +361,22 @@ class SystemBase : public libMesh::ParallelObject virtual void addVariable(const std::string & var_name, const FEType & type, Real scale_factor, - const std::set * const active_subdomains = NULL); + const std::set * const active_subdomains = nullptr); + + /** + * Adds an array variable to the system + * + * @param var_name Name of the array variable + * @param type FE type of the array variable + * @param components Number of components for this array variable + * @param scale_factor The scaling factors for the array variable + * @param active_subdomains A list of subdomain ids this array variable is active on + */ + virtual void addArrayVariable(const std::string & var_name, + const FEType & type, + unsigned int components, + const std::vector & scale_factor, + const std::set * const active_subdomains = nullptr); ///@{ /** diff --git a/framework/include/utils/Conversion.h b/framework/include/utils/Conversion.h index 83626cfe2f04..c8fb2493e093 100644 --- a/framework/include/utils/Conversion.h +++ b/framework/include/utils/Conversion.h @@ -67,6 +67,9 @@ stringify(const T & t) /// Convert solve type into human readable string std::string stringify(const SolveType & t); +/// Convert variable field type into human readable string +std::string stringify(const VarFieldType & t); + /// Add no-op stringify if the argument already is a string (must use overloading) std::string stringify(const std::string & s); diff --git a/framework/include/utils/MooseTypes.h b/framework/include/utils/MooseTypes.h index 11e207adbe66..fb7dcb1a0a83 100644 --- a/framework/include/utils/MooseTypes.h +++ b/framework/include/utils/MooseTypes.h @@ -22,6 +22,8 @@ // BOOST include #include "bitmask_operators.h" +#include "Eigen/Core" + #include "libmesh/tensor_tools.h" #include @@ -126,6 +128,9 @@ namespace libMesh template class VectorValue; typedef VectorValue RealVectorValue; +typedef Eigen::Array RealArrayValue; +typedef Eigen::Array RealVectorArrayValue; +typedef Eigen::Array RealTensorArrayValue; template class TypeVector; template @@ -136,6 +141,27 @@ class TypeTensor; template class TypeNTensor; class Point; + +namespace TensorTools +{ +template <> +struct IncrementRank> +{ + typedef Eigen::Array type; +}; + +template <> +struct IncrementRank> +{ + typedef Eigen::Array type; +}; + +template <> +struct DecrementRank> +{ + typedef Eigen::Array type; +}; +} } /** @@ -165,32 +191,106 @@ typedef unsigned int PerfID; typedef StoredRange::iterator, dof_id_type> NodeIdRange; typedef StoredRange::iterator, const Elem *> ConstElemPointerRange; +enum ComputeStage +{ + RESIDUAL, + JACOBIAN +}; + +namespace Moose +{ +template +struct RealType +{ + typedef Real type; +}; +template <> +struct RealType +{ + typedef DualReal type; +}; + +template +struct ValueType +{ + typedef typename RealType::type type; +}; + +template +struct ValueType +{ + typedef typename RealType::type type; +}; + +template class W> +struct ValueType, compute_stage> +{ + typedef W::type> type; +}; + +template +struct ShapeType +{ + typedef OutputType type; +}; +template <> +struct ShapeType> +{ + typedef Real type; +}; + +template +struct DOFType +{ + typedef OutputType type; +}; +template <> +struct DOFType +{ + typedef Real type; +}; +// not using map for now +// template <> +// struct DOFType +//{ +// typedef Eigen::Map type; +//}; +} // MOOSE + template struct OutputTools { - typedef OutputType OutputShape; - typedef OutputType OutputValue; - typedef typename TensorTools::IncrementRank::type OutputGradient; + typedef typename TensorTools::IncrementRank::type OutputGradient; typedef typename TensorTools::IncrementRank::type OutputSecond; - typedef typename TensorTools::DecrementRank::type OutputDivergence; + typedef typename TensorTools::DecrementRank::type OutputDivergence; - typedef MooseArray VariableValue; + typedef MooseArray VariableValue; typedef MooseArray VariableGradient; typedef MooseArray VariableSecond; - typedef MooseArray VariableCurl; + typedef MooseArray VariableCurl; typedef MooseArray VariableDivergence; + typedef typename Moose::ShapeType::type OutputShape; + typedef typename TensorTools::IncrementRank::type OutputShapeGradient; + typedef typename TensorTools::IncrementRank::type OutputShapeSecond; + typedef typename TensorTools::DecrementRank::type OutputShapeDivergence; + typedef MooseArray> VariablePhiValue; - typedef MooseArray> VariablePhiGradient; - typedef MooseArray> VariablePhiSecond; + typedef MooseArray> VariablePhiGradient; + typedef MooseArray> VariablePhiSecond; typedef MooseArray> VariablePhiCurl; - typedef MooseArray> VariablePhiDivergence; + typedef MooseArray> VariablePhiDivergence; typedef MooseArray> VariableTestValue; - typedef MooseArray> VariableTestGradient; - typedef MooseArray> VariableTestSecond; + typedef MooseArray> VariableTestGradient; + typedef MooseArray> VariableTestSecond; typedef MooseArray> VariableTestCurl; - typedef MooseArray> VariableTestDivergence; + typedef MooseArray> VariableTestDivergence; + + // DoF value type for the template class OutputType + typedef typename Moose::DOFType::type OutputData; + typedef MooseArray DoFValue; + typedef OutputType OutputValue; }; // types for standard variable @@ -221,6 +321,20 @@ typedef typename OutputTools::VariableTestGradient VectorVariab typedef typename OutputTools::VariableTestSecond VectorVariableTestSecond; typedef typename OutputTools::VariableTestCurl VectorVariableTestCurl; +// types for array variable +typedef typename OutputTools::VariableValue ArrayVariableValue; +typedef typename OutputTools::VariableGradient ArrayVariableGradient; +typedef typename OutputTools::VariableSecond ArrayVariableSecond; +typedef typename OutputTools::VariableCurl ArrayVariableCurl; +typedef typename OutputTools::VariablePhiValue ArrayVariablePhiValue; +typedef typename OutputTools::VariablePhiGradient ArrayVariablePhiGradient; +typedef typename OutputTools::VariablePhiSecond ArrayVariablePhiSecond; +typedef typename OutputTools::VariablePhiCurl ArrayVariablePhiCurl; +typedef typename OutputTools::VariableTestValue ArrayVariableTestValue; +typedef typename OutputTools::VariableTestGradient ArrayVariableTestGradient; +typedef typename OutputTools::VariableTestSecond ArrayVariableTestSecond; +typedef typename OutputTools::VariableTestCurl ArrayVariableTestCurl; + template