Add a postprocessor to calculate the average value along the centerli…

…ne of an axisymmetric (RZ) mesh. Closes idaholab#7528.

framework/include/postprocessors/AxisymmetricCenterlineAverageValue.h

@@ -0,0 +1,41 @@
+/****************************************************************/
+/*               DO NOT MODIFY THIS HEADER                      */
+/* MOOSE - Multiphysics Object Oriented Simulation Environment  */
+/*                                                              */
+/*           (c) 2010 Battelle Energy Alliance, LLC             */
+/*                   ALL RIGHTS RESERVED                        */
+/*                                                              */
+/*          Prepared by Battelle Energy Alliance, LLC           */
+/*            Under Contract No. DE-AC07-05ID14517              */
+/*            With the U. S. Department of Energy               */
+/*                                                              */
+/*            See COPYRIGHT for full restrictions               */
+/****************************************************************/
+
+#ifndef AXISYMMETRICCENTERLINEAVERAGEVALUE_H
+#define AXISYMMETRICCENTERLINEAVERAGEVALUE_H
+
+#include "SideAverageValue.h"
+
+//Forward Declarations
+class AxisymmetricCenterlineAverageValue;
+
+template<>
+InputParameters validParams<AxisymmetricCenterlineAverageValue>();
+
+/**
+ * This postprocessor computes a line integral of the specified variable
+ * along the centerline of an axisymmetric domain.
+ */
+class AxisymmetricCenterlineAverageValue : public SideAverageValue
+{
+public:
+  AxisymmetricCenterlineAverageValue(const InputParameters & parameters);
+
+protected:
+  virtual Real computeIntegral() override;
+  virtual Real volume() override;
+  Real _volume;
+};
+
+#endif

framework/include/postprocessors/SideAverageValue.h

@@ -40,6 +40,7 @@ class SideAverageValue : public SideIntegralVariablePostprocessor
   virtual void threadJoin(const UserObject & y) override;
 
 protected:
+  virtual Real volume();
   Real _volume;
 };
 

framework/src/base/Moose.C

@@ -211,6 +211,7 @@
 #include "ElementL2Difference.h"
 #include "TimeExtremeValue.h"
 #include "RelativeSolutionDifferenceNorm.h"
+#include "AxisymmetricCenterlineAverageValue.h"
 
 // vector PPS
 #include "ConstantVectorPostprocessor.h"
@@ -624,6 +625,7 @@ registerObjects(Factory & factory)
   registerPostprocessor(ElementL2Difference);
   registerPostprocessor(TimeExtremeValue);
   registerPostprocessor(RelativeSolutionDifferenceNorm);
+  registerPostprocessor(AxisymmetricCenterlineAverageValue);
 
   // vector PPS
   registerVectorPostprocessor(ConstantVectorPostprocessor);

framework/src/postprocessors/AxisymmetricCenterlineAverageValue.C

@@ -0,0 +1,45 @@
+/****************************************************************/
+/*               DO NOT MODIFY THIS HEADER                      */
+/* MOOSE - Multiphysics Object Oriented Simulation Environment  */
+/*                                                              */
+/*           (c) 2010 Battelle Energy Alliance, LLC             */
+/*                   ALL RIGHTS RESERVED                        */
+/*                                                              */
+/*          Prepared by Battelle Energy Alliance, LLC           */
+/*            Under Contract No. DE-AC07-05ID14517              */
+/*            With the U. S. Department of Energy               */
+/*                                                              */
+/*            See COPYRIGHT for full restrictions               */
+/****************************************************************/
+
+#include "AxisymmetricCenterlineAverageValue.h"
+// libmesh includes
+#include "libmesh/quadrature.h"
+
+template<>
+InputParameters validParams<AxisymmetricCenterlineAverageValue>()
+{
+  InputParameters params = validParams<SideAverageValue>();
+  return params;
+}
+
+AxisymmetricCenterlineAverageValue::AxisymmetricCenterlineAverageValue(const InputParameters & parameters) :
+    SideAverageValue(parameters),
+    _volume(0)
+{}
+
+Real
+AxisymmetricCenterlineAverageValue::volume()
+{
+  Real volume = _current_side_elem->volume();
+  return volume;
+}
+
+Real
+AxisymmetricCenterlineAverageValue::computeIntegral()
+{
+  Real sum = 0;
+  for (_qp=0; _qp<_qrule->n_points(); _qp++)
+    sum += _JxW[_qp]*computeQpIntegral();
+  return sum;
+}

framework/src/postprocessors/SideAverageValue.C

@@ -37,7 +37,7 @@ void
 SideAverageValue::execute()
 {
   SideIntegralVariablePostprocessor::execute();
-  _volume += _current_side_volume;
+  _volume += volume();
 }
 
 Real
@@ -48,6 +48,12 @@ SideAverageValue::getValue()
   return integral / _volume;
 }
 
+Real
+SideAverageValue::volume()
+{
+  Real volume = _current_side_volume;
+  return volume;
+}
 
 void
 SideAverageValue::threadJoin(const UserObject & y)

test/tests/postprocessors/axisymmetric_centerline_average_value/axisymmetric_centerline_average_value_test.i

@@ -0,0 +1,70 @@
+[Problem]
+  coord_type = RZ
+[]
+
+[Mesh]
+  type = GeneratedMesh
+  dim = 2
+  nx = 10
+  ny = 10
+  xmin = 0
+  xmax = 2
+  ymin = 0
+  ymax = 1
+[]
+
+[Variables]
+  active = 'u'
+
+  [./u]
+    order = FIRST
+    family = LAGRANGE
+  [../]
+[]
+
+[Kernels]
+  active = 'diff'
+
+  [./diff]
+    type = Diffusion
+    variable = u
+  [../]
+[]
+
+[BCs]
+  active = 'top bottom'
+
+  [./top]
+    type = DirichletBC
+    variable = u
+    boundary = top
+    value = 0
+  [../]
+
+  [./bottom]
+    type = DirichletBC
+    variable = u
+    boundary = bottom
+    value = 1
+  [../]
+[]
+
+[Executioner]
+  type = Steady
+
+  # Preconditioned JFNK (default)
+  solve_type = 'PJFNK'
+[]
+
+[Postprocessors]
+  [./average]
+    type = AxisymmetricCenterlineAverageValue
+    boundary = left
+    variable = u
+  [../]
+[]
+
+[Outputs]
+  file_base = out
+  exodus = true
+[]

test/tests/postprocessors/axisymmetric_centerline_average_value/tests

@@ -0,0 +1,7 @@
+[Tests]
+  [./test]
+    type = 'Exodiff'
+    input = 'axisymmetric_centerline_average_value_test.i'
+    exodiff = 'out.e'
+  [../]
+[]