#include <QuasiStaticSolidMechanicsPhysics.h>

Inheritance diagram for QuasiStaticSolidMechanicsPhysics:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	QuasiStaticSolidMechanicsPhysics (const InputParameters &params)

virtual void	act ()

void	timedAct ()

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

MooseObjectName	uniqueActionName () const

const std::string &	specificTaskName () const

const std::set< std::string > &	getAllTasks () const

void	appendTask (const std::string &task)

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static MultiMooseEnum	outputPropertiesType ()

static MultiMooseEnum	materialOutputOrders ()

static MultiMooseEnum	materialOutputFamilies ()

static void	addCartesianComponentOutput (const std::string &name, const std::string &prop_name="")

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	unique_action_name_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME


static const std::vector< char >	_component_table = {'x', 'y', 'z'}
	table data for output generation More...

static const std::map< std::string, std::pair< std::string, std::vector< std::string > > >	_rank_two_invariant_table

static const std::map< std::string, std::pair< std::string, std::vector< std::string > > >	_rank_two_directional_component_table

static const std::map< std::string, std::pair< std::string, std::vector< std::string > > >	_rank_two_cylindrical_component_table

static const std::map< std::string, std::pair< std::string, std::vector< std::string > > >	_rank_two_spherical_component_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 }

enum	LKFormulation { LKFormulation::Total, LKFormulation::Updated }
	New kernel system kinematics types. More...

Protected Member Functions
void	actSubdomainChecks ()

void	actOutputGeneration ()

void	actEigenstrainNames ()

void	actOutputMatProp ()

void	actGatherActionParameters ()

void	verifyOrderAndFamilyOutputs ()

void	actLagrangianKernelStrain ()

void	actStressDivergenceTensorsStrain ()

virtual std::string	getKernelType ()

virtual InputParameters	getKernelParameters (std::string type)

std::string	remapCompatOutputProp (const std::string &prop_name) const
	Apply `compatibility_mode` remapping to a property name pulled from the `_rank_two_*` output tables: in compat mode the NEW pipeline writes Cauchy stress + rotated mechanical strain under different names than the OLD pipeline. More...

template<typename T , typename T2 >
bool	setupOutput (std::string out, T table, T2 setup)
	Helper function to decode `generate_outputs` options using a "table" of scalar output quantities and a "setup" lambda that performs the input parameter setup for the output material object. More...

bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)

void	associateWithParameter (const std::string &param_name, InputParameters &params) const

void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const

const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)

const T &	getMeshProperty (const std::string &data_name)

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

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 SolidMechanics/Master action blocks More...

enum QuasiStaticSolidMechanicsPhysics::Strain	_strain

enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement	_strain_and_increment

enum QuasiStaticSolidMechanicsPhysics::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 materials to generate scalar stress/strain tensor quantities More...

MultiMooseEnum	_material_output_order

MultiMooseEnum	_material_output_family

bool	_cylindrical_axis_point1_valid
	booleans used to determine if cylindrical axis points are passed More...

bool	_cylindrical_axis_point2_valid

bool	_direction_valid

bool	_verbose

Point	_cylindrical_axis_point1
	points used to determine axis of rotation for cylindrical stress/strain quantities More...

Point	_cylindrical_axis_point2

Point	_direction

bool	_spherical_center_point_valid
	booleans used to determine if spherical center point is passed More...

Point	_spherical_center_point
	center point for spherical stress/strain quantities More...

const bool	_auto_eigenstrain
	automatically gather names of eigenstrain tensors provided by simulation objects More...

std::vector< MaterialPropertyName >	_eigenstrain_names

const bool	_compatibility_mode
	OLD-compat shim: auto-configures the Lagrangian kernel system to reproduce `StressDivergenceTensors + ComputeFiniteStrain + ComputeStressBase` bit-for-bit when set. More...

const bool	_lagrangian_kernels
	New or old kernel system. True if `new_system = true` OR `compatibility_mode = true`. More...

const bool	_lk_large_kinematics
	Simplified flag for small/large deformations, Lagrangian kernel system. More...

const LKFormulation	_lk_formulation

const bool	_lk_locking
	Simplified volumetric locking correction flag for new kernels. More...

bool	_lk_homogenization
	Flag indicating if the homogenization system is present for new kernels. More...

const std::string	_hname = "hvar"

const std::string	_integrator_name = "integrator"

const std::string	_homogenization_strain_name = "homogenization_gradient"

MultiMooseEnum	_constraint_types

std::vector< FunctionName >	_targets

const bool	_lk_h_off_jac
	Whether to use the off diagonal scalar jacobian for the homogenization system. More...

const bool	_use_ad

std::string	_registered_identifier

std::string	_specific_task_name

std::set< std::string >	_all_tasks

ActionWarehouse &	_awh

const std::string &	_current_task

std::shared_ptr< MooseMesh > &	_mesh

std::shared_ptr< MooseMesh > &	_displaced_mesh

std::shared_ptr< FEProblemBase > &	_problem

PerfID	_act_timer

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator


std::vector< VariableName >	_displacements
	displacement variables More...

unsigned int	_ndisp
	Number of displacement variables. More...

std::vector< VariableName >	_coupled_displacements
	Coupled displacement variables. More...


std::vector< AuxVariableName >	_save_in
	residual debugging More...

std::vector< AuxVariableName >	_diag_save_in

Static Protected Attributes
static const std::map< unsigned int, std::string >	_order_mapper

static std::map< std::string, std::string >	_rank_two_cartesian_component_table

Detailed Description

Definition at line 15 of file QuasiStaticSolidMechanicsPhysics.h.

Member Enumeration Documentation

◆ LKFormulation

enum QuasiStaticSolidMechanicsPhysics::LKFormulation

strongprotected

New kernel system kinematics types.

Enumerator
Total
Updated

Definition at line 154 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     Total,
     Updated
   };

◆ OutOfPlaneDirection

enum QuasiStaticSolidMechanicsPhysics::OutOfPlaneDirection

strongprotected

Enumerator
x
y
z

Definition at line 101 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     x,
     y,
     z
   };

◆ PlanarFormulation

enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation

strongprotected

use an out of plane stress/strain formulation

Enumerator
None
WeakPlaneStress
PlaneStrain
GeneralizedPlaneStrain

Definition at line 93 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ Strain

enum QuasiStaticSolidMechanicsPhysics::Strain

strongprotected

strain formulation

Enumerator
Small
Finite

Definition at line 77 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     Small,
     Finite
   } _strain;

◆ StrainAndIncrement

enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement

strongprotected

strain formulation

Enumerator
SmallTotal
FiniteTotal
SmallIncremental
FiniteIncremental

Definition at line 84 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     SmallTotal,
     FiniteTotal,
     SmallIncremental,
     FiniteIncremental
   } _strain_and_increment;

Constructor & Destructor Documentation

◆ QuasiStaticSolidMechanicsPhysics()

QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics ( const InputParameters & params )

Definition at line 133 of file QuasiStaticSolidMechanicsPhysics.C.

   : QuasiStaticSolidMechanicsPhysicsBase(params),
     _displacements(getParam<std::vector<VariableName>>("displacements")),
     _ndisp(_displacements.size()),
     _coupled_displacements(_ndisp),
     _save_in(getParam<std::vector<AuxVariableName>>("save_in")),
     _diag_save_in(getParam<std::vector<AuxVariableName>>("diag_save_in")),
     _subdomain_names(getParam<std::vector<SubdomainName>>("block")),
     _subdomain_ids(),
     _strain(getParam<MooseEnum>("strain").getEnum<Strain>()),
     _planar_formulation(getParam<MooseEnum>("planar_formulation").getEnum<PlanarFormulation>()),
     _out_of_plane_direction(
         getParam<MooseEnum>("out_of_plane_direction").getEnum<OutOfPlaneDirection>()),
     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
     _material_output_order(getParam<MultiMooseEnum>("material_output_order")),
     _material_output_family(getParam<MultiMooseEnum>("material_output_family")),
     _cylindrical_axis_point1_valid(params.isParamSetByUser("cylindrical_axis_point1")),
     _cylindrical_axis_point2_valid(params.isParamSetByUser("cylindrical_axis_point2")),
     _direction_valid(params.isParamSetByUser("direction")),
     _verbose(getParam<bool>("verbose")),
     _spherical_center_point_valid(params.isParamSetByUser("spherical_center_point")),
     _auto_eigenstrain(getParam<bool>("automatic_eigenstrain_names")),
     _compatibility_mode(getParam<bool>("compatibility_mode")),
     _lagrangian_kernels(getParam<bool>("new_system") || _compatibility_mode),
     _lk_large_kinematics(_strain == Strain::Finite),
     // compatibility_mode mandates the total Lagrangian kernel; otherwise honor the user choice.
     _lk_formulation(_compatibility_mode
                         ? LKFormulation::Total
                         : getParam<MooseEnum>("formulation").getEnum<LKFormulation>()),
     _lk_locking(getParam<bool>("volumetric_locking_correction")),
     _lk_homogenization(false),
     _constraint_types(getParam<MultiMooseEnum>("constraint_types")),
     _targets(getParam<std::vector<FunctionName>>("targets")),
     _lk_h_off_jac(getParam<bool>("homogenized_off_diagonal_jacobian"))
 {
   // determine if incremental strains are to be used
   if (isParamValid("incremental"))
   {
     const bool incremental = getParam<bool>("incremental");
     if (!incremental && _strain == Strain::Small)
       _strain_and_increment = StrainAndIncrement::SmallTotal;
     else if (!incremental && _strain == Strain::Finite)
       _strain_and_increment = StrainAndIncrement::FiniteTotal;
     else if (incremental && _strain == Strain::Small)
       _strain_and_increment = StrainAndIncrement::SmallIncremental;
     else if (incremental && _strain == Strain::Finite)
       _strain_and_increment = StrainAndIncrement::FiniteIncremental;
     else
       mooseError("Internal error");
   }
   else
   {
     if (_strain == Strain::Small)
     {
       _strain_and_increment = StrainAndIncrement::SmallTotal;
       mooseInfo("SolidMechanics Action: selecting 'total small strain' formulation. Use "
                 "`incremental = true` to select 'incremental small strain' instead.");
     }
     else if (_strain == Strain::Finite)
     {
       _strain_and_increment = StrainAndIncrement::FiniteIncremental;
       mooseInfo("SolidMechanics Action: selecting 'incremental finite strain' formulation.");
     }
     else
       mooseError("Internal error");
   }
 
   // determine if displaced mesh is to be used
   _use_displaced_mesh = (_strain == Strain::Finite);
   if (params.isParamSetByUser("use_displaced_mesh") && !_lagrangian_kernels)
   {
     bool use_displaced_mesh_param = getParam<bool>("use_displaced_mesh");
     if (use_displaced_mesh_param != _use_displaced_mesh && params.isParamSetByUser("strain"))
       mooseError("Wrong combination of use displaced mesh and strain model");
     _use_displaced_mesh = use_displaced_mesh_param;
   }
 
   // convert vector of VariableName to vector of VariableName
   for (unsigned int i = 0; i < _ndisp; ++i)
     _coupled_displacements[i] = _displacements[i];
 
   if (_save_in.size() != 0 && _save_in.size() != _ndisp)
     mooseError("Number of save_in variables should equal to the number of displacement variables ",
                _ndisp);
 
   if (_diag_save_in.size() != 0 && _diag_save_in.size() != _ndisp)
     mooseError(
         "Number of diag_save_in variables should equal to the number of displacement variables ",
         _ndisp);
 
   // plane strain consistency check
   if (_planar_formulation != PlanarFormulation::None)
   {
     if (_lagrangian_kernels)
       mooseDocumentedError(
           "moose",
           27340,
           "Planar formulations are not yet available through the Physics syntax with new_system = "
           "true. They can be enabled by manually setting up the appropriate objects. Please refer "
           "to the documentation and regression tests for examples.");
     if (params.isParamSetByUser("out_of_plane_strain") &&
         _planar_formulation != PlanarFormulation::WeakPlaneStress)
       mooseError(
           "out_of_plane_strain should only be specified with planar_formulation=WEAK_PLANE_STRESS");
     else if (!params.isParamSetByUser("out_of_plane_strain") &&
              _planar_formulation == PlanarFormulation::WeakPlaneStress)
       mooseError("out_of_plane_strain must be specified with planar_formulation=WEAK_PLANE_STRESS");
   }
 
   // convert output variable names to lower case
   for (const auto & out : getParam<MultiMooseEnum>("generate_output"))
   {
     std::string lower(out);
     std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
     _generate_output.push_back(lower);
   }
 
   if (!_generate_output.empty())
     verifyOrderAndFamilyOutputs();
 
   // Error if volumetric locking correction is true for 1D problems
   if (_ndisp == 1 && getParam<bool>("volumetric_locking_correction"))
     mooseError("Volumetric locking correction should be set to false for 1D problems.");
 
   if (!getParam<bool>("add_variables") && params.isParamSetByUser("scaling"))
     paramError("scaling",
                "The scaling parameter has no effect unless add_variables is set to true. Did you "
                "mean to set 'add_variables = true'?");
 
   // Get cylindrical axis points if set by user
   if (_cylindrical_axis_point1_valid && _cylindrical_axis_point2_valid)
   {
     _cylindrical_axis_point1 = getParam<Point>("cylindrical_axis_point1");
     _cylindrical_axis_point2 = getParam<Point>("cylindrical_axis_point2");
   }
 
   // Get spherical center point if set by user
   if (_spherical_center_point_valid)
     _spherical_center_point = getParam<Point>("spherical_center_point");
 
   // Get direction for tensor component if set by user
   if (_direction_valid)
     _direction = getParam<Point>("direction");
 
   // Get eigenstrain names if passed by user
   _eigenstrain_names = getParam<std::vector<MaterialPropertyName>>("eigenstrain_names");
 
   // Determine if we're going to use the homogenization system for the new
   // lagrangian kernels
   bool ctype_set = params.isParamSetByUser("constraint_types");
   bool targets_set = params.isParamSetByUser("targets");
   if (ctype_set || targets_set)
   {
     if (!(ctype_set && targets_set))
       mooseError("To use the Lagrangian kernel homogenization system you "
                  "most provide both the constraint_types and the targets "
                  "parameters");
     _lk_homogenization = true;
     // Do consistency checking on the kernel options
     if (_lk_homogenization && (_lk_formulation == LKFormulation::Updated))
       mooseError("The Lagrangian kernel homogenization system requires the "
                  "use of formulation = TOTAL");
   }
 
   // The action drives two mutually exclusive kernel systems: the legacy
   // StressDivergenceTensors + ComputeFiniteStrain system, and the new Lagrangian kernel system
   // (new_system / compatibility_mode). Many parameters belong exclusively to one system; setting
   // one that does not match the active system is almost always a copy-paste error, so reject it
   // explicitly with a clear message instead of silently ignoring it. The lists below are the
   // single place to register a parameter as system-specific.
   static const std::vector<std::string> new_system_only = {
       "formulation", "constraint_types", "targets", "homogenized_off_diagonal_jacobian"};
   static const std::vector<std::string> legacy_only = {"use_finite_deform_jacobian",
                                                        "global_strain"};
 
   if (_lagrangian_kernels)
   {
     for (const auto & p : legacy_only)
       if (params.isParamSetByUser(p))
         paramError(p,
                    "'",
                    p,
                    "' belongs to the legacy StressDivergenceTensors kernel system and cannot be "
                    "combined with new_system = true or compatibility_mode = true. The Lagrangian "
                    "kernel system produces the exact Jacobian natively; homogenization replaces "
                    "global_strain.");
 
     // use_automatic_differentiation is a value (defaults false); reject only when requested.
     if (_use_ad)
       paramError("use_automatic_differentiation",
                  "The Lagrangian kernel system is not yet compatible with automatic "
                  "differentiation.");
 
     // decomposition_method is legal only in compatibility_mode, where it maps to the strain
     // calculator's kinematic_approximation; plain new_system exposes those options directly on the
     // ComputeLagrangianStrain material via `kinematic_approximation`.
     if (params.isParamSetByUser("decomposition_method") && !_compatibility_mode)
       paramError("decomposition_method",
                  "decomposition_method is not used by the Lagrangian kernel system. Set the "
                  "equivalent option on the ComputeLagrangianStrain material via "
                  "kinematic_approximation instead.");
 
     // compatibility_mode-specific consistency checks.
     if (_compatibility_mode)
     {
       if (params.isParamSetByUser("formulation") &&
           getParam<MooseEnum>("formulation").getEnum<LKFormulation>() != LKFormulation::Total)
         paramError("formulation",
                    "compatibility_mode requires formulation = TOTAL (the OLD kernel system is "
                    "always total Lagrangian on the displaced mesh).");
 
       if (_lk_large_kinematics && params.isParamSetByUser("kinematic_approximation"))
         paramError("kinematic_approximation",
                    "compatibility_mode derives kinematic_approximation from decomposition_method; "
                    "do not set it explicitly.");
       if (_lk_locking && _lk_large_kinematics &&
           params.isParamSetByUser("volumetric_locking_correction_mode"))
         paramError("volumetric_locking_correction_mode",
                    "compatibility_mode derives the F-bar mode from volumetric_locking_correction; "
                    "do not set volumetric_locking_correction_mode explicitly.");
       if (params.isParamSetByUser("generalized_midpoint_alpha"))
         paramError("generalized_midpoint_alpha",
                    "compatibility_mode reproduces the legacy backward-Euler update; do not set "
                    "generalized_midpoint_alpha explicitly.");
 
       // Validate decomposition_method <-> kinematic_approximation mapping. The NEW strain
       // calculator's `rashid_approximate` and `rashid_eigen` reproduce OLD's `TaylorExpansion`
       // and `EigenSolution` exactly; OLD's `HughesWinget` has no NEW counterpart.
       if (_lk_large_kinematics)
       {
         const std::string decomp = getParam<MooseEnum>("decomposition_method");
         if (decomp != "TaylorExpansion" && decomp != "EigenSolution")
           paramError("decomposition_method",
                      "compatibility_mode + strain = FINITE supports only "
                      "decomposition_method = TaylorExpansion or EigenSolution; '",
                      decomp,
                      "' has no Lagrangian kinematic_approximation counterpart.");
       }
     }
   }
   else
   {
     for (const auto & p : new_system_only)
       if (params.isParamSetByUser(p))
         paramError(p,
                    "'",
                    p,
                    "' belongs to the new Lagrangian kernel system. Set new_system = true (or "
                    "compatibility_mode = true) to use it.");
   }
 }

Member Function Documentation

◆ act()

void QuasiStaticSolidMechanicsPhysics::act ( )

virtual

Implements Action.

Reimplemented in LegacyDynamicTensorMechanicsAction, LegacyTensorMechanicsAction, PoroMechanicsAction, and DynamicSolidMechanicsPhysics.

Definition at line 386 of file QuasiStaticSolidMechanicsPhysics.C.

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

 {
   std::string ad_prepend = "";
   if (_use_ad)
     ad_prepend = "AD";
 
   // Consistency checks across subdomains
   actSubdomainChecks();
 
   // Gather info from all other QuasiStaticSolidMechanicsPhysics
   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_automatic_differentiation", "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)";
 
       // Skipping selected parameters in applyParameters() and then manually setting them only if
       // they are set by the user is just to prevent both the current and deprecated variants of
       // these parameters from both getting passed to the UserObject. Once we get rid of the
       // deprecated versions, we can just set them all with applyParameters().
       action_params.applyParameters(parameters(),
                                     {"use_displaced_mesh",
                                      "out_of_plane_pressure",
                                      "out_of_plane_pressure_function",
                                      "factor",
                                      "pressure_factor"});
       action_params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
 
       if (parameters().isParamSetByUser("out_of_plane_pressure"))
         action_params.set<FunctionName>("out_of_plane_pressure") =
             getParam<FunctionName>("out_of_plane_pressure");
       if (parameters().isParamSetByUser("out_of_plane_pressure_function"))
         action_params.set<FunctionName>("out_of_plane_pressure_function") =
             getParam<FunctionName>("out_of_plane_pressure_function");
       if (parameters().isParamSetByUser("factor"))
         action_params.set<Real>("factor") = getParam<Real>("factor");
       if (parameters().isParamSetByUser("pressure_factor"))
         action_params.set<Real>("pressure_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);
     }
   }
 
   // Add variables
   else if (_current_task == "add_variable")
   {
     // Add variables here only if the CommonSolidMechanicsAction does not exist.
     // This happens notably if the QuasiStaticSolidMechanics was created by a meta_action
     const auto common_actions = _awh.getActions<CommonSolidMechanicsAction>();
     if (common_actions.empty() && 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";
       if (isParamValid("scaling"))
         params.set<std::vector<Real>>("scaling") = {getParam<Real>("scaling")};
 
       // Note how we do not add the block restriction because BISON's meta-actions
       // currently rely on them not being added.
 
       // Loop through the displacement variables
       for (const auto & disp : _displacements)
       {
         // Create displacement variables
         _problem->addVariable("MooseVariable", disp, params);
       }
     }
 
     // Homogenization scalar
     if (_lk_homogenization)
     {
       InputParameters params = _factory.getValidParams("MooseVariable");
       const std::map<bool, std::vector<unsigned int>> mg_order_max{{true, {1, 4, 9}},
                                                                    {false, {1, 3, 6}}};
       std::size_t mg_order = 0;
       for (auto i : index_range(_constraint_types))
       {
         const auto ctype = static_cast<Homogenization::ConstraintType>(_constraint_types.get(i));
         if (ctype != Homogenization::ConstraintType::None)
           mg_order++;
       }
       if (mg_order > mg_order_max.at(_lk_large_kinematics)[_ndisp - 1])
         paramError("constraint_types",
                    "Number of non-none constraint types must not be greater than ",
                    mg_order_max.at(_lk_large_kinematics)[_ndisp - 1],
                    ", but ",
                    mg_order,
                    " are provided.");
       params.set<MooseEnum>("family") = "SCALAR";
       params.set<MooseEnum>("order") = mg_order;
       auto fe_type = AddVariableAction::feType(params);
       auto var_type = AddVariableAction::variableType(fe_type);
       _problem->addVariable(var_type, _hname, params);
     }
   }
   // Add Materials
   else if (_current_task == "add_master_action_material")
   {
     // Automatic eigenstrain names
     if (_auto_eigenstrain)
       actEigenstrainNames();
 
     // Easiest just to branch on type here, as the strain systems are completely
     // different
     if (_lagrangian_kernels)
       actLagrangianKernelStrain();
     else
       actStressDivergenceTensorsStrain();
   }
 
   // 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);
 
       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") && !_lagrangian_kernels)
         params.set<std::vector<VariableName>>("out_of_plane_strain") = {
             getParam<VariableName>("out_of_plane_strain")};
 
       if (_lk_homogenization)
       {
         params.set<std::vector<VariableName>>("scalar_variable") = {_hname};
         params.set<MultiMooseEnum>("constraint_types") = _constraint_types;
         params.set<std::vector<FunctionName>>("targets") = _targets;
       }
 
       _problem->addKernel(ad_prepend + tensor_kernel_type, kernel_name, params);
     }
 
     if (_planar_formulation == PlanarFormulation::WeakPlaneStress)
     {
       auto params = getKernelParameters(ad_prepend + "WeakPlaneStress");
       std::string wps_kernel_name = "TM_WPS_" + name();
       params.set<NonlinearVariableName>("variable") = getParam<VariableName>("out_of_plane_strain");
 
       _problem->addKernel(ad_prepend + "WeakPlaneStress", wps_kernel_name, params);
     }
   }
 }

◆ actEigenstrainNames()

void QuasiStaticSolidMechanicsPhysics::actEigenstrainNames ( )

protected

Definition at line 695 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

 {
   // Create containers for collecting blockIDs and eigenstrain names from materials
   std::map<std::string, std::set<SubdomainID>> material_eigenstrain_map;
   std::set<std::string> eigenstrain_set;
 
   std::set<MaterialPropertyName> verified_eigenstrain_names;
 
   std::map<std::string, std::string> remove_add_map;
   std::set<std::string> remove_reduced_set;
 
   // Loop over all the materials(eigenstrains) already created
   auto materials = _problem->getMaterialWarehouse().getObjects();
   for (auto & mat : materials)
   {
     std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(mat);
     const InputParameters & mat_params = mat->parameters();
     auto & mat_name = mat->type();
 
     // Check for eigenstrain names, only deal with those materials
     if (mat_params.isParamValid("eigenstrain_name"))
     {
       std::shared_ptr<MaterialData> mat_dat;
       auto name = mat_params.get<std::string>("eigenstrain_name");
 
       // Check for base_name prefix
       if (mat_params.isParamValid("base_name"))
         name = mat_params.get<std::string>("base_name") + '_' + name;
 
       // Check block restrictions
       if (!blk)
         mooseError("Internal error, Material object that does not inherit form BlockRestricted");
       const std::set<SubdomainID> & blocks =
           blk->blockRestricted() ? blk->blockIDs() : blk->meshBlockIDs();
 
       if (std::includes(blocks.begin(), blocks.end(), _subdomain_ids.begin(), _subdomain_ids.end()))
       {
         material_eigenstrain_map[name].insert(blocks.begin(), blocks.end());
         eigenstrain_set.insert(name);
       }
     }
 
     // Account for reduced eigenstrains and CompositeEigenstrains
     if (mat_name == "ComputeReducedOrderEigenstrain")
     {
       auto input_eigenstrain_names =
           mat_params.get<std::vector<MaterialPropertyName>>("input_eigenstrain_names");
       remove_reduced_set.insert(input_eigenstrain_names.begin(), input_eigenstrain_names.end());
     }
     // Account for CompositeEigenstrains
     if (mat_name == "CompositeEigenstrain")
     {
       auto remove_list = mat_params.get<std::vector<MaterialPropertyName>>("tensors");
       for (auto i : remove_list)
         remove_reduced_set.insert(i);
     }
 
     // Account for MaterialADConverter , add or remove later
     if (mat_name == "RankTwoTensorMaterialADConverter")
     {
       std::vector<MaterialPropertyName> remove_list;
       std::vector<MaterialPropertyName> add_list;
 
       if (mat_params.isParamValid("ad_props_out") && mat_params.isParamValid("reg_props_in") &&
           _use_ad)
       {
         remove_list = mat_params.get<std::vector<MaterialPropertyName>>("reg_props_in");
         add_list = mat_params.get<std::vector<MaterialPropertyName>>("ad_props_out");
       }
       if (mat_params.isParamValid("ad_props_in") && mat_params.isParamValid("reg_props_out") &&
           !_use_ad)
       {
         remove_list = mat_params.get<std::vector<MaterialPropertyName>>("ad_props_in");
         add_list = mat_params.get<std::vector<MaterialPropertyName>>("reg_props_out");
       }
 
       // These vectors are the same size as checked in MaterialADConverter
       for (unsigned int index = 0; index < remove_list.size(); index++)
         remove_add_map.emplace(remove_list[index], add_list[index]);
     }
   }
   // All the materials have been accounted for, now remove or add parts
 
   // Remove names which aren't eigenstrains (converter properties)
   for (auto remove_add_index : remove_add_map)
   {
     const bool is_in = eigenstrain_set.find(remove_add_index.first) != eigenstrain_set.end();
     if (is_in)
     {
       eigenstrain_set.erase(remove_add_index.first);
       eigenstrain_set.insert(remove_add_index.second);
     }
   }
   for (auto index : remove_reduced_set)
     eigenstrain_set.erase(index);
 
   // Compare the blockIDs set of eigenstrain names with the vector of _eigenstrain_names for the
   // current subdomainID
   std::set_union(eigenstrain_set.begin(),
                  eigenstrain_set.end(),
                  _eigenstrain_names.begin(),
                  _eigenstrain_names.end(),
                  std::inserter(verified_eigenstrain_names, verified_eigenstrain_names.begin()));
 
   // Ensure the eigenstrain names previously passed include any missing names
   _eigenstrain_names.resize(verified_eigenstrain_names.size());
   std::copy(verified_eigenstrain_names.begin(),
             verified_eigenstrain_names.end(),
             _eigenstrain_names.begin());
 
   Moose::out << COLOR_CYAN << "*** Automatic Eigenstrain Names ***"
              << "\n"
              << _name << ": " << Moose::stringify(_eigenstrain_names) << "\n"
              << COLOR_DEFAULT << std::flush;
 }

◆ actGatherActionParameters()

void QuasiStaticSolidMechanicsPhysics::actGatherActionParameters ( )

protected

Definition at line 989 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

 {
   // Gather info about all other solid mechanics physics when we add variables
   if (_current_task == "validate_coordinate_systems" && getParam<bool>("add_variables"))
   {
     auto actions = _awh.getActions<QuasiStaticSolidMechanicsPhysics>();
     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 SolidMechanics/QuasiStatic actions must be "
                    "non-overlapping.");
 
       if (added_size == 0 && actions.size() > 1)
         mooseError(
             "No SolidMechanics/QuasiStatic action can be block unrestricted if more than one "
             "SolidMechanics/QuasiStatic action is specified.");
     }
   }
 }

◆ actLagrangianKernelStrain()

void QuasiStaticSolidMechanicsPhysics::actLagrangianKernelStrain ( )

protected

Definition at line 1015 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

 {
   std::string type;
   if (_coord_system == Moose::COORD_XYZ)
     type = "ComputeLagrangianStrain";
   else if (_coord_system == Moose::COORD_RZ)
     type = "ComputeLagrangianStrainAxisymmetricCylindrical";
   else if (_coord_system == Moose::COORD_RSPHERICAL)
     type = "ComputeLagrangianStrainCentrosymmetricSpherical";
   else
     mooseError("Unsupported coordinate system");
 
   auto params = _factory.getValidParams(type);
 
   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<std::vector<MaterialPropertyName>>("eigenstrain_names") = _eigenstrain_names;
   params.set<bool>("large_kinematics") = _lk_large_kinematics;
   params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
   // Error if volumetric locking correction is on for higher-order elements
   if (_problem->mesh().hasSecondOrderElements() && _lk_locking)
     mooseError("Volumetric locking correction should not be used for "
                "higher-order elements.");
 
   params.set<bool>("stabilize_strain") = _lk_locking;
 
   // Forward the strain time-integration options.  In compatibility mode kinematic_approximation
   // and F_bar_mode are overridden below (and the action errors if the user also set them).
   params.set<MooseEnum>("kinematic_approximation") = getParam<MooseEnum>("kinematic_approximation");
   params.set<Real>("alpha") = getParam<Real>("generalized_midpoint_alpha");
   params.set<MooseEnum>("F_bar_mode") = getParam<MooseEnum>("volumetric_locking_correction_mode");
 
   if (_lk_homogenization)
   {
     params.set<std::vector<MaterialPropertyName>>("homogenization_gradient_names") = {
         _homogenization_strain_name};
   }
 
   // OLD-compat configuration: map decomposition_method -> kinematic_approximation, switch the
   // F-bar to incremental mode (matches OLD `ComputeFiniteStrain`'s `_Fhat` F-bar), and have
   // the strain calc publish a real rotation_increment so the wrapped ComputeStressBase
   // material's FSR rotates correctly across steps.
   if (_compatibility_mode)
   {
     if (_lk_large_kinematics)
     {
       const std::string decomp = getParam<MooseEnum>("decomposition_method");
       if (decomp == "TaylorExpansion")
         params.set<MooseEnum>("kinematic_approximation") = "rashid_approximate";
       else if (decomp == "EigenSolution")
         params.set<MooseEnum>("kinematic_approximation") = "rashid_eigen";
       // HughesWinget rejected in the ctor; SMALL strain ignores kinematic_approximation.
     }
 
     // OLD's `volumetric_locking_correction = true` in incremental finite strain maps to
     // `F_bar_mode = incremental` on the NEW strain calc. The strain calc rejects
     // `incremental` for small kinematics -- for SMALL + locking we leave `F_bar_mode` at its
     // default (`total`), which is the additive trace correction (matches OLD's small-strain
     // B-bar in the locked-flag-equivalent form).
     if (_lk_locking && _lk_large_kinematics)
       params.set<MooseEnum>("F_bar_mode") = "incremental";
 
     // Only meaningful with FINITE -- in SMALL the wrap runs in passthrough-off mode and the
     // rotation increment isn't consumed downstream.
     params.set<bool>("publish_rotation_increment") = _lk_large_kinematics;
   }
 
   _problem->addMaterial(type, name() + "_strain", params);
 
   // OLD-compat configuration: auto-add ComputeLagrangianWrappedStress around the user's
   // ComputeStressBase-style stress material. `input_stress = "stress"` and
   // `input_jacobian = "Jacobian_mult"` default to the property names every
   // ComputeStressBase descendant publishes.
   if (_compatibility_mode)
   {
     const std::string wrap_type = "ComputeLagrangianWrappedStress";
     auto wrap_params = _factory.getValidParams(wrap_type);
     if (isParamValid("base_name"))
       wrap_params.set<std::string>("base_name") = getParam<std::string>("base_name");
     wrap_params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
     // large_kinematics is derived from the strain calculator's LARGE_KINEMATICS guarantee.
     wrap_params.set<MooseEnum>("objective_rate") = "rashid";
     // FINITE: the wrap runs in passthrough mode (the wrapped material's FSR already produced
     // the correctly-rotated cumulative Cauchy stress, fed by our published rotation_increment).
     // SMALL: nothing to rotate, plain Cauchy passthrough via the rate's small-kinematics branch.
     wrap_params.set<bool>("rotate_old_stress") = _lk_large_kinematics;
     _problem->addMaterial(wrap_type, name() + "_compatibility_wrap", wrap_params);
   }
 
   // Add the homogenization strain calculator
   if (_lk_homogenization)
   {
     std::string type = "ComputeHomogenizedLagrangianStrain";
     auto params = _factory.getValidParams(type);
 
     params.set<MaterialPropertyName>("homogenization_gradient_name") = _homogenization_strain_name;
     params.set<std::vector<VariableName>>("macro_gradient") = {_hname};
     params.set<MultiMooseEnum>("constraint_types") = _constraint_types;
     params.set<std::vector<FunctionName>>("targets") = _targets;
 
     _problem->addMaterial(type, name() + "_compute_" + _homogenization_strain_name, params);
   }
 }

◆ actOutputGeneration()

void QuasiStaticSolidMechanicsPhysics::actOutputGeneration ( )

protected

Definition at line 614 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

 {
   if (_current_task == "add_material")
     actOutputMatProp();
 
   // Add variables (optional)
   if (_current_task == "add_aux_variable")
   {
     unsigned int index = 0;
     for (auto out : _generate_output)
     {
       const auto & order = _material_output_order[index];
       const auto & family = _material_output_family[index];
 
       std::string type = (order == "CONSTANT" && family == "MONOMIAL")
                              ? "MooseVariableConstMonomial"
                              : "MooseVariable";
 
       // Create output helper aux variables
       auto params = _factory.getValidParams(type);
       params.set<MooseEnum>("order") = order;
       params.set<MooseEnum>("family") = family;
 
       if (family == "MONOMIAL")
         _problem->addAuxVariable(type, _base_name + out, params);
       else
         _problem->addVariable(type, _base_name + out, params);
 
       index++;
     }
   }
 
   // Add output AuxKernels
   else if (_current_task == "add_aux_kernel")
   {
     std::string ad_prepend = _use_ad ? "AD" : "";
     // Loop through output aux variables
     unsigned int index = 0;
     for (auto out : _generate_output)
     {
       if (_material_output_family[index] == "MONOMIAL")
       {
         InputParameters params = emptyInputParameters();
 
         params = _factory.getValidParams("MaterialRealAux");
         params.applyParameters(parameters());
         params.set<MaterialPropertyName>("property") = _base_name + out;
         params.set<AuxVariableName>("variable") = _base_name + out;
         params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
 
         _problem->addAuxKernel(
             ad_prepend + "MaterialRealAux", _base_name + out + '_' + name(), params);
       }
       index++;
     }
   }
   else if (_current_task == "add_kernel")
   {
     std::string ad_prepend = _use_ad ? "AD" : "";
     // Loop through output aux variables
     unsigned int index = 0;
     for (auto out : _generate_output)
     {
       if (_material_output_family[index] != "MONOMIAL")
       {
         InputParameters params = emptyInputParameters();
 
         params = _factory.getValidParams("MaterialPropertyValue");
         params.applyParameters(parameters());
         params.set<MaterialPropertyName>("prop_name") = _base_name + out;
         params.set<NonlinearVariableName>("variable") = _base_name + out;
 
         _problem->addKernel(
             ad_prepend + "MaterialPropertyValue", _base_name + out + '_' + name(), params);
       }
       index++;
     }
   }
 }

◆ actOutputMatProp()

void QuasiStaticSolidMechanicsPhysics::actOutputMatProp ( )

protected

Definition at line 879 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by actOutputGeneration().

 {
   std::string ad_prepend = _use_ad ? "AD" : "";
 
   if (_current_task == "add_material")
   {
     // Add output Materials
     for (auto out : _generate_output)
     {
       InputParameters params = emptyInputParameters();
 
       // RankTwoCartesianComponent
       if (
           [&]()
           {
             for (const auto & r2q : _rank_two_cartesian_component_table)
               for (unsigned int a = 0; a < 3; ++a)
                 for (unsigned int b = 0; b < 3; ++b)
                   if (r2q.first + '_' + _component_table[a] + _component_table[b] == out)
                   {
                     auto type = ad_prepend + "RankTwoCartesianComponent";
                     params = _factory.getValidParams(type);
                     params.set<MaterialPropertyName>("rank_two_tensor") =
                         _base_name + remapCompatOutputProp(r2q.second);
                     params.set<unsigned int>("index_i") = a;
                     params.set<unsigned int>("index_j") = b;
 
                     params.applyParameters(parameters());
                     params.set<MaterialPropertyName>("property_name") = _base_name + out;
                     _problem->addMaterial(type, _base_name + out + '_' + name(), params);
                     return true;
                   }
             return false;
           }())
         continue;
 
       // RankTwoDirectionalComponent
       if (setupOutput(out,
                       _rank_two_directional_component_table,
                       [&](std::string prop_name, std::string invariant)
                       {
                         auto type = ad_prepend + "RankTwoDirectionalComponent";
                         params = _factory.getValidParams(type);
                         params.set<MaterialPropertyName>("rank_two_tensor") =
                             _base_name + remapCompatOutputProp(prop_name);
                         params.set<MooseEnum>("invariant") = invariant;
                         params.applyParameters(parameters());
                         params.set<MaterialPropertyName>("property_name") = _base_name + out;
                         _problem->addMaterial(type, _base_name + out + '_' + name(), params);
                       }))
         continue;
 
       // RankTwoInvariant
       if (setupOutput(out,
                       _rank_two_invariant_table,
                       [&](std::string prop_name, std::string invariant)
                       {
                         auto type = ad_prepend + "RankTwoInvariant";
                         params = _factory.getValidParams(type);
                         params.set<MaterialPropertyName>("rank_two_tensor") =
                             _base_name + remapCompatOutputProp(prop_name);
                         params.set<MooseEnum>("invariant") = invariant;
                         params.applyParameters(parameters());
                         params.set<MaterialPropertyName>("property_name") = _base_name + out;
                         _problem->addMaterial(type, _base_name + out + '_' + name(), params);
                       }))
         continue;
 
       // RankTwoCylindricalComponent
       if (setupOutput(
               out,
               _rank_two_cylindrical_component_table,
               [&](std::string prop_name, std::string component)
               {
                 if (_coord_system == Moose::COORD_RSPHERICAL)
                   mooseError(
                       "Cannot use cylindrical component output in a spherical coordinate system.");
                 auto type = ad_prepend + "RankTwoCylindricalComponent";
                 params = _factory.getValidParams(type);
                 params.set<MaterialPropertyName>("rank_two_tensor") =
                     _base_name + remapCompatOutputProp(prop_name);
                 params.set<MooseEnum>("cylindrical_component") = component;
                 params.applyParameters(parameters());
                 params.set<MaterialPropertyName>("property_name") = _base_name + out;
                 _problem->addMaterial(type, _base_name + out + '_' + name(), params);
               }))
         continue;
 
       // RankTwoSphericalComponent
       if (setupOutput(out,
                       _rank_two_spherical_component_table,
                       [&](std::string prop_name, std::string component)
                       {
                         auto type = ad_prepend + "RankTwoSphericalComponent";
                         params = _factory.getValidParams(type);
                         params.set<MaterialPropertyName>("rank_two_tensor") =
                             _base_name + remapCompatOutputProp(prop_name);
                         params.set<MooseEnum>("spherical_component") = component;
                         params.applyParameters(parameters());
                         params.set<MaterialPropertyName>("property_name") = _base_name + out;
                         _problem->addMaterial(type, _base_name + out + '_' + name(), params);
                       }))
         continue;
 
       paramError("generate_output", "Unable to add output Material for '", out, "'");
     }
   }
 }

◆ actStressDivergenceTensorsStrain()

void QuasiStaticSolidMechanicsPhysics::actStressDivergenceTensorsStrain ( )

protected

Definition at line 1123 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

 {
   std::string ad_prepend = _use_ad ? "AD" : "";
 
   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}, "ComputeIncrementalStrain"},
         {{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 && (_planar_formulation == PlanarFormulation::PlaneStrain ||
                     _planar_formulation == PlanarFormulation::GeneralizedPlaneStrain))
       paramError("use_automatic_differentiation",
                  "AD not setup for use with 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);
   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")};
 
   params.set<std::vector<MaterialPropertyName>>("eigenstrain_names") = _eigenstrain_names;
 
   _problem->addMaterial(ad_prepend + type, name() + "_strain", params);
 }

◆ actSubdomainChecks()

void QuasiStaticSolidMechanicsPhysics::actSubdomainChecks ( )

protected

Definition at line 565 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

 {
   // 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)
     {
       auto id = _mesh->getSubdomainID(name);
       if (id == Moose::INVALID_BLOCK_ID)
         paramError("block", "Subdomain \"" + name + "\" not found in mesh.");
       else
         _subdomain_ids.insert(id);
     }
   }
 
   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 SolidMechanics 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");
     }
   }
 }

◆ addCartesianComponentOutput()

void QuasiStaticSolidMechanicsPhysicsBase::addCartesianComponentOutput	(	const std::string &	name,
		const std::string &	prop_name = `""`
	)

staticinherited

Definition at line 372 of file QuasiStaticSolidMechanicsPhysicsBase.C.

 {
   if (prop_name.empty())
     // the enum name is the actual tensor material property name
     _rank_two_cartesian_component_table.emplace(enum_name, enum_name);
   else
     // supply a different name for the enum options (this is done for
     // 'strain' -> 'mechanical_strain' in the TMA)
     _rank_two_cartesian_component_table.emplace(enum_name, prop_name);
 }

◆ getKernelParameters()

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

protectedvirtual

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1267 of file QuasiStaticSolidMechanicsPhysics.C.

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

 {
   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;
 
   if (_lagrangian_kernels)
   {
     params.set<bool>("use_displaced_mesh") =
         (_lk_large_kinematics && (_lk_formulation == LKFormulation::Updated));
     // large_kinematics is derived from the strain calculator's LARGE_KINEMATICS guarantee.
     params.set<bool>("stabilize_strain") = _lk_locking;
     params.set<MooseEnum>("F_bar_mode") = getParam<MooseEnum>("volumetric_locking_correction_mode");
     if (_lk_homogenization)
       params.set<bool>("off_diagonal_jacobian") = _lk_h_off_jac;
     // Match the strain calc's F-bar mode on the kernel -- the TL kernel's OLD-compat B-bar
     // residual is gated on `F_bar_mode = incremental && stabilize_strain`. Setting it on
     // both keeps the kernel and the strain material on the same F-bar formulation. Only
     // applicable to large kinematics (the strain calc rejects `incremental` for small).
     if (_compatibility_mode && _lk_locking && _lk_large_kinematics)
       params.set<MooseEnum>("F_bar_mode") = "incremental";
   }
   else
     params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
 
   return params;
 }

◆ getKernelType()

std::string QuasiStaticSolidMechanicsPhysics::getKernelType ( )

protectedvirtual

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1208 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

 {
   if (_lagrangian_kernels)
   {
     std::string type;
     if (_coord_system == Moose::COORD_XYZ)
     {
       if (_lk_homogenization)
         type = "HomogenizedTotalLagrangianStressDivergence";
       else if (_lk_formulation == LKFormulation::Total)
         type = "TotalLagrangianStressDivergence";
       else if (_lk_formulation == LKFormulation::Updated)
         type = "UpdatedLagrangianStressDivergence";
       else
         mooseError("Unknown formulation type");
     }
     else if (_coord_system == Moose::COORD_RZ)
     {
       if (_lk_homogenization)
         mooseError("The Lagrangian mechanics kernels do not yet support homogenization in "
                    "coordinate systems other than Cartesian.");
       else if (_lk_formulation == LKFormulation::Total)
         type = "TotalLagrangianStressDivergenceAxisymmetricCylindrical";
       else if (_lk_formulation == LKFormulation::Updated)
         mooseError("The Lagrangian mechanics kernels do not yet support the updated Lagrangian "
                    "formulation in RZ coordinates.");
     }
     else if (_coord_system == Moose::COORD_RSPHERICAL)
     {
       if (_lk_homogenization)
         mooseError("The Lagrangian mechanics kernels do not yet support homogenization in "
                    "coordinate systems other than Cartesian.");
       else if (_lk_formulation == LKFormulation::Total)
         type = "TotalLagrangianStressDivergenceCentrosymmetricSpherical";
       else if (_lk_formulation == LKFormulation::Updated)
         mooseError("The Lagrangian mechanics kernels do not yet support the updated Lagrangian "
                    "formulation in RZ coordinates.");
     }
     else
       mooseError("Unsupported coordinate system");
     return type;
   }
   else
   {
     std::map<Moose::CoordinateSystemType, std::string> type_map = {
         {Moose::COORD_XYZ, "StressDivergenceTensors"},
         {Moose::COORD_RZ, "StressDivergenceRZTensors"},
         {Moose::COORD_RSPHERICAL, "StressDivergenceRSphericalTensors"}};
 
     // choose kernel type based on coordinate system
     auto type_it = type_map.find(_coord_system);
     if (type_it != type_map.end())
       return type_it->second;
     else
       mooseError("Unsupported coordinate system");
   }
 }

◆ materialOutputFamilies()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies ( )

staticinherited

Definition at line 337 of file QuasiStaticSolidMechanicsPhysicsBase.C.

Referenced by QuasiStaticSolidMechanicsPhysicsBase::validParams(), and validParams().

 {
   return MultiMooseEnum("MONOMIAL LAGRANGE");
 }

◆ materialOutputOrders()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders ( )

staticinherited

Definition at line 329 of file QuasiStaticSolidMechanicsPhysicsBase.C.

Referenced by QuasiStaticSolidMechanicsPhysicsBase::validParams(), and validParams().

 {
   auto orders = AddAuxVariableAction::getAuxVariableOrders().getRawNames();
 
   return MultiMooseEnum(orders);
 }

◆ outputPropertiesType()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType ( )

staticinherited

Definition at line 343 of file QuasiStaticSolidMechanicsPhysicsBase.C.

Referenced by QuasiStaticSolidMechanicsPhysicsBase::validParams(), and validParams().

 {
   std::string options = "";
   for (auto & r2tc : _rank_two_cartesian_component_table)
     for (unsigned int a = 0; a < 3; ++a)
       for (unsigned int b = 0; b < 3; ++b)
         options += (options == "" ? "" : " ") + r2tc.first + '_' + _component_table[a] +
                    _component_table[b];
 
   for (auto & r2i : _rank_two_invariant_table)
     for (auto & t : r2i.second.second)
       options += " " + r2i.first + "_" + t;
 
   for (auto & r2sdc : _rank_two_directional_component_table)
     for (auto & r : r2sdc.second.second)
       options += " " + r2sdc.first + "_" + r;
 
   for (auto & r2cc : _rank_two_cylindrical_component_table)
     for (auto & r : r2cc.second.second)
       options += " " + r2cc.first + "_" + r;
 
   for (auto & r2sc : _rank_two_spherical_component_table)
     for (auto & r : r2sc.second.second)
       options += " " + r2sc.first + "_" + r;
 
   return MultiMooseEnum(options, "", true);
 }

◆ remapCompatOutputProp()

std::string QuasiStaticSolidMechanicsPhysics::remapCompatOutputProp ( const std::string & prop_name ) const

protected

Apply compatibility_mode remapping to a property name pulled from the _rank_two_* output tables: in compat mode the NEW pipeline writes Cauchy stress + rotated mechanical strain under different names than the OLD pipeline.

Outside compat mode this is the identity.

Definition at line 862 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by actOutputMatProp().

 {
   // The OLD pipeline publishes `stress` and `mechanical_strain` directly. The NEW pipeline
   // publishes Cauchy stress under `cauchy_stress` and (when the strain calc is configured for
   // OLD compatibility) the OLD-equivalent mechanical strain under `rotated_mechanical_strain`.
   // Redirect the underlying property name so user output requests like `stress_xx` keep their
   // OLD-style aux variable name but read from the NEW-style source.
   if (!_compatibility_mode)
     return prop_name;
   if (prop_name == "stress")
     return "cauchy_stress";
   if (prop_name == "mechanical_strain")
     return "rotated_mechanical_strain";
   return prop_name;
 }

◆ setupOutput()

template<typename T , typename T2 >

bool QuasiStaticSolidMechanicsPhysics::setupOutput	(	std::string	out,
		T	table,
		T2	setup
	)

protected

Helper function to decode generate_outputs options using a "table" of scalar output quantities and a "setup" lambda that performs the input parameter setup for the output material object.

Definition at line 184 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actOutputMatProp().

 {
   for (const auto & t1 : table)
   {
     // find the officially supported properties
     for (const auto & t2 : t1.second.second)
       if (t1.first + '_' + t2 == out)
       {
         const auto it = _rank_two_cartesian_component_table.find(t2);
         if (it != _rank_two_cartesian_component_table.end())
         {
           setup(it->second, t1.second.first);
           return true;
         }
         else
           mooseError("Internal error. The permitted tensor shortcuts must be keys in the "
                      "'_rank_two_cartesian_component_table'.");
       }
 
     // check for custom properties
     auto prefix = t1.first + '_';
     if (out.substr(0, prefix.length()) == prefix)
     {
       setup(out.substr(prefix.length()), t1.second.first);
       return true;
     }
   }
 
   return false;
 }

◆ validParams()

InputParameters QuasiStaticSolidMechanicsPhysics::validParams ( )

static

Definition at line 54 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by LegacyTensorMechanicsAction::validParams(), DynamicSolidMechanicsPhysics::validParams(), and PoroMechanicsAction::validParams().

 {
   InputParameters params = QuasiStaticSolidMechanicsPhysicsBase::validParams();
   params.addClassDescription("Set up stress divergence kernels with coordinate system aware logic");
 
   // parameters specified here only appear in the input file sub-blocks of the solid mechanics
   // action, not in the common parameters area
   params.addParam<std::vector<SubdomainName>>("block",
                                               {},
                                               "The list of ids of the blocks (subdomain) "
                                               "that the stress divergence kernels will be "
                                               "applied to");
   params.addParamNamesToGroup("block", "Advanced");
 
   params.addParam<MultiMooseEnum>("additional_generate_output",
                                   QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType(),
                                   "Add scalar quantity output for stress and/or strain (will be "
                                   "appended to the list in `generate_output`)");
   params.addParam<MultiMooseEnum>(
       "additional_material_output_order",
       QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders(),
       "Specifies the order of the FE shape function to use for this variable.");
 
   params.addParam<MultiMooseEnum>(
       "additional_material_output_family",
       QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies(),
       "Specifies the family of FE shape functions to use for this variable.");
 
   params.addParamNamesToGroup("additional_generate_output additional_material_output_order "
                               "additional_material_output_family",
                               "Output");
   params.addParam<std::string>(
       "strain_base_name",
       "The base name used for the strain. If not provided, it will be set equal to base_name");
   params.addParam<std::vector<TagName>>(
       "extra_vector_tags",
       "The tag names for extra vectors that residual data should be saved into");
   params.addParam<std::vector<TagName>>("absolute_value_vector_tags",
                                         "The tag names for extra vectors that the absolute value "
                                         "of the residual should be accumulated into");
   params.addParam<Real>("scaling", "The scaling to apply to the displacement variables");
   params.addParam<Point>(
       "cylindrical_axis_point1",
       "Starting point for direction of axis of rotation for cylindrical stress/strain.");
   params.addParam<Point>(
       "cylindrical_axis_point2",
       "Ending point for direction of axis of rotation for cylindrical stress/strain.");
   params.addParam<Point>("spherical_center_point",
                          "Center point of the spherical coordinate system.");
   params.addParam<Point>("direction", "Direction stress/strain is calculated in");
   params.addParam<bool>("automatic_eigenstrain_names",
                         false,
                         "Collects all material eigenstrains and passes to required strain "
                         "calculator within TMA internally.");
 
   // Homogenization system input
   params.addParam<MultiMooseEnum>(
       "constraint_types",
       Homogenization::constraintType,
       "Type of each constraint: strain, stress, or none. The types are specified in the "
       "column-major order, and there must be 9 entries in total.");
   params.addParam<std::vector<FunctionName>>(
       "targets", {}, "Functions giving the targets to hit for constraint types that are not none.");
   params.addParam<bool>(
       "homogenized_off_diagonal_jacobian",
       true,
       "Whether to include the off-diagonal scalar contributions to the homogenized jacobian");
 
   params.addParamNamesToGroup("scaling", "Variables");
   params.addParamNamesToGroup("strain_base_name automatic_eigenstrain_names", "Strain");
   params.addParamNamesToGroup(
       "cylindrical_axis_point1 cylindrical_axis_point2 spherical_center_point direction",
       "Coordinate system");
   params.addParamNamesToGroup("constraint_types targets homogenized_off_diagonal_jacobian",
                               "Homogenization");
 
   return params;
 }

◆ verifyOrderAndFamilyOutputs()

void QuasiStaticSolidMechanicsPhysics::verifyOrderAndFamilyOutputs ( )

protected

Definition at line 812 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics().

 {
   // Ensure material output order and family vectors are same size as generate output
 
   // check number of supplied orders and families
   if (_material_output_order.size() > 1 && _material_output_order.size() < _generate_output.size())
     paramError("material_output_order",
                "The number of orders assigned to material outputs must be: 0 to be assigned "
                "CONSTANT; 1 to assign all outputs the same value, or the same size as the number "
                "of generate outputs listed.");
 
   if (_material_output_family.size() > 1 &&
       _material_output_family.size() < _generate_output.size())
     paramError("material_output_family",
                "The number of families assigned to material outputs must be: 0 to be assigned "
                "MONOMIAL; 1 to assign all outputs the same value, or the same size as the number "
                "of generate outputs listed.");
 
   // if no value was provided, chose the default CONSTANT
   if (_material_output_order.size() == 0)
     _material_output_order.setAdditionalValue("CONSTANT");
 
   // For only one order, make all orders the same magnitude
   if (_material_output_order.size() == 1)
     _material_output_order =
         std::vector<std::string>(_generate_output.size(), _material_output_order[0]);
 
   if (_verbose)
     Moose::out << COLOR_CYAN << "*** Automatic applied material output orders ***"
                << "\n"
                << _name << ": " << Moose::stringify(_material_output_order) << "\n"
                << COLOR_DEFAULT << std::flush;
 
   // if no value was provided, chose the default MONOMIAL
   if (_material_output_family.size() == 0)
     _material_output_family.setAdditionalValue("MONOMIAL");
 
   // For only one family, make all families that value
   if (_material_output_family.size() == 1)
     _material_output_family =
         std::vector<std::string>(_generate_output.size(), _material_output_family[0]);
 
   if (_verbose)
     Moose::out << COLOR_CYAN << "*** Automatic applied material output families ***"
                << "\n"
                << _name << ": " << Moose::stringify(_material_output_family) << "\n"
                << COLOR_DEFAULT << std::flush;
 }

Member Data Documentation

◆ _auto_eigenstrain

const bool QuasiStaticSolidMechanicsPhysics::_auto_eigenstrain

protected

automatically gather names of eigenstrain tensors provided by simulation objects

Definition at line 139 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act().

◆ _base_name

const std::string QuasiStaticSolidMechanicsPhysics::_base_name

protected

base name for the current master action block

Definition at line 111 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actOutputGeneration(), and actOutputMatProp().

◆ _compatibility_mode

const bool QuasiStaticSolidMechanicsPhysics::_compatibility_mode

protected

OLD-compat shim: auto-configures the Lagrangian kernel system to reproduce StressDivergenceTensors + ComputeFiniteStrain + ComputeStressBase bit-for-bit when set.

Definition at line 145 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actLagrangianKernelStrain(), getKernelParameters(), QuasiStaticSolidMechanicsPhysics(), and remapCompatOutputProp().

◆ _component_table

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

staticinherited

table data for output generation

Definition at line 27 of file QuasiStaticSolidMechanicsPhysicsBase.h.

Referenced by actOutputMatProp(), and QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType().

◆ _constraint_types

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_constraint_types

protected

Definition at line 176 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), and actLagrangianKernelStrain().

◆ _coord_system

Moose::CoordinateSystemType QuasiStaticSolidMechanicsPhysics::_coord_system

protected

Definition at line 65 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actLagrangianKernelStrain(), actOutputMatProp(), actStressDivergenceTensorsStrain(), actSubdomainChecks(), DynamicSolidMechanicsPhysics::getKernelType(), and getKernelType().

◆ _coupled_displacements

std::vector<VariableName> QuasiStaticSolidMechanicsPhysics::_coupled_displacements

protected

Coupled displacement variables.

Definition at line 57 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actLagrangianKernelStrain(), actStressDivergenceTensorsStrain(), getKernelParameters(), and QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point1

Point QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1

protected

points used to determine axis of rotation for cylindrical stress/strain quantities

Definition at line 128 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point1_valid

bool QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1_valid

protected

booleans used to determine if cylindrical axis points are passed

Definition at line 122 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point2

Point QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point2

protected

Definition at line 129 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point2_valid

bool QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point2_valid

protected

Definition at line 123 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _diag_save_in

std::vector<AuxVariableName> QuasiStaticSolidMechanicsPhysics::_diag_save_in

protected

Definition at line 62 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), and QuasiStaticSolidMechanicsPhysics().

◆ _direction

Point QuasiStaticSolidMechanicsPhysics::_direction

protected

Definition at line 130 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _direction_valid

bool QuasiStaticSolidMechanicsPhysics::_direction_valid

protected

Definition at line 124 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _displacements

std::vector<VariableName> QuasiStaticSolidMechanicsPhysics::_displacements

protected

displacement variables

Definition at line 51 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by DynamicSolidMechanicsPhysics::act(), act(), and QuasiStaticSolidMechanicsPhysics().

◆ _eigenstrain_names

std::vector<MaterialPropertyName> QuasiStaticSolidMechanicsPhysics::_eigenstrain_names

protected

Definition at line 141 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actEigenstrainNames(), actLagrangianKernelStrain(), actStressDivergenceTensorsStrain(), and QuasiStaticSolidMechanicsPhysics().

◆ _generate_output

std::vector<std::string> QuasiStaticSolidMechanicsPhysics::_generate_output

protected

output materials to generate scalar stress/strain tensor quantities

Definition at line 117 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actOutputGeneration(), actOutputMatProp(), QuasiStaticSolidMechanicsPhysics(), and verifyOrderAndFamilyOutputs().

◆ _hname

const std::string QuasiStaticSolidMechanicsPhysics::_hname = "hvar"

protected

Definition at line 170 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), and actLagrangianKernelStrain().

◆ _homogenization_strain_name

const std::string QuasiStaticSolidMechanicsPhysics::_homogenization_strain_name = "homogenization_gradient"

protected

Definition at line 174 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actLagrangianKernelStrain().

◆ _integrator_name

const std::string QuasiStaticSolidMechanicsPhysics::_integrator_name = "integrator"

protected

Definition at line 172 of file QuasiStaticSolidMechanicsPhysics.h.

◆ _lagrangian_kernels

const bool QuasiStaticSolidMechanicsPhysics::_lagrangian_kernels

protected

New or old kernel system. True if new_system = true OR compatibility_mode = true.

Definition at line 148 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), getKernelParameters(), getKernelType(), and QuasiStaticSolidMechanicsPhysics().

◆ _lk_formulation

const LKFormulation QuasiStaticSolidMechanicsPhysics::_lk_formulation

protected

Definition at line 159 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by getKernelParameters(), getKernelType(), and QuasiStaticSolidMechanicsPhysics().

◆ _lk_h_off_jac

const bool QuasiStaticSolidMechanicsPhysics::_lk_h_off_jac

protected

Whether to use the off diagonal scalar jacobian for the homogenization system.

Definition at line 179 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by getKernelParameters().

◆ _lk_homogenization

bool QuasiStaticSolidMechanicsPhysics::_lk_homogenization

protected

Flag indicating if the homogenization system is present for new kernels.

Definition at line 165 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), actLagrangianKernelStrain(), getKernelParameters(), getKernelType(), and QuasiStaticSolidMechanicsPhysics().

◆ _lk_large_kinematics

const bool QuasiStaticSolidMechanicsPhysics::_lk_large_kinematics

protected

Simplified flag for small/large deformations, Lagrangian kernel system.

Definition at line 151 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), actLagrangianKernelStrain(), getKernelParameters(), and QuasiStaticSolidMechanicsPhysics().

◆ _lk_locking

const bool QuasiStaticSolidMechanicsPhysics::_lk_locking

protected

Simplified volumetric locking correction flag for new kernels.

Definition at line 162 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actLagrangianKernelStrain(), getKernelParameters(), and QuasiStaticSolidMechanicsPhysics().

◆ _material_output_family

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_material_output_family

protected

Definition at line 119 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actOutputGeneration(), and verifyOrderAndFamilyOutputs().

◆ _material_output_order

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_material_output_order

protected

Definition at line 118 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actOutputGeneration(), and verifyOrderAndFamilyOutputs().

◆ _ndisp

unsigned int QuasiStaticSolidMechanicsPhysics::_ndisp

protected

Number of displacement variables.

Definition at line 54 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by DynamicSolidMechanicsPhysics::act(), act(), actSubdomainChecks(), and QuasiStaticSolidMechanicsPhysics().

◆ _order_mapper

const std::map<unsigned int, std::string> QuasiStaticSolidMechanicsPhysics::_order_mapper

staticprotected

Definition at line 168 of file QuasiStaticSolidMechanicsPhysics.h.

◆ _out_of_plane_direction

const OutOfPlaneDirection QuasiStaticSolidMechanicsPhysics::_out_of_plane_direction

protected

Definition at line 108 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), and actSubdomainChecks().

◆ _planar_formulation

enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation QuasiStaticSolidMechanicsPhysics::_planar_formulation

protected

Referenced by act(), actStressDivergenceTensorsStrain(), actSubdomainChecks(), and QuasiStaticSolidMechanicsPhysics().

◆ _rank_two_cartesian_component_table

std::map< std::string, std::string > QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cartesian_component_table

staticprotectedinherited

Initial value:

= {
        {"strain", "total_strain"},
        {"mechanical_strain", "mechanical_strain"},
        {"stress", "stress"},
        {"cauchy_stress", "cauchy_stress"},
        {"deformation_gradient", "deformation_gradient"},
        {"pk1_stress", "pk1_stress"},
        {"pk2_stress", "pk2_stress"},
        {"small_stress", "small_stress"},
        {"elastic_strain", "elastic_strain"},
        {"plastic_strain", "plastic_strain"},
        {"creep_strain", "creep_strain"},
        {"creep_stress", "creep_stress"}}

Definition at line 42 of file QuasiStaticSolidMechanicsPhysicsBase.h.

Referenced by actOutputMatProp(), QuasiStaticSolidMechanicsPhysicsBase::addCartesianComponentOutput(), QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType(), and setupOutput().

◆ _rank_two_cylindrical_component_table

const std::map< std::string, std::pair< std::string, std::vector< std::string > > > QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cylindrical_component_table

staticinherited

Initial value:

= {
        {"axial",
         {"AxialStress", {"stress", "strain", "plastic_strain", "creep_strain", "elastic_strain"}}},
        {"hoop",
         {"HoopStress", {"stress", "strain", "plastic_strain", "creep_strain", "elastic_strain"}}},
        {"radial", {"RadialStress", {"stress", "strain"}}}}

Definition at line 33 of file QuasiStaticSolidMechanicsPhysicsBase.h.

Referenced by actOutputMatProp(), and QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType().

◆ _rank_two_directional_component_table

const std::map< std::string, std::pair< std::string, std::vector< std::string > > > QuasiStaticSolidMechanicsPhysicsBase::_rank_two_directional_component_table

staticinherited

Initial value:

= {

{"directional", {"Direction", {"stress", "strain"}}}}

Definition at line 31 of file QuasiStaticSolidMechanicsPhysicsBase.h.

Referenced by actOutputMatProp(), and QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType().

◆ _rank_two_invariant_table

const std::map< std::string, std::pair< std::string, std::vector< std::string > > > QuasiStaticSolidMechanicsPhysicsBase::_rank_two_invariant_table

staticinherited

Definition at line 29 of file QuasiStaticSolidMechanicsPhysicsBase.h.

Referenced by actOutputMatProp(), and QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType().

◆ _rank_two_spherical_component_table

const std::map< std::string, std::pair< std::string, std::vector< std::string > > > QuasiStaticSolidMechanicsPhysicsBase::_rank_two_spherical_component_table

staticinherited

Initial value:

= {
        {"spherical_hoop",
         {"HoopStress", {"stress", "strain", "plastic_strain", "creep_strain", "elastic_strain"}}},
        {"spherical_radial", {"RadialStress", {"stress", "strain"}}}}