#include <TensorMechanicsActionBase.h>

Inheritance diagram for TensorMechanicsActionBase:

Public Member Functions
	TensorMechanicsActionBase (const InputParameters &params)

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 Attributes
const bool	_use_ad

Detailed Description

Definition at line 19 of file TensorMechanicsActionBase.h.

Constructor & Destructor Documentation

◆ TensorMechanicsActionBase()

TensorMechanicsActionBase::TensorMechanicsActionBase ( const InputParameters & params )

Definition at line 112 of file TensorMechanicsActionBase.C.

   : Action(parameters), _use_ad(getParam<bool>("use_automatic_differentiation"))
 {
   // check if a container block with common parameters is found
   auto action = _awh.getActions<CommonTensorMechanicsAction>();
   if (action.size() == 1)
     _pars.applyParameters(action[0]->parameters());
  
   // append additional_generate_output
   if (isParamValid("additional_generate_output"))
   {
     MultiMooseEnum generate_output = getParam<MultiMooseEnum>("generate_output");
     MultiMooseEnum additional_generate_output =
         getParam<MultiMooseEnum>("additional_generate_output");
     for (auto & output : additional_generate_output)
       generate_output.push_back(output);
  
     _pars.set<MultiMooseEnum>("generate_output") = generate_output;
   }
 }

Member Function Documentation

◆ outputPropertiesType()

MultiMooseEnum TensorMechanicsActionBase::outputPropertiesType ( )

static

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 validParams().

◆ validParams()

InputParameters TensorMechanicsActionBase::validParams ( )

static

Definition at line 39 of file TensorMechanicsActionBase.C.

 {
   InputParameters params = Action::validParams();
  
   params.addRequiredParam<std::vector<VariableName>>(
       "displacements", "The nonlinear displacement variables for the problem");
   params.addParam<VariableName>("temperature", "The temperature");
  
   MooseEnum strainType("SMALL FINITE", "SMALL");
   params.addParam<MooseEnum>("strain", strainType, "Strain formulation");
   params.addParam<bool>("incremental", "Use incremental or total strain");
  
   params.addParam<std::string>("base_name", "Material property base name");
   params.addParam<bool>(
       "volumetric_locking_correction", false, "Flag to correct volumetric locking");
   params.addParam<bool>(
       "use_finite_deform_jacobian", false, "Jacobian for corrotational finite strain");
   params.addParam<bool>(
       "use_displaced_mesh", false, "Whether to use displaced mesh in the kernels");
   params.addParam<bool>("add_variables", false, "Add the displacement variables");
   params.addParam<std::vector<MaterialPropertyName>>(
       "eigenstrain_names", "List of eigenstrains to be applied in this strain calculation");
   params.addParam<bool>("use_automatic_differentiation",
                         false,
                         "Flag to use automatic differentiation (AD) objects when possible");
   // Global Strain
   params.addParam<MaterialPropertyName>(
       "global_strain",
       "Name of the global strain material to be applied in this strain calculation. "
       "The global strain tensor is constant over the whole domain and allows visualization "
       "of the deformed shape with the periodic BC");
  
   // Advanced
   params.addParam<std::vector<AuxVariableName>>("save_in", "The displacement residuals");
   params.addParam<std::vector<AuxVariableName>>("diag_save_in",
                                                 "The displacement diagonal preconditioner terms");
   params.addParam<MooseEnum>("decomposition_method",
                              ComputeFiniteStrain::decompositionType(),
                              "Methods to calculate the finite strain and rotation increments");
   params.addParamNamesToGroup("save_in diag_save_in", "Advanced");
  
   // Planar Formulation
   MooseEnum planarFormulationType("NONE WEAK_PLANE_STRESS PLANE_STRAIN GENERALIZED_PLANE_STRAIN",
                                   "NONE");
   params.addParam<MooseEnum>(
       "planar_formulation", planarFormulationType, "Out-of-plane stress/strain formulation");
   params.addParam<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>("out_of_plane_strain",
                                 "Variable for the out-of-plane strain for plane stress models");
   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>("pressure_factor", 1.0, "Scale factor applied to prescribed pressure");
   params.addParamNamesToGroup("planar_formulation scalar_out_of_plane_strain out_of_plane_pressure "
                               "pressure_factor out_of_plane_direction out_of_plane_strain",
                               "Out-of-plane stress/strain");
  
   // Output
   params.addParam<MultiMooseEnum>("generate_output",
                                   TensorMechanicsActionBase::outputPropertiesType(),
                                   "Add scalar quantity output for stress and/or strain");
   params.addParamNamesToGroup("generate_output", "Output");
  
   return params;
 }

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

Member Data Documentation

◆ _component_table

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

static

Definition at line 31 of file TensorMechanicsActionBase.h.

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

◆ _ranktwoaux_table

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

static

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 outputPropertiesType().

◆ _ranktwoscalaraux_table

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

static

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"}}}}