#include <LegacyDynamicTensorMechanicsAction.h>

Inheritance diagram for LegacyDynamicTensorMechanicsAction:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	LegacyDynamicTensorMechanicsAction (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

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 class	Strain { Small , Finite }
	strain formulation More...

enum class	StrainAndIncrement { SmallTotal , FiniteTotal , SmallIncremental , FiniteIncremental }
	strain formulation More...

enum class	PlanarFormulation { None , WeakPlaneStress , PlaneStrain , GeneralizedPlaneStrain }
	use an out of plane stress/strain formulation More...

enum class	OutOfPlaneDirection { x , y , z }

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

Protected Member Functions
virtual std::string	getKernelType () override

virtual InputParameters	getKernelParameters (std::string type) override

void	actSubdomainChecks ()

void	actOutputGeneration ()

void	actEigenstrainNames ()

void	actOutputMatProp ()

void	actGatherActionParameters ()

void	verifyOrderAndFamilyOutputs ()

void	actLagrangianKernelStrain ()

void	actStressDivergenceTensorsStrain ()

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.

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.

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
std::vector< AuxVariableName >	_velocities

std::vector< AuxVariableName >	_accelerations

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

std::set< SubdomainID >	_subdomain_ids
	set generated from the passed in vector of subdomain names

std::set< SubdomainID >	_subdomain_id_union
	set generated from the combined block restrictions of all SolidMechanics/Master action blocks

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

bool	_use_displaced_mesh
	use displaced mesh (true unless _strain is SMALL)

std::vector< std::string >	_generate_output
	output materials to generate scalar stress/strain tensor quantities

MultiMooseEnum	_material_output_order

MultiMooseEnum	_material_output_family

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

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

Point	_cylindrical_axis_point2

Point	_direction

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

Point	_spherical_center_point
	center point for spherical stress/strain quantities

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

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.

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

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

const LKFormulation	_lk_formulation

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

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

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.

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

unsigned int	_ndisp
	Number of displacement variables.

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


std::vector< AuxVariableName >	_save_in
	residual debugging

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

Private Member Functions
bool	addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)

virtual std::string	meshPropertyPrefix (const std::string &data_name) const

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

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

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
const ParallelParamObject &	_parent

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

Detailed Description

Definition at line 14 of file LegacyDynamicTensorMechanicsAction.h.

Member Enumeration Documentation

◆ LKFormulation

enum class QuasiStaticSolidMechanicsPhysics::LKFormulation

strongprotectedinherited

New kernel system kinematics types.

Enumerator
Total
Updated

Definition at line 154 of file QuasiStaticSolidMechanicsPhysics.h.

  {
    Total,
    Updated
  };

◆ OutOfPlaneDirection

enum class QuasiStaticSolidMechanicsPhysics::OutOfPlaneDirection

strongprotectedinherited

Enumerator
x
y
z

Definition at line 101 of file QuasiStaticSolidMechanicsPhysics.h.

  {
    x,
    y,
    z
  };

◆ PlanarFormulation

enum class 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 class QuasiStaticSolidMechanicsPhysics::Strain

strongprotectedinherited

strain formulation

Enumerator
Small
Finite

Definition at line 77 of file QuasiStaticSolidMechanicsPhysics.h.

  {
    Small,
    Finite
  } _strain;

◆ StrainAndIncrement

enum class 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

◆ LegacyDynamicTensorMechanicsAction()

LegacyDynamicTensorMechanicsAction::LegacyDynamicTensorMechanicsAction ( const InputParameters & params )

Definition at line 29 of file LegacyDynamicTensorMechanicsAction.C.

  : DynamicSolidMechanicsPhysics(params)
{
}

Member Function Documentation

◆ act()

void LegacyDynamicTensorMechanicsAction::act ( )

virtual

Reimplemented from DynamicSolidMechanicsPhysics.

Definition at line 36 of file LegacyDynamicTensorMechanicsAction.C.

{
  if (_current_task == "add_kernel" || _current_task == "validate_coordinate_systems")
    // note that we do not call SolidMechanicsAction::act() here, because the old
    // behavior is not to add inertia kernels
    QuasiStaticSolidMechanicsPhysics::act();
}

◆ actEigenstrainNames()

void QuasiStaticSolidMechanicsPhysics::actEigenstrainNames ( )

protectedinherited

Definition at line 694 of file QuasiStaticSolidMechanicsPhysics.C.

{
  // 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;
}

Referenced by QuasiStaticSolidMechanicsPhysics::act().

◆ actGatherActionParameters()

void QuasiStaticSolidMechanicsPhysics::actGatherActionParameters ( )

protectedinherited

Definition at line 988 of file QuasiStaticSolidMechanicsPhysics.C.

{
  // 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.");
    }
  }
}

Referenced by QuasiStaticSolidMechanicsPhysics::act().

◆ actLagrangianKernelStrain()

void QuasiStaticSolidMechanicsPhysics::actLagrangianKernelStrain ( )

protectedinherited

Definition at line 1014 of file QuasiStaticSolidMechanicsPhysics.C.

{
  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);
  }
}

Referenced by QuasiStaticSolidMechanicsPhysics::act().

◆ actOutputGeneration()

void QuasiStaticSolidMechanicsPhysics::actOutputGeneration ( )

protectedinherited

Definition at line 613 of file QuasiStaticSolidMechanicsPhysics.C.

{
  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++;
    }
  }
}

Referenced by QuasiStaticSolidMechanicsPhysics::act().

◆ actOutputMatProp()

void QuasiStaticSolidMechanicsPhysics::actOutputMatProp ( )

protectedinherited

Definition at line 878 of file QuasiStaticSolidMechanicsPhysics.C.

{
  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, "'");
    }
  }
}

Referenced by QuasiStaticSolidMechanicsPhysics::actOutputGeneration().

◆ actStressDivergenceTensorsStrain()

void QuasiStaticSolidMechanicsPhysics::actStressDivergenceTensorsStrain ( )

protectedinherited

Definition at line 1122 of file QuasiStaticSolidMechanicsPhysics.C.

{
  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)
      paramError("use_automatic_differentiation", "AD not setup for use with PlaneStrain");
 
    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);
}

Referenced by QuasiStaticSolidMechanicsPhysics::act().

◆ actSubdomainChecks()

void QuasiStaticSolidMechanicsPhysics::actSubdomainChecks ( )

protectedinherited

Definition at line 564 of file QuasiStaticSolidMechanicsPhysics.C.

{
  // Do the coordinate system check only once the problem is created
  if (_current_task == "setup_mesh_complete")
  {
    // get subdomain IDs
    for (auto & name : _subdomain_names)
    {
      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");
    }
  }
}

Referenced by QuasiStaticSolidMechanicsPhysics::act().

◆ 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 DynamicSolidMechanicsPhysics::getKernelParameters ( std::string type )

overrideprotectedvirtualinherited

Reimplemented from QuasiStaticSolidMechanicsPhysics.

Definition at line 191 of file DynamicSolidMechanicsPhysics.C.

{
  InputParameters params = QuasiStaticSolidMechanicsPhysics::getKernelParameters(type);
 
  if (params.isParamDefined("alpha"))
    params.set<Real>("alpha") = getParam<Real>("hht_alpha");
  if (params.isParamDefined("zeta"))
    params.set<MaterialPropertyName>("zeta") =
        getParam<MaterialPropertyName>("stiffness_damping_coefficient");
 
  return params;
}

◆ getKernelType()

std::string DynamicSolidMechanicsPhysics::getKernelType ( )

overrideprotectedvirtualinherited

Reimplemented from QuasiStaticSolidMechanicsPhysics.

Definition at line 181 of file DynamicSolidMechanicsPhysics.C.

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

◆ materialOutputFamilies()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies ( )

staticinherited

Definition at line 337 of file QuasiStaticSolidMechanicsPhysicsBase.C.

{
  return MultiMooseEnum("MONOMIAL LAGRANGE");
}

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

◆ materialOutputOrders()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders ( )

staticinherited

Definition at line 329 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

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

◆ outputPropertiesType()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType ( )

staticinherited

Definition at line 343 of file QuasiStaticSolidMechanicsPhysicsBase.C.

{
  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);
}

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

◆ 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 861 of file QuasiStaticSolidMechanicsPhysics.C.

{
  // 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;
}

Referenced by QuasiStaticSolidMechanicsPhysics::actOutputMatProp().

◆ 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.

{
  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;
}

Referenced by QuasiStaticSolidMechanicsPhysics::actOutputMatProp().

◆ validParams()

InputParameters LegacyDynamicTensorMechanicsAction::validParams ( )

static

Definition at line 21 of file LegacyDynamicTensorMechanicsAction.C.

{
  InputParameters params = DynamicSolidMechanicsPhysics::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 811 of file QuasiStaticSolidMechanicsPhysics.C.

{
  // 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;
}

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

Member Data Documentation

◆ _accelerations

std::vector<AuxVariableName> DynamicSolidMechanicsPhysics::_accelerations

protectedinherited

Definition at line 28 of file DynamicSolidMechanicsPhysics.h.

Referenced by DynamicSolidMechanicsPhysics::act().

◆ _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 33 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(), QuasiStaticSolidMechanicsPhysics::getKernelType(), and DynamicSolidMechanicsPhysics::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 QuasiStaticSolidMechanicsPhysics::act(), DynamicSolidMechanicsPhysics::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 QuasiStaticSolidMechanicsPhysics::act(), DynamicSolidMechanicsPhysics::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 20 of file QuasiStaticSolidMechanicsPhysicsBase.h.

      :
  static const std::vector<char> _component_table;
  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>>>

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 123 of file QuasiStaticSolidMechanicsPhysicsBase.h.

                                           : public Action
{
public:
  static InputParameters validParams();
 
  QuasiStaticSolidMechanicsPhysicsBase(const InputParameters & params);
 
  static MultiMooseEnum outputPropertiesType();
  static MultiMooseEnum materialOutputOrders();
  static MultiMooseEnum materialOutputFamilies();
 
public:
  static const std::vector<char> _component_table;
  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;
 
  static void addCartesianComponentOutput(const std::string & name,
                                          const std::string & prop_name = "");
 
protected:
  static std::map<std::string, std::string> _rank_two_cartesian_component_table;
 
  const bool _use_ad;
};

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 119 of file QuasiStaticSolidMechanicsPhysicsBase.h.

                                           : public Action
{
public:
  static InputParameters validParams();
 
  QuasiStaticSolidMechanicsPhysicsBase(const InputParameters & params);
 
  static MultiMooseEnum outputPropertiesType();
  static MultiMooseEnum materialOutputOrders();
  static MultiMooseEnum materialOutputFamilies();
 
public:
  static const std::vector<char> _component_table;
  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;
 
  static void addCartesianComponentOutput(const std::string & name,
                                          const std::string & prop_name = "");
 
protected:
  static std::map<std::string, std::string> _rank_two_cartesian_component_table;
 
  const bool _use_ad;
};

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 38 of file QuasiStaticSolidMechanicsPhysicsBase.h.

         :
  static std::map<std::string, std::string> _rank_two_cartesian_component_table;
 
  const bool _use_ad;
};

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

Definition at line 131 of file QuasiStaticSolidMechanicsPhysicsBase.h.

                                           : public Action
{
public:
  static InputParameters validParams();
 
  QuasiStaticSolidMechanicsPhysicsBase(const InputParameters & params);
 
  static MultiMooseEnum outputPropertiesType();
  static MultiMooseEnum materialOutputOrders();
  static MultiMooseEnum materialOutputFamilies();
 
public:
  static const std::vector<char> _component_table;
  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;
 
  static void addCartesianComponentOutput(const std::string & name,
                                          const std::string & prop_name = "");
 
protected:
  static std::map<std::string, std::string> _rank_two_cartesian_component_table;
 
  const bool _use_ad;
};