GlobalStrainAction Class Reference

#include <GlobalStrainAction.h>

Inheritance diagram for GlobalStrainAction:

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

Protected Attributes
std::vector< VariableName >	_disp
std::vector< AuxVariableName >	_aux_disp
std::vector< AuxVariableName >	_global_disp
std::vector< SubdomainName >	_block_names
std::set< SubdomainID >	_block_ids

Detailed Description

Definition at line 20 of file GlobalStrainAction.h.

Constructor & Destructor Documentation

GlobalStrainAction()

GlobalStrainAction::GlobalStrainAction

(

const InputParameters &

params

)

Definition at line 53 of file GlobalStrainAction.C.

  : Action(params),
    _disp(getParam<std::vector<VariableName>>("displacements")),
    _aux_disp(getParam<std::vector<AuxVariableName>>("auxiliary_displacements")),
    _global_disp(getParam<std::vector<AuxVariableName>>("global_displacements")),
    _block_names(getParam<std::vector<SubdomainName>>("block")),
    _block_ids()
{
  if (_aux_disp.size() != _disp.size())
    mooseError("Number of auxiliary displacement variables should be equal to the number of "
               "nonlinear displacement variables, i.e., ",
               _disp.size());
}

Member Function Documentation

act()

void GlobalStrainAction::act ( )

override

Definition at line 68 of file GlobalStrainAction.C.

{
  // get subdomain IDs
  for (auto & name : _block_names)
    _block_ids.insert(_problem->mesh().getSubdomainID(name));

  // user object name
  const std::string uo_name = _name + "_GlobalStrainUserObject";

  //
  // Add user object
  //
  if (_current_task == "add_user_object")
  {
    std::string uo_type = "GlobalStrainUserObject";
    InputParameters params = _factory.getValidParams(uo_type);
    params.applyParameters(parameters());
    params.set<bool>("use_displaced_mesh") = false;
    params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR, EXEC_NONLINEAR};

    _problem->addUserObject(uo_type, uo_name, params);
  }

  //
  // Add scalar kernel
  //
  else if (_current_task == "add_scalar_kernel")
  {
    std::string sk_type = "GlobalStrain";
    InputParameters params = _factory.getValidParams(sk_type);
    params.applyParameters(parameters());
    params.set<bool>("use_displaced_mesh") = false;
    params.set<NonlinearVariableName>("variable") = getParam<VariableName>("scalar_global_strain");
    params.set<UserObjectName>("global_strain_uo") = uo_name;

    _problem->addScalarKernel(sk_type, _name + "_GlobalStrain", params);
  }

  //
  // Add ComputeGlobalStrain material
  //
  else if (_current_task == "add_material")
  {
    std::string mat_type = "ComputeGlobalStrain";
    InputParameters params = _factory.getValidParams(mat_type);
    params.applyParameters(parameters(), {"scalar_global_strain"});
    params.set<bool>("use_displaced_mesh") = false;
    params.set<std::vector<VariableName>>("scalar_global_strain") = {
        getParam<VariableName>("scalar_global_strain")};
    params.set<UserObjectName>("global_strain_uo") = uo_name;

    _problem->addMaterial(mat_type, _name + "_global_strain", params);
  }

  //
  // Add auxiliary displacement variables
  //
  else if (_current_task == "add_aux_variable")
  {
    const bool second = _problem->mesh().hasSecondOrderElements();

    for (unsigned int i = 0; i < _aux_disp.size(); ++i)
    {
      std::string aux_var_name = _aux_disp[i];

      _problem->addAuxVariable(aux_var_name,
                               FEType(Utility::string_to_enum<Order>(second ? "SECOND" : "FIRST"),
                                      Utility::string_to_enum<FEFamily>("LAGRANGE")),
                               _block_ids.empty() ? nullptr : &_block_ids);
    }

    for (unsigned int i = 0; i < _global_disp.size(); ++i)
    {
      std::string aux_var_name = _global_disp[i];

      _problem->addAuxVariable(aux_var_name,
                               FEType(Utility::string_to_enum<Order>(second ? "SECOND" : "FIRST"),
                                      Utility::string_to_enum<FEFamily>("LAGRANGE")),
                               _block_ids.empty() ? nullptr : &_block_ids);
    }
  }

  //
  // Add aux kernels for computing global displacements
  //
  else if (_current_task == "add_aux_kernel")
  {
    for (unsigned int i = 0; i < _aux_disp.size(); ++i)
    {
      std::string aux_var_name = _aux_disp[i];

      std::string aux_type = "GlobalDisplacementAux";
      InputParameters params = _factory.getValidParams(aux_type);
      params.applyParameters(parameters(), {"scalar_global_strain"});
      params.set<AuxVariableName>("variable") = aux_var_name;
      params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
      params.set<bool>("use_displaced_mesh") = false;
      params.set<bool>("output_global_displacement") = false;
      params.set<std::vector<VariableName>>("scalar_global_strain") = {
          getParam<VariableName>("scalar_global_strain")};
      params.set<UserObjectName>("global_strain_uo") = uo_name;
      params.set<unsigned int>("component") = i;

      _problem->addAuxKernel(aux_type, aux_var_name + '_' + name(), params);
    }

    for (unsigned int i = 0; i < _global_disp.size(); ++i)
    {
      std::string aux_var_name = _global_disp[i];

      std::string aux_type = "GlobalDisplacementAux";
      InputParameters params = _factory.getValidParams(aux_type);
      params.applyParameters(parameters(), {"scalar_global_strain"});
      params.set<AuxVariableName>("variable") = aux_var_name;
      params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
      params.set<bool>("use_displaced_mesh") = false;
      params.set<bool>("output_global_displacement") = true;
      params.set<std::vector<VariableName>>("scalar_global_strain") = {
          getParam<VariableName>("scalar_global_strain")};
      params.set<UserObjectName>("global_strain_uo") = uo_name;
      params.set<unsigned int>("component") = i;

      _problem->addAuxKernel(aux_type, aux_var_name + '_' + name(), params);
    }
  }
}

Member Data Documentation

_aux_disp

std::vector<AuxVariableName> GlobalStrainAction::_aux_disp

protected

Definition at line 29 of file GlobalStrainAction.h.

Referenced by act(), and GlobalStrainAction().

_block_ids

std::set<SubdomainID> GlobalStrainAction::_block_ids

protected

Definition at line 33 of file GlobalStrainAction.h.

Referenced by act().

_block_names

std::vector<SubdomainName> GlobalStrainAction::_block_names

protected

Definition at line 32 of file GlobalStrainAction.h.

Referenced by act().

_disp

std::vector<VariableName> GlobalStrainAction::_disp

protected

Definition at line 28 of file GlobalStrainAction.h.

Referenced by GlobalStrainAction().

_global_disp

std::vector<AuxVariableName> GlobalStrainAction::_global_disp

protected

Definition at line 30 of file GlobalStrainAction.h.

Referenced by act().

---

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

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