GeneralizedPlaneStrainAction Class Reference

#include <GeneralizedPlaneStrainAction.h>

Inheritance diagram for GeneralizedPlaneStrainAction:

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

Static Public Member Functions
static InputParameters	validParams ()

Protected Attributes
std::vector< VariableName >	_displacements
unsigned int	_ndisp
const unsigned int	_out_of_plane_direction

Detailed Description

Definition at line 19 of file GeneralizedPlaneStrainAction.h.

Constructor & Destructor Documentation

GeneralizedPlaneStrainAction()

GeneralizedPlaneStrainAction::GeneralizedPlaneStrainAction

(

const InputParameters &

params

)

Definition at line 59 of file GeneralizedPlaneStrainAction.C.

  : Action(params),
    _displacements(getParam<std::vector<VariableName>>("displacements")),
    _ndisp(_displacements.size()),
    _out_of_plane_direction(getParam<MooseEnum>("out_of_plane_direction"))
{
}

Member Function Documentation

act()

void GeneralizedPlaneStrainAction::act ( )

override

Definition at line 68 of file GeneralizedPlaneStrainAction.C.

{
  // user object name
  const std::string uo_name = _name + "_GeneralizedPlaneStrainUserObject";
 
  //
  // Add off diagonal Jacobian kernels
  //
  if (_current_task == "add_kernel")
  {
    std::string k_type = "GeneralizedPlaneStrainOffDiag";
    InputParameters params = _factory.getValidParams(k_type);
 
    params.applyParameters(parameters(), {"scalar_out_of_plane_strain"});
    params.set<std::vector<VariableName>>("scalar_out_of_plane_strain") = {
        getParam<VariableName>("scalar_out_of_plane_strain")};
 
    // add off-diagonal jacobian kernels for the displacements
    for (unsigned int i = 0; i < _ndisp; ++i)
    {
      if (_out_of_plane_direction == i)
        continue;
 
      std::string k_name = _name + "GeneralizedPlaneStrainOffDiag_disp" + Moose::stringify(i);
      params.set<NonlinearVariableName>("variable") = _displacements[i];
 
      _problem->addKernel(k_type, k_name, params);
    }
 
    // add temperature kernel only if temperature is a nonlinear variable (and not an auxvariable)
    if (isParamValid("temperature"))
    {
      VariableName temp = getParam<VariableName>("temperature");
      if (_problem->getNonlinearSystemBase().hasVariable(temp))
      {
        params.set<VariableName>("temperature") = temp;
 
        std::string k_name = _name + "_GeneralizedPlaneStrainOffDiag_temp";
        params.set<NonlinearVariableName>("variable") = temp;
 
        _problem->addKernel(k_type, k_name, params);
      }
    }
  }
 
  //
  // Add user object
  //
  else if (_current_task == "add_user_object")
  {
    std::string uo_type = "GeneralizedPlaneStrainUserObject";
    InputParameters params = _factory.getValidParams(uo_type);
 
    params.applyParameters(parameters());
    params.set<ExecFlagEnum>("execute_on") = EXEC_LINEAR;
 
    _problem->addUserObject(uo_type, uo_name, params);
  }
 
  //
  // Add scalar kernel
  //
  else if (_current_task == "add_scalar_kernel")
  {
    std::string sk_type = "GeneralizedPlaneStrain";
    InputParameters params = _factory.getValidParams(sk_type);
 
    params.set<NonlinearVariableName>("variable") =
        getParam<VariableName>("scalar_out_of_plane_strain");
 
    // set the UserObjectName from previously added UserObject
    params.set<UserObjectName>("generalized_plane_strain") = uo_name;
 
    if (isParamValid("extra_vector_tags"))
      params.set<std::vector<TagName>>("extra_vector_tags") =
          getParam<std::vector<TagName>>("extra_vector_tags");
 
    _problem->addScalarKernel(sk_type, _name + "_GeneralizedPlaneStrain", params);
  }
}

validParams()

InputParameters GeneralizedPlaneStrainAction::validParams ( )

static

Definition at line 26 of file GeneralizedPlaneStrainAction.C.

{
  InputParameters params = Action::validParams();
  params.addClassDescription("Set up the GeneralizedPlaneStrain environment");
  params.addRequiredParam<std::vector<VariableName>>("displacements", "The displacement variables");
  params.addRequiredParam<VariableName>("scalar_out_of_plane_strain",
                                        "Scalar variable for the out-of-plane strain (in "
                                        "y direction for 1D Axisymmetric or in z "
                                        "direction for 2D Cartesian problems)");
  params.addParam<VariableName>("temperature", "The temperature variable");
  MooseEnum outOfPlaneDirection("x y z", "z");
  params.addParam<MooseEnum>(
      "out_of_plane_direction", outOfPlaneDirection, "The direction of the out-of-plane strain.");
  params.addParam<FunctionName>("out_of_plane_pressure",
                                "0",
                                "Function used to prescribe pressure "
                                "in the out-of-plane direction (y "
                                "for 1D Axisymmetric or z for 2D "
                                "Cartesian problems)");
  params.addParam<Real>("factor", 1.0, "Scale factor applied to prescribed pressure");
  params.addParam<bool>("use_displaced_mesh", false, "Whether to use displaced mesh");
  params.addParam<std::string>("base_name", "Material property base name");
  params.addParam<std::vector<SubdomainName>>("block",
                                              "The list of ids of the blocks (subdomain) "
                                              "that the GeneralizedPlaneStrain kernels "
                                              "will be applied to");
  params.addParam<std::vector<TagName>>(
      "extra_vector_tags",
      "The tag names for extra vectors that residual data should be saved into");
 
  return params;
}

Member Data Documentation

_displacements

std::vector<VariableName> GeneralizedPlaneStrainAction::_displacements

protected

Definition at line 29 of file GeneralizedPlaneStrainAction.h.

Referenced by act().

_ndisp

unsigned int GeneralizedPlaneStrainAction::_ndisp

protected

Definition at line 30 of file GeneralizedPlaneStrainAction.h.

Referenced by act().

_out_of_plane_direction

const unsigned int GeneralizedPlaneStrainAction::_out_of_plane_direction

protected

Definition at line 31 of file GeneralizedPlaneStrainAction.h.

Referenced by act().

---

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

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