PressureAction Class Reference

#include <PressureAction.h>

Inheritance diagram for PressureAction:

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

Static Public Member Functions
static InputParameters	validParams ()

Protected Attributes
const bool	_use_ad
	Flag to use automatic differentiation. More...
std::vector< std::vector< AuxVariableName > >	_save_in_vars
std::vector< bool >	_has_save_in_vars

Detailed Description

Definition at line 14 of file PressureAction.h.

Constructor & Destructor Documentation

PressureAction()

PressureAction::PressureAction

(

const InputParameters &

params

)

Definition at line 52 of file PressureAction.C.

  : Action(params), _use_ad(getParam<bool>("use_automatic_differentiation"))
{
  _save_in_vars.push_back(getParam<std::vector<AuxVariableName>>("save_in_disp_x"));
  _save_in_vars.push_back(getParam<std::vector<AuxVariableName>>("save_in_disp_y"));
  _save_in_vars.push_back(getParam<std::vector<AuxVariableName>>("save_in_disp_z"));
 
  _has_save_in_vars.push_back(params.isParamValid("save_in_disp_x"));
  _has_save_in_vars.push_back(params.isParamValid("save_in_disp_y"));
  _has_save_in_vars.push_back(params.isParamValid("save_in_disp_z"));
}

Member Function Documentation

act()

void PressureAction::act ( )

overridevirtual

Definition at line 65 of file PressureAction.C.

{
  std::string ad_append = "";
  std::string ad_prepend = "";
  if (_use_ad)
  {
    ad_append = "<RESIDUAL>";
    ad_prepend = "AD";
  }
 
  std::string kernel_name = ad_prepend + "Pressure";
 
  std::vector<VariableName> displacements;
  if (isParamValid("displacements"))
    displacements = getParam<std::vector<VariableName>>("displacements");
  else
  {
    // Legacy parameter scheme for displacements
    if (!isParamValid("disp_x"))
      mooseError("Specify displacement variables using the `displacements` parameter.");
    displacements.push_back(getParam<VariableName>("disp_x"));
 
    if (isParamValid("disp_y"))
    {
      displacements.push_back(getParam<VariableName>("disp_y"));
      if (isParamValid("disp_z"))
        displacements.push_back(getParam<VariableName>("disp_z"));
    }
  }
 
  // Create pressure BCs
  for (unsigned int i = 0; i < displacements.size(); ++i)
  {
    // Create unique kernel name for each of the components
    std::string unique_kernel_name = kernel_name + "_" + _name + "_" + Moose::stringify(i);
 
    InputParameters params = _factory.getValidParams(kernel_name + ad_append);
    params.applyParameters(parameters(), {"factor"});
    params.set<bool>("use_displaced_mesh") = true;
    params.set<unsigned int>("component") = i;
    params.set<NonlinearVariableName>("variable") = displacements[i];
 
    if (_has_save_in_vars[i])
      params.set<std::vector<AuxVariableName>>("save_in") = _save_in_vars[i];
 
    if (_use_ad)
    {
      params.set<Real>("constant") = getParam<Real>("factor");
      _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
    {
      params.set<Real>("factor") = getParam<Real>("factor");
      _problem->addBoundaryCondition(kernel_name, unique_kernel_name, params);
    }
  }
}

validParams()

InputParameters PressureAction::validParams ( )

static

Definition at line 20 of file PressureAction.C.

{
  InputParameters params = Action::validParams();
  params.addClassDescription("Set up Pressure boundary conditions");
 
  params.addRequiredParam<std::vector<BoundaryName>>(
      "boundary", "The list of boundary IDs from the mesh where the pressure will be applied");
 
  params.addParam<VariableName>("disp_x", "The x displacement");
  params.addParam<VariableName>("disp_y", "The y displacement");
  params.addParam<VariableName>("disp_z", "The z displacement");
 
  params.addParam<std::vector<VariableName>>(
      "displacements",
      "The displacements appropriate for the simulation geometry and coordinate system");
 
  params.addParam<std::vector<AuxVariableName>>("save_in_disp_x",
                                                "The save_in variables for x displacement");
  params.addParam<std::vector<AuxVariableName>>("save_in_disp_y",
                                                "The save_in variables for y displacement");
  params.addParam<std::vector<AuxVariableName>>("save_in_disp_z",
                                                "The save_in variables for z displacement");
 
  params.addParam<Real>("factor", 1.0, "The factor to use in computing the pressure");
  params.addParam<Real>("alpha", 0.0, "alpha parameter for HHT time integration");
  params.addParam<FunctionName>("function", "The function that describes the pressure");
  params.addParam<bool>("use_automatic_differentiation",
                        false,
                        "Flag to use automatic differentiation (AD) objects when possible");
  return params;
}

Member Data Documentation

_has_save_in_vars

std::vector<bool> PressureAction::_has_save_in_vars

protected

Definition at line 28 of file PressureAction.h.

Referenced by act(), and PressureAction().

_save_in_vars

std::vector<std::vector<AuxVariableName> > PressureAction::_save_in_vars

protected

Definition at line 27 of file PressureAction.h.

Referenced by act(), and PressureAction().

_use_ad

const bool PressureAction::_use_ad

protected

Flag to use automatic differentiation.

Definition at line 25 of file PressureAction.h.

Referenced by act().

---

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

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