Step 5: Develop a Kernel Object

Source Code

To evaluate Eq. (2), a new ADKernelGrad object can be created and it shall be called DarcyPressure. Start by making the directories to store files for objects that are part of the Kernels System:

cd ~/projects/babbler
mkdir include/kernels src/kernels

In include/kernels, create a file named DarcyPressure.h and add the code given in Listing 2. Here, the DarcyPressure class was defined as a type of ADKernelGrad object, and so the header file ADKernelGrad.h was included. A MooseObject must have a validParams() method and a constructor, and so these were included as part of the public members. The precomputeQpResidual() method was overridden so that Eq. (2) may set its returned value in accordance with Table 1. Finally, two variables, _permeability and _viscosity, were created to store the values for and , respectively, and were assigned const types to ensure that their values aren't accidentally modified after they are set by the constructor method.

#pragma once

// Including the "ADKernel" base class here so we can extend it
#include "ADKernelGrad.h"

/**
 * Computes the residual contribution: K / mu * grad_test * grad_u.
 */
class DarcyPressure : public ADKernelGrad
{
public:
  static InputParameters validParams();

  DarcyPressure(const InputParameters & parameters);

protected:
  /// ADKernel objects must override precomputeQpResidual
  virtual ADRealVectorValue precomputeQpResidual() override;

  /// The variables which hold the value for K and mu
  const Real _permeability;
  const Real _viscosity;
};

In src/kernels, create a file named DarcyPressure.C and add the code given in Listing 3. Here, the header file for this object was included. Next, the registerMooseObject() method was called for "BabblerApp" and the DarcyPressure object. The validParams() method is the subject of the next step, so, for now, it is okay to simply copy and paste its definition. In the constructor method the _permeability and _viscosity attributes were set according to the values that were given earlier. Finally, the precomputeQpResidual() method was programmed to return the left-hand side of Eq. (2), except that the (_grad_test) term is automatically handled by the base class.

#include "DarcyPressure.h"

registerMooseObject("BabblerApp", DarcyPressure);

InputParameters
DarcyPressure::validParams()
{
  InputParameters params = ADKernelGrad::validParams();
  params.addClassDescription("Compute the diffusion term for Darcy pressure ($p$) equation: "
                             "$-\\nabla \\cdot \\frac{\\mathbf{K}}{\\mu} \\nabla p = 0$");

  return params;
}

DarcyPressure::DarcyPressure(const InputParameters & parameters)
  : ADKernelGrad(parameters),

    // Set the coefficients for the pressure kernel
    _permeability(0.8451e-09),
    _viscosity(7.98e-04)
{
}

ADRealVectorValue
DarcyPressure::precomputeQpResidual()
{
  return (_permeability / _viscosity) * _grad_u[_qp];
}

Since the source code has been modified, the executable must be recompiled:

cd ~/projects/babbler
make -j4

Input File

Instead of the ADDiffusion class, the problem model should now use DarcyPressure. In the pressure_diffusion.i input file, which was created in Step 2, replace the [Kernels] block with the following:

[Kernels]
  [diffusion]
    type = DarcyPressure # Zero-gravity, divergence-free form of Darcy's law
    variable = pressure # Operate on the "pressure" variable from above
  []
[]

Now, execute the input file:

cd ~/projects/babbler/problems
../babbler-opt -i pressure_diffusion.i

Results

Visualize the solution with PEACOCK and confirm that it resembles that which is shown in Figure 1:

cd ~/projects/babbler/problems
~/projects/moose/python/peacock/peacock -r pressure_diffusion_out.e

Figure 1: Rendering of the FEM solution of Darcy's pressure equation subject to the given BVP.

One should be convinced that, because this is a steady-state problem, where the coefficient is constant and since the foregoing BVP is a simple one that involves only essential boundary conditions, the solution produced by the new DarcyPressure object, shown in Figure 1, is identical to the previous one produced by the ADDiffusion object.

Commit

Add the two new files, DarcyPressure.h and DarcyPressure.C, to the git tracker and update the pressure_diffusion.i file:

cd ~/projects/babbler
git add include/kernels src/kernels problems/pressure_diffusion.i

Now, commit and push the changes to the remote repository:

git commit -m "developed kernel to solve Darcy pressure and updated the problem input file"
git push