DynamicTensorMechanicsAction Class Reference

#include <DynamicTensorMechanicsAction.h>

Inheritance diagram for DynamicTensorMechanicsAction:

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

Static Public Member Functions
static InputParameters	validParams ()
static MultiMooseEnum	outputPropertiesType ()

Static Public Attributes
static const std::map< std::string, std::string >	_ranktwoaux_table
	table data for output generation More...
static const std::vector< char >	_component_table = {'x', 'y', 'z'}
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > >	_ranktwoscalaraux_table

Protected Types
enum	Strain { Strain::Small, Strain::Finite }
	strain formulation More...
enum	StrainAndIncrement { StrainAndIncrement::SmallTotal, StrainAndIncrement::FiniteTotal, StrainAndIncrement::SmallIncremental, StrainAndIncrement::FiniteIncremental }
	strain formulation More...
enum	PlanarFormulation { PlanarFormulation::None, PlanarFormulation::WeakPlaneStress, PlanarFormulation::PlaneStrain, PlanarFormulation::GeneralizedPlaneStrain }
	use an out of plane stress/strain formulation More...
enum	OutOfPlaneDirection { OutOfPlaneDirection::x, OutOfPlaneDirection::y, OutOfPlaneDirection::z }

Protected Member Functions
virtual std::string	getKernelType ()
void	actSubdomainChecks ()
void	actOutputGeneration ()
void	actGatherActionParameters ()
virtual InputParameters	getKernelParameters (std::string type)

Protected Attributes
Moose::CoordinateSystemType	_coord_system
std::vector< SubdomainName >	_subdomain_names
	if this vector is not empty the variables, kernels and materials are restricted to these subdomains More...
std::set< SubdomainID >	_subdomain_ids
	set generated from the passed in vector of subdomain names More...
std::set< SubdomainID >	_subdomain_id_union
	set generated from the combined block restrictions of all TensorMechanics/Master action blocks More...
enum TensorMechanicsAction::Strain	_strain
enum TensorMechanicsAction::StrainAndIncrement	_strain_and_increment
enum TensorMechanicsAction::PlanarFormulation	_planar_formulation
const OutOfPlaneDirection	_out_of_plane_direction
const std::string	_base_name
	base name for the current master action block More...
bool	_use_displaced_mesh
	use displaced mesh (true unless _strain is SMALL) More...
std::vector< std::string >	_generate_output
	output aux variables to generate for sclar stress/strain tensor quantities More...
const bool	_use_ad
std::vector< VariableName >	_displacements
	displacement variables More...
unsigned int	_ndisp
std::vector< VariableName >	_coupled_displacements
std::vector< AuxVariableName >	_save_in
	residual debugging More...
std::vector< AuxVariableName >	_diag_save_in

Detailed Description

Definition at line 19 of file DynamicTensorMechanicsAction.h.

Member Enumeration Documentation

OutOfPlaneDirection

enum TensorMechanicsAction::OutOfPlaneDirection

strongprotectedinherited

Enumerator
x
y
z

Definition at line 83 of file TensorMechanicsAction.h.

  {
    x,
    y,
    z
  };

PlanarFormulation

enum TensorMechanicsAction::PlanarFormulation

strongprotectedinherited

use an out of plane stress/strain formulation

Enumerator
None
WeakPlaneStress
PlaneStrain
GeneralizedPlaneStrain

Definition at line 75 of file TensorMechanicsAction.h.

  {
    None,
    WeakPlaneStress,
    PlaneStrain,
    GeneralizedPlaneStrain,
  } _planar_formulation;

Strain

enum TensorMechanicsAction::Strain

strongprotectedinherited

strain formulation

Enumerator
Small
Finite

Definition at line 59 of file TensorMechanicsAction.h.

  {
    Small,
    Finite
  } _strain;

StrainAndIncrement

enum TensorMechanicsAction::StrainAndIncrement

strongprotectedinherited

strain formulation

Enumerator
SmallTotal
FiniteTotal
SmallIncremental
FiniteIncremental

Definition at line 66 of file TensorMechanicsAction.h.

  {
    SmallTotal,
    FiniteTotal,
    SmallIncremental,
    FiniteIncremental
  } _strain_and_increment;

Constructor & Destructor Documentation

DynamicTensorMechanicsAction()

DynamicTensorMechanicsAction::DynamicTensorMechanicsAction

(

const InputParameters &

params

)

Definition at line 45 of file DynamicTensorMechanicsAction.C.

  : TensorMechanicsAction(params)
{
}

Member Function Documentation

act()

void TensorMechanicsAction::act ( )

virtualinherited

Reimplemented in LegacyTensorMechanicsAction, and PoroMechanicsAction.

Definition at line 156 of file TensorMechanicsAction.C.

{
  std::string ad_prepend = "";
  std::string ad_append = "";
  if (_use_ad)
  {
    ad_prepend = "AD";
    ad_append = "<RESIDUAL>";
  }
 
  //
  // Consistency checks across subdomains
  //
  actSubdomainChecks();
 
  //
  // Gather info from all other TensorMechanicsAction
  //
  actGatherActionParameters();
 
  //
  // Deal with the optional AuxVariable based tensor quantity output
  //
  actOutputGeneration();
 
  //
  // Meta action which optionally spawns other actions
  //
  if (_current_task == "meta_action")
  {
    if (_planar_formulation == PlanarFormulation::GeneralizedPlaneStrain)
    {
      if (_use_ad)
        paramError("use_ad", "AD not setup for use with PlaneStrain");
      // Set the action parameters
      const std::string type = "GeneralizedPlaneStrainAction";
      auto action_params = _action_factory.getValidParams(type);
      action_params.set<bool>("_built_by_moose") = true;
      action_params.set<std::string>("registered_identifier") = "(AutoBuilt)";
      action_params.applyParameters(parameters(), {"use_displaced_mesh"});
      action_params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
      if (isParamValid("pressure_factor"))
        action_params.set<Real>("factor") = getParam<Real>("pressure_factor");
      // Create and add the action to the warehouse
      auto action = MooseSharedNamespace::static_pointer_cast<MooseObjectAction>(
          _action_factory.create(type, name() + "_gps", action_params));
      _awh.addActionBlock(action);
      if (isParamValid("extra_vector_tags"))
        action_params.set<std::vector<TagName>>("extra_vector_tags") =
            getParam<std::vector<TagName>>("extra_vector_tags");
    }
  }
 
  //
  // Add variables (optional)
  //
  else if (_current_task == "add_variable" && getParam<bool>("add_variables"))
  {
    auto params = _factory.getValidParams("MooseVariable");
    // determine necessary order
    const bool second = _problem->mesh().hasSecondOrderElements();
 
    params.set<MooseEnum>("order") = second ? "SECOND" : "FIRST";
    params.set<MooseEnum>("family") = "LAGRANGE";
 
    // Loop through the displacement variables
    for (const auto & disp : _displacements)
    {
      // Create displacement variables
      _problem->addVariable("MooseVariable", disp, params);
    }
  }
 
  //
  // Add Strain Materials
  //
  else if (_current_task == "add_material")
  {
    std::string type;
 
    //
    // no plane strain
    //
    if (_planar_formulation == PlanarFormulation::None)
    {
      std::map<std::pair<Moose::CoordinateSystemType, StrainAndIncrement>, std::string> type_map = {
          {{Moose::COORD_XYZ, StrainAndIncrement::SmallTotal}, "ComputeSmallStrain"},
          {{Moose::COORD_XYZ, StrainAndIncrement::SmallIncremental},
           "ComputeIncrementalSmallStrain"},
          {{Moose::COORD_XYZ, StrainAndIncrement::FiniteIncremental}, "ComputeFiniteStrain"},
          {{Moose::COORD_RZ, StrainAndIncrement::SmallTotal}, "ComputeAxisymmetricRZSmallStrain"},
          {{Moose::COORD_RZ, StrainAndIncrement::SmallIncremental},
           "ComputeAxisymmetricRZIncrementalStrain"},
          {{Moose::COORD_RZ, StrainAndIncrement::FiniteIncremental},
           "ComputeAxisymmetricRZFiniteStrain"},
          {{Moose::COORD_RSPHERICAL, StrainAndIncrement::SmallTotal},
           "ComputeRSphericalSmallStrain"},
          {{Moose::COORD_RSPHERICAL, StrainAndIncrement::SmallIncremental},
           "ComputeRSphericalIncrementalStrain"},
          {{Moose::COORD_RSPHERICAL, StrainAndIncrement::FiniteIncremental},
           "ComputeRSphericalFiniteStrain"}};
 
      auto type_it = type_map.find(std::make_pair(_coord_system, _strain_and_increment));
      if (type_it != type_map.end())
        type = type_it->second;
      else
        mooseError("Unsupported strain formulation");
    }
    else if (_planar_formulation == PlanarFormulation::WeakPlaneStress ||
             _planar_formulation == PlanarFormulation::PlaneStrain ||
             _planar_formulation == PlanarFormulation::GeneralizedPlaneStrain)
    {
      if (_use_ad)
        paramError(
            "use_ad",
            "AD not setup for use with WeakPlaneStress, PlaneStrain, or GeneralizedPlaneStrain");
 
      std::map<std::pair<Moose::CoordinateSystemType, StrainAndIncrement>, std::string> type_map = {
          {{Moose::COORD_XYZ, StrainAndIncrement::SmallTotal}, "ComputePlaneSmallStrain"},
          {{Moose::COORD_XYZ, StrainAndIncrement::SmallIncremental},
           "ComputePlaneIncrementalStrain"},
          {{Moose::COORD_XYZ, StrainAndIncrement::FiniteIncremental}, "ComputePlaneFiniteStrain"},
          {{Moose::COORD_RZ, StrainAndIncrement::SmallTotal}, "ComputeAxisymmetric1DSmallStrain"},
          {{Moose::COORD_RZ, StrainAndIncrement::SmallIncremental},
           "ComputeAxisymmetric1DIncrementalStrain"},
          {{Moose::COORD_RZ, StrainAndIncrement::FiniteIncremental},
           "ComputeAxisymmetric1DFiniteStrain"}};
 
      // choose kernel type based on coordinate system
      auto type_it = type_map.find(std::make_pair(_coord_system, _strain_and_increment));
      if (type_it != type_map.end())
        type = type_it->second;
      else
        mooseError("Unsupported coordinate system for plane strain.");
    }
    else
      mooseError("Unsupported planar formulation");
 
    // set material parameters
    auto params = _factory.getValidParams(ad_prepend + type + ad_append);
    params.applyParameters(parameters(),
                           {"displacements",
                            "use_displaced_mesh",
                            "out_of_plane_strain",
                            "scalar_out_of_plane_strain"});
 
    if (isParamValid("strain_base_name"))
      params.set<std::string>("base_name") = getParam<std::string>("strain_base_name");
 
    params.set<std::vector<VariableName>>("displacements") = _coupled_displacements;
    params.set<bool>("use_displaced_mesh") = false;
 
    if (isParamValid("scalar_out_of_plane_strain"))
      params.set<std::vector<VariableName>>("scalar_out_of_plane_strain") = {
          getParam<VariableName>("scalar_out_of_plane_strain")};
 
    if (isParamValid("out_of_plane_strain"))
      params.set<std::vector<VariableName>>("out_of_plane_strain") = {
          getParam<VariableName>("out_of_plane_strain")};
 
    if (_use_ad)
    {
      _problem->addADResidualMaterial(
          ad_prepend + type + "<RESIDUAL>", name() + "_strain" + "_residual", params);
      _problem->addADJacobianMaterial(
          ad_prepend + type + "<JACOBIAN>", name() + "_strain" + "_jacobian", params);
      _problem->haveADObjects(true);
    }
    else
      _problem->addMaterial(type, name() + "_strain", params);
  }
 
  //
  // Add Stress Divergence (and optionally WeakPlaneStress) Kernels
  //
  else if (_current_task == "add_kernel")
  {
    for (unsigned int i = 0; i < _ndisp; ++i)
    {
      auto tensor_kernel_type = getKernelType();
      auto params = getKernelParameters(ad_prepend + tensor_kernel_type + ad_append);
 
      std::string kernel_name = "TM_" + name() + Moose::stringify(i);
 
      // Set appropriate components for kernels, including in the cases where a planar model is
      // running in planes other than the x-y plane (defined by _out_of_plane_strain_direction).
      if (_out_of_plane_direction == OutOfPlaneDirection::x && i == 0)
        continue;
      else if (_out_of_plane_direction == OutOfPlaneDirection::y && i == 1)
        continue;
 
      params.set<unsigned int>("component") = i;
 
      params.set<NonlinearVariableName>("variable") = _displacements[i];
 
      if (_save_in.size() == _ndisp)
        params.set<std::vector<AuxVariableName>>("save_in") = {_save_in[i]};
      if (_diag_save_in.size() == _ndisp)
        params.set<std::vector<AuxVariableName>>("diag_save_in") = {_diag_save_in[i]};
      if (isParamValid("out_of_plane_strain"))
        params.set<std::vector<VariableName>>("out_of_plane_strain") = {
            getParam<VariableName>("out_of_plane_strain")};
 
      if (_use_ad)
      {
        _problem->addKernel(
            ad_prepend + tensor_kernel_type + "<RESIDUAL>", kernel_name + "_residual", params);
        _problem->addKernel(
            ad_prepend + tensor_kernel_type + "<JACOBIAN>", kernel_name + "_jacobian", params);
        _problem->haveADObjects(true);
      }
      else
        _problem->addKernel(tensor_kernel_type, kernel_name, params);
    }
 
    if (_planar_formulation == PlanarFormulation::WeakPlaneStress)
    {
      auto params = getKernelParameters("WeakPlaneStress");
      std::string wps_kernel_name = "TM_WPS_" + name();
      params.set<NonlinearVariableName>("variable") = getParam<VariableName>("out_of_plane_strain");
      _problem->addKernel("WeakPlaneStress", wps_kernel_name, params);
    }
  }
}

Referenced by LegacyTensorMechanicsAction::act(), and PoroMechanicsAction::act().

actGatherActionParameters()

void TensorMechanicsAction::actGatherActionParameters ( )

protectedinherited

Definition at line 501 of file TensorMechanicsAction.C.

{
  //
  // Gather info about all other master actions when we add variables
  //
  if (_current_task == "validate_coordinate_systems" && getParam<bool>("add_variables"))
  {
    auto actions = _awh.getActions<TensorMechanicsAction>();
    for (const auto & action : actions)
    {
      const auto size_before = _subdomain_id_union.size();
      const auto added_size = action->_subdomain_ids.size();
      _subdomain_id_union.insert(action->_subdomain_ids.begin(), action->_subdomain_ids.end());
      const auto size_after = _subdomain_id_union.size();
 
      if (size_after != size_before + added_size)
        mooseError("The block restrictions in the TensorMechanics/Master actions must be "
                   "non-overlapping.");
 
      if (added_size == 0 && actions.size() > 1)
        mooseError("No TensorMechanics/Master action can be block unrestricted if more than one "
                   "TensorMechanics/Master action is specified.");
    }
  }
}

Referenced by TensorMechanicsAction::act().

actOutputGeneration()

void TensorMechanicsAction::actOutputGeneration ( )

protectedinherited

Definition at line 427 of file TensorMechanicsAction.C.

{
  //
  // Add variables (optional)
  //
  if (_current_task == "add_aux_variable")
  {
    auto params = _factory.getValidParams("MooseVariableConstMonomial");
    params.set<MooseEnum>("order") = "CONSTANT";
    params.set<MooseEnum>("family") = "MONOMIAL";
    // Loop through output aux variables
    for (auto out : _generate_output)
    {
      // Create output helper aux variables
      _problem->addAuxVariable("MooseVariableConstMonomial", _base_name + out, params);
    }
  }
 
  //
  // Add output AuxKernels
  //
  else if (_current_task == "add_aux_kernel")
  {
    // Loop through output aux variables
    for (auto out : _generate_output)
    {
      std::string type = "";
      InputParameters params = emptyInputParameters();
 
      // RankTwoAux
      for (const auto & r2a : _ranktwoaux_table)
        for (unsigned int a = 0; a < 3; ++a)
          for (unsigned int b = 0; b < 3; ++b)
            if (r2a.first + '_' + _component_table[a] + _component_table[b] == out)
            {
              type = "RankTwoAux";
              params = _factory.getValidParams(type);
              params.set<MaterialPropertyName>("rank_two_tensor") = _base_name + r2a.second;
              params.set<unsigned int>("index_i") = a;
              params.set<unsigned int>("index_j") = b;
            }
 
      // RankTwoScalarAux
      for (const auto & r2sa : _ranktwoscalaraux_table)
        for (const auto & t : r2sa.second.second)
          if (r2sa.first + '_' + t == out)
          {
            const auto r2a = _ranktwoaux_table.find(t);
            if (r2a != _ranktwoaux_table.end())
            {
              type = "RankTwoScalarAux";
              params = _factory.getValidParams(type);
              params.set<MaterialPropertyName>("rank_two_tensor") = _base_name + r2a->second;
              params.set<MooseEnum>("scalar_type") = r2sa.second.first;
            }
            else
              mooseError("Internal error. The permitted tensor shortcuts in "
                         "'_ranktwoscalaraux_table' must be keys in the '_ranktwoaux_table'.");
          }
 
      if (type != "")
      {
        params.applyParameters(parameters());
        params.set<AuxVariableName>("variable") = _base_name + out;
        params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
        _problem->addAuxKernel(type, _base_name + out + '_' + name(), params);
      }
      else
        mooseError("Unable to add output AuxKernel");
    }
  }
}

Referenced by TensorMechanicsAction::act().

actSubdomainChecks()

void TensorMechanicsAction::actSubdomainChecks ( )

protectedinherited

Definition at line 382 of file TensorMechanicsAction.C.

{
  //
  // Do the coordinate system check only once the problem is created
  //
  if (_current_task == "setup_mesh_complete")
  {
    // get subdomain IDs
    for (auto & name : _subdomain_names)
      _subdomain_ids.insert(_mesh->getSubdomainID(name));
  }
 
  if (_current_task == "validate_coordinate_systems")
  {
    // use either block restriction list or list of all subdomains in the mesh
    const auto & check_subdomains =
        _subdomain_ids.empty() ? _problem->mesh().meshSubdomains() : _subdomain_ids;
    if (check_subdomains.empty())
      mooseError("No subdomains found");
 
    // make sure all subdomains are using the same coordinate system
    _coord_system = _problem->getCoordSystem(*check_subdomains.begin());
    for (auto subdomain : check_subdomains)
      if (_problem->getCoordSystem(subdomain) != _coord_system)
        mooseError("The TensorMechanics action requires all subdomains to have the same coordinate "
                   "system.");
 
    if (_coord_system == Moose::COORD_RZ)
    {
      if (_out_of_plane_direction != OutOfPlaneDirection::z)
        mooseError("'out_of_plane_direction' must be 'z' for axisymmetric simulations");
    }
    else if (_planar_formulation != PlanarFormulation::None)
    {
      if (_out_of_plane_direction == OutOfPlaneDirection::z && _ndisp != 2)
        mooseError(
            "Must specify two displacements for plane strain when the out of plane direction is z");
      else if (_out_of_plane_direction != OutOfPlaneDirection::z && _ndisp != 3)
        mooseError("Must specify three displacements for plane strain when the out of plane "
                   "direction is x or y");
    }
  }
}

Referenced by TensorMechanicsAction::act().

getKernelParameters()

InputParameters TensorMechanicsAction::getKernelParameters ( std::string  type )

protectedvirtualinherited

Definition at line 544 of file TensorMechanicsAction.C.

{
  InputParameters params = _factory.getValidParams(type);
  params.applyParameters(parameters(),
                         {"displacements",
                          "use_displaced_mesh",
                          "save_in",
                          "diag_save_in",
                          "out_of_plane_strain"});
 
  params.set<std::vector<VariableName>>("displacements") = _coupled_displacements;
  params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
 
  return params;
}

Referenced by TensorMechanicsAction::act().

getKernelType()

std::string DynamicTensorMechanicsAction::getKernelType ( )

protectedvirtual

Reimplemented from TensorMechanicsAction.

Definition at line 51 of file DynamicTensorMechanicsAction.C.

{
  // choose kernel type based on coordinate system
  if (_coord_system == Moose::COORD_XYZ)
    return "DynamicStressDivergenceTensors";
  else
    mooseError("Unsupported coordinate system");
}

outputPropertiesType()

MultiMooseEnum TensorMechanicsActionBase::outputPropertiesType ( )

staticinherited

Definition at line 134 of file TensorMechanicsActionBase.C.

{
  std::string options = "";
  for (auto & r2a : _ranktwoaux_table)
    for (unsigned int a = 0; a < 3; ++a)
      for (unsigned int b = 0; b < 3; ++b)
        options += (options == "" ? "" : " ") + r2a.first + '_' + _component_table[a] +
                   _component_table[b];
 
  for (auto & r2sa : _ranktwoscalaraux_table)
    for (auto & t : r2sa.second.second)
      options += " " + r2sa.first + "_" + t;
 
  return MultiMooseEnum(options);
}

Referenced by TensorMechanicsAction::validParams(), and TensorMechanicsActionBase::validParams().

validParams()

InputParameters DynamicTensorMechanicsAction::validParams ( )

static

Definition at line 26 of file DynamicTensorMechanicsAction.C.

{
  InputParameters params = TensorMechanicsAction::validParams();
  params.addClassDescription("Set up dynamic stress divergence kernels");
  params.addParam<MaterialPropertyName>("zeta",
                                        0.0,
                                        "Name of material property or a constant real "
                                        "number defining the zeta parameter for the "
                                        "Rayleigh damping.");
  params.addParam<Real>("alpha", 0, "alpha parameter for HHT time integration");
  params.addParam<bool>("static_initialization",
                        false,
                        "Set to true get the system to "
                        "equilibrium under gravity by running a "
                        "quasi-static analysis (by solving Ku = F) "
                        "in the first time step.");
  return params;
}

Member Data Documentation

_base_name

const std::string TensorMechanicsAction::_base_name

protectedinherited

base name for the current master action block

Definition at line 93 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::actOutputGeneration().

_component_table

const std::vector< char > TensorMechanicsActionBase::_component_table = {'x', 'y', 'z'}

staticinherited

Definition at line 31 of file TensorMechanicsActionBase.h.

Referenced by TensorMechanicsAction::actOutputGeneration(), and TensorMechanicsActionBase::outputPropertiesType().

_coord_system

Moose::CoordinateSystemType TensorMechanicsAction::_coord_system

protectedinherited

Definition at line 47 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::act(), TensorMechanicsAction::actSubdomainChecks(), getKernelType(), and TensorMechanicsAction::getKernelType().

_coupled_displacements

std::vector<VariableName> TensorMechanicsAction::_coupled_displacements

protectedinherited

Definition at line 39 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::act(), TensorMechanicsAction::getKernelParameters(), and TensorMechanicsAction::TensorMechanicsAction().

_diag_save_in

std::vector<AuxVariableName> TensorMechanicsAction::_diag_save_in

protectedinherited

Definition at line 44 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::act(), and TensorMechanicsAction::TensorMechanicsAction().

_displacements

std::vector<VariableName> TensorMechanicsAction::_displacements

protectedinherited

displacement variables

Definition at line 37 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::act(), and TensorMechanicsAction::TensorMechanicsAction().

_generate_output

std::vector<std::string> TensorMechanicsAction::_generate_output

protectedinherited

output aux variables to generate for sclar stress/strain tensor quantities

Definition at line 99 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::actOutputGeneration(), and TensorMechanicsAction::TensorMechanicsAction().

_ndisp

unsigned int TensorMechanicsAction::_ndisp

protectedinherited

Definition at line 38 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::act(), TensorMechanicsAction::actSubdomainChecks(), and TensorMechanicsAction::TensorMechanicsAction().

_out_of_plane_direction

const OutOfPlaneDirection TensorMechanicsAction::_out_of_plane_direction

protectedinherited

Definition at line 90 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::act(), and TensorMechanicsAction::actSubdomainChecks().

_planar_formulation

enum TensorMechanicsAction::PlanarFormulation TensorMechanicsAction::_planar_formulation

protectedinherited

Referenced by TensorMechanicsAction::act(), TensorMechanicsAction::actSubdomainChecks(), and TensorMechanicsAction::TensorMechanicsAction().

_ranktwoaux_table

const std::map< std::string, std::string > TensorMechanicsActionBase::_ranktwoaux_table

staticinherited

Initial value:

= {
    {"strain", "total_strain"},
    {"stress", "stress"},
    {"elastic_strain", "elastic_strain"},
    {"plastic_strain", "plastic_strain"},
    {"creep_strain", "creep_strain"}}

table data for output generation

Definition at line 30 of file TensorMechanicsActionBase.h.

Referenced by TensorMechanicsAction::actOutputGeneration(), and TensorMechanicsActionBase::outputPropertiesType().

_ranktwoscalaraux_table

const std::map< std::string, std::pair< std::string, std::vector< std::string > > > TensorMechanicsActionBase::_ranktwoscalaraux_table

staticinherited

Initial value:

= {
        {"vonmises", {"VonMisesStress", {"stress"}}},
        {"hydrostatic", {"Hydrostatic", {"stress"}}},
        {"max_principal", {"MaxPrincipal", {"stress"}}},
        {"mid_principal", {"MidPrincipal", {"stress"}}},
        {"min_principal", {"MinPrincipal", {"stress"}}},
        {"firstinv", {"FirstInvariant", {"stress", "strain"}}},
        {"secondinv", {"SecondInvariant", {"stress", "strain"}}},
        {"thirdinv", {"ThirdInvariant", {"stress", "strain"}}}}

Definition at line 33 of file TensorMechanicsActionBase.h.

Referenced by TensorMechanicsAction::actOutputGeneration(), and TensorMechanicsActionBase::outputPropertiesType().

_save_in

std::vector<AuxVariableName> TensorMechanicsAction::_save_in

protectedinherited

residual debugging

Definition at line 43 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::act(), and TensorMechanicsAction::TensorMechanicsAction().

_strain

enum TensorMechanicsAction::Strain TensorMechanicsAction::_strain

protectedinherited

Referenced by TensorMechanicsAction::TensorMechanicsAction().

_strain_and_increment

enum TensorMechanicsAction::StrainAndIncrement TensorMechanicsAction::_strain_and_increment

protectedinherited

Referenced by TensorMechanicsAction::act(), and TensorMechanicsAction::TensorMechanicsAction().

_subdomain_id_union

std::set<SubdomainID> TensorMechanicsAction::_subdomain_id_union

protectedinherited

set generated from the combined block restrictions of all TensorMechanics/Master action blocks

Definition at line 56 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::actGatherActionParameters().

_subdomain_ids

std::set<SubdomainID> TensorMechanicsAction::_subdomain_ids

protectedinherited

set generated from the passed in vector of subdomain names

Definition at line 53 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::actSubdomainChecks().

_subdomain_names

std::vector<SubdomainName> TensorMechanicsAction::_subdomain_names

protectedinherited

if this vector is not empty the variables, kernels and materials are restricted to these subdomains

Definition at line 50 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::actSubdomainChecks().

_use_ad

const bool TensorMechanicsActionBase::_use_ad

protectedinherited

Definition at line 37 of file TensorMechanicsActionBase.h.

Referenced by TensorMechanicsAction::act(), and PoroMechanicsAction::PoroMechanicsAction().

_use_displaced_mesh

bool TensorMechanicsAction::_use_displaced_mesh

protectedinherited

use displaced mesh (true unless _strain is SMALL)

Definition at line 96 of file TensorMechanicsAction.h.

Referenced by TensorMechanicsAction::act(), TensorMechanicsAction::getKernelParameters(), and TensorMechanicsAction::TensorMechanicsAction().

---

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

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