Add tests #30655

Author: NamjaeChoi

test/include/kokkos/auxkernels/KokkosCoupledAux.h

@@ -0,0 +1,52 @@
+//* This file is part of the MOOSE framework
+//* https://mooseframework.inl.gov
+//*
+//* All rights reserved, see COPYRIGHT for full restrictions
+//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
+//*
+//* Licensed under LGPL 2.1, please see LICENSE for details
+//* https://www.gnu.org/licenses/lgpl-2.1.html
+
+#pragma once
+
+#include "KokkosAuxKernel.h"
+
+class KokkosCoupledAux : public Moose::Kokkos::AuxKernel
+{
+public:
+  static InputParameters validParams();
+
+  KokkosCoupledAux(const InputParameters & parameters);
+
+  KOKKOS_FUNCTION Real computeValue(const unsigned int qp, Datum & datum) const;
+
+protected:
+  const Real _value;
+  const int _operator;
+
+  const unsigned int _coupled;
+  const Moose::Kokkos::VariableValue _coupled_val;
+};
+
+KOKKOS_FUNCTION inline Real
+KokkosCoupledAux::computeValue(const unsigned int qp, Datum & datum) const
+{
+  if (_operator == 0)
+    return _coupled_val(datum, qp) + _value;
+  else if (_operator == 1)
+    return _coupled_val(datum, qp) - _value;
+  else if (_operator == 2)
+    return _coupled_val(datum, qp) * _value;
+  else if (_operator == 3)
+  // We are going to do division for this operation
+  // This is useful for testing evalutation order
+  // when we attempt to divide by zero!
+  {
+    KOKKOS_ASSERT(_coupled_val(datum, qp) != 0);
+
+    return _value / _coupled_val(datum, qp);
+  }
+
+  // Won't reach this statement
+  return 0;
+}

test/src/kokkos/auxkernels/KokkosCoupledAux.K

@@ -0,0 +1,37 @@
+//* This file is part of the MOOSE framework
+//* https://mooseframework.inl.gov
+//*
+//* All rights reserved, see COPYRIGHT for full restrictions
+//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
+//*
+//* Licensed under LGPL 2.1, please see LICENSE for details
+//* https://www.gnu.org/licenses/lgpl-2.1.html
+
+#include "KokkosCoupledAux.h"
+
+registerKokkosAuxKernel("MooseTestApp", KokkosCoupledAux);
+
+InputParameters
+KokkosCoupledAux::validParams()
+{
+  InputParameters params = AuxKernel::validParams();
+
+  MooseEnum operators("+ - * /", "+");
+
+  params.addRequiredCoupledVar("coupled", "Coupled Value for Calculation");
+
+  params.addParam<Real>(
+      "value", 0.0, "A value to use in the binary arithmetic operation of this coupled auxkernel");
+  params.addParam<MooseEnum>(
+      "operator", operators, "The binary operator to use in the calculation");
+  return params;
+}
+
+KokkosCoupledAux::KokkosCoupledAux(const InputParameters & parameters)
+  : AuxKernel(parameters),
+    _value(getParam<Real>("value")),
+    _operator(getParam<MooseEnum>("operator")),
+    _coupled(coupled("coupled")),
+    _coupled_val(kokkosCoupledValue("coupled"))
+{
+}

test/tests/kokkos/auxkernels/copy_value_aux/kokkos_copy_old_aux.i

@@ -56,17 +56,17 @@
 
 [Postprocessors]
   [T]
-    type = ElementAverageValue
+    type = KokkosElementAverageValue
     variable = T
     execute_on = 'timestep_end'
   []
   [T_old]
-    type = ElementAverageValue
+    type = KokkosElementAverageValue
     variable = T_old
     execute_on = 'timestep_end'
   []
   [T_older]
-    type = ElementAverageValue
+    type = KokkosElementAverageValue
     variable = T_older
     execute_on = 'timestep_end'
   []

test/tests/kokkos/functions/piecewise_constant/kokkos_piecewise_constant.i

@@ -82,7 +82,7 @@
 
 [Postprocessors]
   [coef]
-    type = ElementIntegralVariablePostprocessor
+    type = KokkosElementIntegralVariablePostprocessor
     variable = coef
   []
 []

test/tests/kokkos/materials/stateful_prop/kokkos_stateful_prop_test.i

@@ -71,7 +71,7 @@
 
 [Postprocessors]
   [integral]
-    type = ElementAverageValue
+    type = KokkosElementAverageValue
     variable = prop1
     execute_on = 'initial timestep_end'
   []

test/tests/kokkos/postprocessors/element_extreme_value/gold/kokkos_element_extreme_value_out.e

@@ -0,0 +1,3 @@
+time,max_v_from_proxy_x,max_v_from_proxy_y,min_v_from_proxy_x,min_v_from_proxy_y
+0,0,0,0,0
+1,0.50528312163513,0.60528312163513,0.69471687836487,0.79471687836487

test/tests/kokkos/postprocessors/element_extreme_value/gold/kokkos_element_proxy_extreme_value_out.csv

@@ -0,0 +1,56 @@
+[Mesh]
+  type = GeneratedMesh
+  dim = 2
+  nx = 10
+  ny = 10
+[]
+
+[Variables]
+  [u]
+  []
+[]
+
+[Kernels]
+  [diff]
+    type = KokkosDiffusion
+    variable = u
+  []
+[]
+
+[BCs]
+  [left]
+    type = KokkosDirichletBC
+    variable = u
+    boundary = left
+    value = 0
+  []
+  [right]
+    type = KokkosDirichletBC
+    variable = u
+    boundary = right
+    value = 1
+  []
+[]
+
+[Postprocessors]
+  [max]
+    type = KokkosElementExtremeValue
+    variable = u
+  []
+  [min]
+    type = KokkosElementExtremeValue
+    variable = u
+    value_type = min
+  []
+[]
+
+[Executioner]
+  type = Steady
+  solve_type = PJFNK
+  petsc_options_iname = '-pc_type -pc_hypre_type'
+  petsc_options_value = 'hypre boomeramg'
+[]
+
+[Outputs]
+  exodus = true
+[]

test/tests/kokkos/postprocessors/element_extreme_value/kokkos_element_extreme_value.i

@@ -0,0 +1,112 @@
+[Problem]
+  type = FEProblem
+  solve = false
+[]
+
+[Mesh]
+  type = GeneratedMesh
+  dim = 2
+  nx = 40
+  ny = 40
+[]
+
+[AuxVariables]
+  [u]
+  []
+  [w]
+  []
+  [v_x]
+  []
+  [v_y]
+  []
+[]
+
+[AuxKernels]
+  [u]
+    type = FunctionAux
+    variable = u
+    function = u
+  []
+  [w]
+    type = FunctionAux
+    variable = w
+    function = w
+  []
+  [v_x]
+    type = FunctionAux
+    variable = v_x
+    function = v_x
+  []
+  [v_y]
+    type = FunctionAux
+    variable = v_y
+    function = v_y
+  []
+[]
+
+[Functions]
+  [u] # reaches a maximum value at (0.5, 0.6)
+    type = ParsedFunction
+    expression = 'sin(pi*x)*sin(pi*y/1.2)'
+  []
+  [w] # reaches a minium expression at (0.7, 0.8)
+    type = ParsedFunction
+    expression = '-sin(pi*x/1.4)*sin(pi*y/1.6)'
+  []
+  [v_x]
+    type = ParsedFunction
+    expression = 'x'
+  []
+  [v_y]
+    type = ParsedFunction
+    expression = 'y'
+  []
+[]
+
+[Postprocessors]
+  # because we set v_x and v_y equal to the x and y coordinates, these two postprocessors
+  # should just return the point at which u reaches a maximum value
+  [max_v_from_proxy_x]
+    type = KokkosElementExtremeValue
+    variable = v_x
+    proxy_variable = u
+    value_type = max
+  []
+  [max_v_from_proxy_y]
+    type = KokkosElementExtremeValue
+    variable = v_y
+    proxy_variable = u
+    value_type = max
+  []
+
+  # because we set v_x and v_y equal to the x and y coordinates, these two postprocessors
+  # should just return the point at which w reaches a minimum value
+  [min_v_from_proxy_x]
+    type = KokkosElementExtremeValue
+    variable = v_x
+    proxy_variable = w
+    value_type = min
+  []
+  [min_v_from_proxy_y]
+    type = KokkosElementExtremeValue
+    variable = v_y
+    proxy_variable = w
+    value_type = min
+  []
+[]
+
+[Executioner]
+  type = Steady
+
+  # increase the quadrature order to get more quadrature points so that were closer
+  # to hitting the expect max/min
+  [Quadrature]
+    type = GAUSS
+    order = SECOND
+  []
+[]
+
+[Outputs]
+  exodus = true
+  csv = true
+[]

test/tests/kokkos/postprocessors/element_extreme_value/kokkos_element_proxy_extreme_value.i

@@ -0,0 +1,24 @@
+[Tests]
+  design = 'ElementExtremeValue.md'
+  issues = '#30655'
+
+  [elemental_extreme]
+    requirement = 'The Kokkos system shall compute the value of an elemental field variable at the point where'
+    [value]
+      type = 'Exodiff'
+      input = 'kokkos_element_extreme_value.i'
+      exodiff = 'kokkos_element_extreme_value_out.e'
+      detail = 'the variable reaches the extreme (max/min) value and'
+      capabilities = 'kokkos'
+      compute_devices = 'cpu cuda'
+    []
+    [proxy]
+      type = 'CSVDiff'
+      input = 'kokkos_element_proxy_extreme_value.i'
+      csvdiff = 'kokkos_element_proxy_extreme_value_out.csv'
+      detail = 'the proxy variable reaches the extreme (max/min) value.'
+      capabilities = 'kokkos'
+      compute_devices = 'cpu cuda'
+    []
+  []
+[]