#include <PoroMechanicsAction.h>

Inheritance diagram for PoroMechanicsAction:

Public Types
typedef DataFileName	DataFileParameterType

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

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

◆ PoroMechanicsAction()

PoroMechanicsAction::PoroMechanicsAction ( const InputParameters & params )

Definition at line 32 of file PoroMechanicsAction.C.

  : QuasiStaticSolidMechanicsPhysics(params)
{
  if (_use_ad)
    paramError("use_ad", "AD not setup for use with PoroMechanicsAction");
}

Member Function Documentation

◆ act()

void PoroMechanicsAction::act ( )

virtual

Reimplemented from QuasiStaticSolidMechanicsPhysics.

Definition at line 40 of file PoroMechanicsAction.C.

{
  QuasiStaticSolidMechanicsPhysics::act();
 
  if (_current_task == "add_kernel")
  {
    // Prepare displacements and set value for dim
    std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
    unsigned int dim = displacements.size();
 
    // all the kernels added below have pore pressure as a coupled variable
    // add this to the kernel's params
    std::string type("PoroMechanicsCoupling");
    InputParameters params = _factory.getValidParams(type);
    VariableName pp_var(getParam<VariableName>("porepressure"));
    params.addCoupledVar("porepressure", "");
    params.set<std::vector<VariableName>>("porepressure") = {pp_var};
 
    // now add the kernels
    for (unsigned int i = 0; i < dim; ++i)
    {
      std::string kernel_name = "PoroMechanics" + Moose::stringify(i);
 
      params.set<unsigned int>("component") = i;
      params.set<NonlinearVariableName>("variable") = displacements[i];
 
      _problem->addKernel(type, kernel_name, params);
    }
  }
}

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

protectedvirtualinherited

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1264 of file QuasiStaticSolidMechanicsPhysics.C.

{
  InputParameters params = _factory.getValidParams(type);
  params.applyParameters(
      parameters(),
      {"displacements", "use_displaced_mesh", "save_in", "diag_save_in", "out_of_plane_strain"});
 
  params.set<std::vector<VariableName>>("displacements") = _coupled_displacements;
 
  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;
}

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

◆ getKernelType()

std::string QuasiStaticSolidMechanicsPhysics::getKernelType ( )

protectedvirtualinherited

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1205 of file QuasiStaticSolidMechanicsPhysics.C.

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

Referenced by QuasiStaticSolidMechanicsPhysics::act().

◆ 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 PoroMechanicsAction::validParams ( )

static

Definition at line 24 of file PoroMechanicsAction.C.

{
  InputParameters params = QuasiStaticSolidMechanicsPhysics::validParams();
  params.addRequiredParam<VariableName>("porepressure", "The pore pressure variable");
  params.addClassDescription("Adds the poro-mechanics coupling term");
  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

◆ _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;
};