CavityPressureAction Class Reference

#include <CavityPressureAction.h>

Inheritance diagram for CavityPressureAction:

Public Member Functions
	CavityPressureAction (const InputParameters &params)
virtual void	act () override

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const bool	_use_ad
	Flag to use automatic differentiation where possible. More...

Detailed Description

Definition at line 19 of file CavityPressureAction.h.

Constructor & Destructor Documentation

CavityPressureAction()

CavityPressureAction::CavityPressureAction

(

const InputParameters &

params

)

Definition at line 38 of file CavityPressureAction.C.

  : Action(params), _use_ad(getParam<bool>("use_automatic_differentiation"))
{
}

Member Function Documentation

act()

void CavityPressureAction::act ( )

overridevirtual

Definition at line 44 of file CavityPressureAction.C.

{
  auto displacements = getParam<std::vector<VariableName>>("displacements");
  auto save_in = getParam<std::vector<AuxVariableName>>("save_in");
 
  unsigned int ndisp = displacements.size();
  if (save_in.size() > 0 && save_in.size() != ndisp)
    mooseError("Number of save_in variables should equal to the number of displacement variables ",
               ndisp);
 
  std::string ad_append = "";
  std::string ad_prepend = "";
  if (_use_ad)
  {
    ad_append = "<RESIDUAL>";
    ad_prepend = "AD";
  }
 
  std::string kernel_name = ad_prepend + "Pressure";
 
  InputParameters params = _factory.getValidParams(kernel_name + ad_append);
  params.applyParameters(parameters());
 
  params.set<PostprocessorName>("postprocessor") =
      isParamValid("output") ? getParam<std::string>("output") : _name;
 
  for (unsigned int i = 0; i < ndisp; ++i)
  {
    params.set<unsigned int>("component") = i;
    params.set<NonlinearVariableName>("variable") = displacements[i];
    if (!save_in.empty())
      params.set<std::vector<AuxVariableName>>("save_in") = {save_in[i]};
    std::string unique_kernel_name = _name + "_" + Moose::stringify(i);
 
    if (_use_ad)
    {
      _problem->addBoundaryCondition(
          kernel_name + ad_append, unique_kernel_name + "_residual", params);
      _problem->addBoundaryCondition(
          kernel_name + "<JACOBIAN>", unique_kernel_name + "_jacobian", params);
      _problem->haveADObjects(true);
    }
    else
    {
      _problem->addBoundaryCondition(kernel_name, unique_kernel_name, params);
    }
  }
}

validParams()

InputParameters CavityPressureAction::validParams ( )

static

Definition at line 20 of file CavityPressureAction.C.

{
  InputParameters params = Action::validParams();
  params.addRequiredParam<std::vector<BoundaryName>>(
      "boundary", "The list of boundary IDs from the mesh where the pressure will be applied");
  params.addRequiredParam<std::vector<VariableName>>("displacements",
                                                     "The nonlinear displacement variables");
  params.addParam<std::vector<AuxVariableName>>(
      "save_in", "Auxiliary variables to save the displacement residuals");
  params.addParam<std::string>("output", "The name to use for the cavity pressure value");
  params.addParam<bool>(
      "use_displaced_mesh", true, "Whether to use displaced mesh in the boundary condition");
  params.addParam<bool>("use_automatic_differentiation",
                        false,
                        "Flag to use automatic differentiation (AD) objects when possible");
  return params;
}

Member Data Documentation

_use_ad

const bool CavityPressureAction::_use_ad

Flag to use automatic differentiation where possible.

Definition at line 29 of file CavityPressureAction.h.

Referenced by act().

---

The documentation for this class was generated from the following files:

• tensor_mechanics/include/actions/CavityPressureAction.h
• tensor_mechanics/src/actions/CavityPressureAction.C