#include <LegacyTensorMechanicsAction.h>

Inheritance diagram for LegacyTensorMechanicsAction:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	LegacyTensorMechanicsAction (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 14 of file LegacyTensorMechanicsAction.h.

Member Enumeration Documentation

◆ LKFormulation

enum QuasiStaticSolidMechanicsPhysics::LKFormulation

strongprotectedinherited

New kernel system kinematics types.

Enumerator
Total
Updated

Definition at line 154 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     Total,
     Updated
   };

◆ OutOfPlaneDirection

enum QuasiStaticSolidMechanicsPhysics::OutOfPlaneDirection

strongprotectedinherited

Enumerator
x
y
z

Definition at line 101 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     x,
     y,
     z
   };

◆ PlanarFormulation

enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation

strongprotectedinherited

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

strongprotectedinherited

strain formulation

Enumerator
Small
Finite

Definition at line 77 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     Small,
     Finite
   } _strain;

◆ StrainAndIncrement

enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement

strongprotectedinherited

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

◆ LegacyTensorMechanicsAction()

LegacyTensorMechanicsAction::LegacyTensorMechanicsAction ( const InputParameters & params )

Definition at line 29 of file LegacyTensorMechanicsAction.C.

   : QuasiStaticSolidMechanicsPhysics(params)
 {
 }

Member Function Documentation

◆ act()

void LegacyTensorMechanicsAction::act ( )

virtual

Reimplemented from QuasiStaticSolidMechanicsPhysics.

Definition at line 35 of file LegacyTensorMechanicsAction.C.

 {
   if (_current_task == "add_kernel" || _current_task == "validate_coordinate_systems")
     QuasiStaticSolidMechanicsPhysics::act();
 }

◆ actEigenstrainNames()

void QuasiStaticSolidMechanicsPhysics::actEigenstrainNames ( )

protectedinherited

Definition at line 695 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 ( )

protectedinherited

Definition at line 989 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 ( )

protectedinherited

Definition at line 1015 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 ( )

protectedinherited

Definition at line 614 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 ( )

protectedinherited

Definition at line 879 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 ( )

protectedinherited

Definition at line 1123 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 ( )

protectedinherited

Definition at line 565 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 )

protectedvirtualinherited

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1267 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 ( )

protectedvirtualinherited

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1208 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 QuasiStaticSolidMechanicsPhysics::validParams().

 {
   return MultiMooseEnum("MONOMIAL LAGRANGE");
 }

◆ materialOutputOrders()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders ( )

staticinherited

Definition at line 329 of file QuasiStaticSolidMechanicsPhysicsBase.C.

Referenced by QuasiStaticSolidMechanicsPhysicsBase::validParams(), and QuasiStaticSolidMechanicsPhysics::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 QuasiStaticSolidMechanicsPhysics::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

protectedinherited

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 QuasiStaticSolidMechanicsPhysics::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
	)

protectedinherited

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 QuasiStaticSolidMechanicsPhysics::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 LegacyTensorMechanicsAction::validParams ( )

static

Definition at line 21 of file LegacyTensorMechanicsAction.C.

 {
   InputParameters params = QuasiStaticSolidMechanicsPhysics::validParams();
   params.addParam<bool>(
       "use_displaced_mesh", false, "Whether to use displaced mesh in the kernels");
   return params;
 }

◆ verifyOrderAndFamilyOutputs()

void QuasiStaticSolidMechanicsPhysics::verifyOrderAndFamilyOutputs ( )

protectedinherited

Definition at line 812 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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

protectedinherited

automatically gather names of eigenstrain tensors provided by simulation objects

Definition at line 139 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

◆ _base_name

const std::string QuasiStaticSolidMechanicsPhysics::_base_name

protectedinherited

base name for the current master action block

Definition at line 111 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _compatibility_mode

const bool QuasiStaticSolidMechanicsPhysics::_compatibility_mode

protectedinherited

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 QuasiStaticSolidMechanicsPhysics::actLagrangianKernelStrain(), QuasiStaticSolidMechanicsPhysics::getKernelParameters(), QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics(), and QuasiStaticSolidMechanicsPhysics::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 QuasiStaticSolidMechanicsPhysics::actOutputMatProp(), and QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType().

◆ _constraint_types

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_constraint_types

protectedinherited

Definition at line 176 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _coord_system

Moose::CoordinateSystemType QuasiStaticSolidMechanicsPhysics::_coord_system

protectedinherited

Definition at line 65 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _coupled_displacements

std::vector<VariableName> QuasiStaticSolidMechanicsPhysics::_coupled_displacements

protectedinherited

Coupled displacement variables.

Definition at line 57 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _cylindrical_axis_point1

Point QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1

protectedinherited

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

Definition at line 128 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point1_valid

bool QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1_valid

protectedinherited

booleans used to determine if cylindrical axis points are passed

Definition at line 122 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point2

Point QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point2

protectedinherited

Definition at line 129 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point2_valid

bool QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point2_valid

protectedinherited

Definition at line 123 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _diag_save_in

std::vector<AuxVariableName> QuasiStaticSolidMechanicsPhysics::_diag_save_in

protectedinherited

Definition at line 62 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _direction

Point QuasiStaticSolidMechanicsPhysics::_direction

protectedinherited

Definition at line 130 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _direction_valid

bool QuasiStaticSolidMechanicsPhysics::_direction_valid

protectedinherited

Definition at line 124 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _displacements

std::vector<VariableName> QuasiStaticSolidMechanicsPhysics::_displacements

protectedinherited

displacement variables

Definition at line 51 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _eigenstrain_names

std::vector<MaterialPropertyName> QuasiStaticSolidMechanicsPhysics::_eigenstrain_names

protectedinherited

Definition at line 141 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _generate_output

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

protectedinherited

output materials to generate scalar stress/strain tensor quantities

Definition at line 117 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _hname

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

protectedinherited

Definition at line 170 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _homogenization_strain_name

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

protectedinherited

Definition at line 174 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::actLagrangianKernelStrain().

◆ _integrator_name

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

protectedinherited

Definition at line 172 of file QuasiStaticSolidMechanicsPhysics.h.

◆ _lagrangian_kernels

const bool QuasiStaticSolidMechanicsPhysics::_lagrangian_kernels

protectedinherited

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

Definition at line 148 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_formulation

const LKFormulation QuasiStaticSolidMechanicsPhysics::_lk_formulation

protectedinherited

Definition at line 159 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_h_off_jac

const bool QuasiStaticSolidMechanicsPhysics::_lk_h_off_jac

protectedinherited

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

Definition at line 179 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::getKernelParameters().

◆ _lk_homogenization

bool QuasiStaticSolidMechanicsPhysics::_lk_homogenization

protectedinherited

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

Definition at line 165 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_large_kinematics

const bool QuasiStaticSolidMechanicsPhysics::_lk_large_kinematics

protectedinherited

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

Definition at line 151 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_locking

const bool QuasiStaticSolidMechanicsPhysics::_lk_locking

protectedinherited

Simplified volumetric locking correction flag for new kernels.

Definition at line 162 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _material_output_family

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_material_output_family

protectedinherited

Definition at line 119 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _material_output_order

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_material_output_order

protectedinherited

Definition at line 118 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _ndisp

unsigned int QuasiStaticSolidMechanicsPhysics::_ndisp

protectedinherited

Number of displacement variables.

Definition at line 54 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _order_mapper

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

staticprotectedinherited

Definition at line 168 of file QuasiStaticSolidMechanicsPhysics.h.

◆ _out_of_plane_direction

const OutOfPlaneDirection QuasiStaticSolidMechanicsPhysics::_out_of_plane_direction

protectedinherited

Definition at line 108 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _planar_formulation

enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation QuasiStaticSolidMechanicsPhysics::_planar_formulation

protectedinherited

Referenced by QuasiStaticSolidMechanicsPhysics::act(), QuasiStaticSolidMechanicsPhysics::actStressDivergenceTensorsStrain(), QuasiStaticSolidMechanicsPhysics::actSubdomainChecks(), and QuasiStaticSolidMechanicsPhysics::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 QuasiStaticSolidMechanicsPhysics::actOutputMatProp(), QuasiStaticSolidMechanicsPhysicsBase::addCartesianComponentOutput(), QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType(), and QuasiStaticSolidMechanicsPhysics::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 QuasiStaticSolidMechanicsPhysics::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 QuasiStaticSolidMechanicsPhysics::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 QuasiStaticSolidMechanicsPhysics::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"}}}}