https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Types | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
QuasiStaticSolidMechanicsPhysics Class Reference

#include <QuasiStaticSolidMechanicsPhysics.h>

Inheritance diagram for QuasiStaticSolidMechanicsPhysics:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 QuasiStaticSolidMechanicsPhysics (const InputParameters &params)
 
virtual void act ()
 
void timedAct ()
 
virtual void addRelationshipManagers (Moose::RelationshipManagerType when_type)
 
MooseObjectName uniqueActionName () const
 
const std::string & specificTaskName () const
 
const std::set< std::string > & getAllTasks () const
 
void appendTask (const std::string &task)
 
MooseApp & getMooseApp () const
 
const std::string & type () const
 
virtual const std::string & name () const
 
std::string typeAndName () const
 
std::string errorPrefix (const std::string &error_type) const
 
void callMooseError (std::string msg, const bool with_prefix) const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
const InputParameters & parameters () const
 
MooseObjectName uniqueName () 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 &nm) const
 
void paramError (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
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void mooseError (Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseInfo (Args &&... args) 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="")
 

Public Attributes

const ConsoleStream _console
 

Static Public Attributes

static constexpr auto SYSTEM
 
static constexpr auto NAME
 
static const std::vector< char > _component_table = {'x', 'y', 'z'}
 table data for output generation More...
 
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_invariant_table
 
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_directional_component_table
 
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_cylindrical_component_table
 
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_spherical_component_table
 

Protected Types

enum  Strain { Strain::Small, Strain::Finite }
 strain formulation More...
 
enum  StrainAndIncrement { StrainAndIncrement::SmallTotal, StrainAndIncrement::FiniteTotal, StrainAndIncrement::SmallIncremental, StrainAndIncrement::FiniteIncremental }
 strain formulation More...
 
enum  PlanarFormulation { PlanarFormulation::None, PlanarFormulation::WeakPlaneStress, PlanarFormulation::PlaneStrain, PlanarFormulation::GeneralizedPlaneStrain }
 use an out of plane stress/strain formulation More...
 
enum  OutOfPlaneDirection { OutOfPlaneDirection::x, OutOfPlaneDirection::y, OutOfPlaneDirection::z }
 
enum  LKFormulation { LKFormulation::Total, LKFormulation::Updated }
 New kernel system kinematics types. More...
 

Protected Member Functions

void actSubdomainChecks ()
 
void actOutputGeneration ()
 
void actEigenstrainNames ()
 
void actOutputMatProp ()
 
void actGatherActionParameters ()
 
void verifyOrderAndFamilyOutputs ()
 
void actLagrangianKernelStrain ()
 
void actStressDivergenceTensorsStrain ()
 
virtual std::string getKernelType ()
 
virtual InputParameters getKernelParameters (std::string type)
 
template<typename T , typename T2 >
bool setupOutput (std::string out, T table, T2 setup)
 Helper function to decode generate_outputs options using a "table" of scalar output quantities and a "setup" lambda that performs the input parameter setup for the output material object. More...
 
bool addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
 
void associateWithParameter (const std::string &param_name, InputParameters &params) const
 
void associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const
 
const T & getMeshProperty (const std::string &data_name, const std::string &prefix)
 
const T & getMeshProperty (const std::string &data_name)
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name) const
 
bool hasMeshProperty (const std::string &data_name) const
 
std::string meshPropertyName (const std::string &data_name) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 
std::string timedSectionName (const std::string &section_name) const
 

Static Protected Member Functions

static std::string meshPropertyName (const std::string &data_name, const std::string &prefix)
 

Protected Attributes

Moose::CoordinateSystemType _coord_system
 
std::vector< SubdomainName > _subdomain_names
 if this vector is not empty the variables, kernels and materials are restricted to these subdomains More...
 
std::set< SubdomainID > _subdomain_ids
 set generated from the passed in vector of subdomain names More...
 
std::set< SubdomainID > _subdomain_id_union
 set generated from the combined block restrictions of all SolidMechanics/Master action blocks More...
 
enum QuasiStaticSolidMechanicsPhysics::Strain _strain
 
enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement _strain_and_increment
 
enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation _planar_formulation
 
const OutOfPlaneDirection _out_of_plane_direction
 
const std::string _base_name
 base name for the current master action block More...
 
bool _use_displaced_mesh
 use displaced mesh (true unless _strain is SMALL) More...
 
std::vector< std::string > _generate_output
 output materials to generate scalar stress/strain tensor quantities More...
 
MultiMooseEnum _material_output_order
 
MultiMooseEnum _material_output_family
 
bool _cylindrical_axis_point1_valid
 booleans used to determine if cylindrical axis points are passed More...
 
bool _cylindrical_axis_point2_valid
 
bool _direction_valid
 
bool _verbose
 
Point _cylindrical_axis_point1
 points used to determine axis of rotation for cylindrical stress/strain quantities More...
 
Point _cylindrical_axis_point2
 
Point _direction
 
bool _spherical_center_point_valid
 booleans used to determine if spherical center point is passed More...
 
Point _spherical_center_point
 center point for spherical stress/strain quantities More...
 
const bool _auto_eigenstrain
 automatically gather names of eigenstrain tensors provided by simulation objects More...
 
std::vector< MaterialPropertyName > _eigenstrain_names
 
const bool _lagrangian_kernels
 New or old kernel system. More...
 
const bool _lk_large_kinematics
 Simplified flag for small/large deformations, Lagrangian kernel system. More...
 
const LKFormulation _lk_formulation
 
bool _lk_locking
 Simplified volumetric locking correction flag for new kernels. More...
 
bool _lk_homogenization
 Flag indicating if the homogenization system is present for new kernels. More...
 
const std::string _hname = "hvar"
 
const std::string _integrator_name = "integrator"
 
const std::string _homogenization_strain_name = "homogenization_gradient"
 
MultiMooseEnum _constraint_types
 
std::vector< FunctionName > _targets
 
const bool _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
 
const std::string _type
 
const std::string _name
 
const InputParameters & _pars
 
Factory & _factory
 
ActionFactory & _action_factory
 
MooseApp & _pg_moose_app
 
const std::string _prefix
 
const Parallel::Communicator & _communicator
 
std::vector< VariableName > _displacements
 displacement variables More...
 
unsigned int _ndisp
 Number of displacement variables. More...
 
std::vector< VariableName > _coupled_displacements
 Coupled displacement variables. More...
 
std::vector< AuxVariableName > _save_in
 residual debugging More...
 
std::vector< AuxVariableName > _diag_save_in
 

Static Protected Attributes

static const std::map< unsigned int, std::string > _order_mapper
 
static std::map< std::string, std::string > _rank_two_cartesian_component_table
 

Detailed Description

Definition at line 15 of file QuasiStaticSolidMechanicsPhysics.h.

Member Enumeration Documentation

◆ LKFormulation

enum QuasiStaticSolidMechanicsPhysics::LKFormulation
strongprotected

New kernel system kinematics types.

Enumerator
Total 
Updated 

Definition at line 145 of file QuasiStaticSolidMechanicsPhysics.h.

146  {
147  Total,
148  Updated
149  };

◆ OutOfPlaneDirection

enum QuasiStaticSolidMechanicsPhysics::OutOfPlaneDirection
strongprotected
Enumerator
x 
y 
z 

Definition at line 96 of file QuasiStaticSolidMechanicsPhysics.h.

97  {
98  x,
99  y,
100  z
101  };
y
const std::vector< double > y
Definition: EquilibriumConstantFitTest.C:18
x
const std::vector< double > x
Definition: EquilibriumConstantFitTest.C:17

◆ PlanarFormulation

enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation
strongprotected

use an out of plane stress/strain formulation

Enumerator
None 
WeakPlaneStress 
PlaneStrain 
GeneralizedPlaneStrain 

Definition at line 88 of file QuasiStaticSolidMechanicsPhysics.h.

89  {
90  None,
91  WeakPlaneStress,
92  PlaneStrain,
93  GeneralizedPlaneStrain,
94  } _planar_formulation;
QuasiStaticSolidMechanicsPhysics::_planar_formulation
enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation _planar_formulation

◆ Strain

enum QuasiStaticSolidMechanicsPhysics::Strain
strongprotected

strain formulation

Enumerator
Small 
Finite 

Definition at line 72 of file QuasiStaticSolidMechanicsPhysics.h.

73  {
74  Small,
75  Finite
76  } _strain;
QuasiStaticSolidMechanicsPhysics::_strain
enum QuasiStaticSolidMechanicsPhysics::Strain _strain

◆ StrainAndIncrement

enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement
strongprotected

strain formulation

Enumerator
SmallTotal 
FiniteTotal 
SmallIncremental 
FiniteIncremental 

Definition at line 79 of file QuasiStaticSolidMechanicsPhysics.h.

80  {
81  SmallTotal,
82  FiniteTotal,
83  SmallIncremental,
84  FiniteIncremental
85  } _strain_and_increment;
QuasiStaticSolidMechanicsPhysics::_strain_and_increment
enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement _strain_and_increment

Constructor & Destructor Documentation

◆ QuasiStaticSolidMechanicsPhysics()

QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics ( const InputParameters &  params)

Definition at line 129 of file QuasiStaticSolidMechanicsPhysics.C.

130  : QuasiStaticSolidMechanicsPhysicsBase(params),
131  _displacements(getParam<std::vector<VariableName>>("displacements")),
132  _ndisp(_displacements.size()),
133  _coupled_displacements(_ndisp),
134  _save_in(getParam<std::vector<AuxVariableName>>("save_in")),
135  _diag_save_in(getParam<std::vector<AuxVariableName>>("diag_save_in")),
136  _subdomain_names(getParam<std::vector<SubdomainName>>("block")),
137  _subdomain_ids(),
138  _strain(getParam<MooseEnum>("strain").getEnum<Strain>()),
139  _planar_formulation(getParam<MooseEnum>("planar_formulation").getEnum<PlanarFormulation>()),
140  _out_of_plane_direction(
141  getParam<MooseEnum>("out_of_plane_direction").getEnum<OutOfPlaneDirection>()),
142  _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
143  _material_output_order(getParam<MultiMooseEnum>("material_output_order")),
144  _material_output_family(getParam<MultiMooseEnum>("material_output_family")),
145  _cylindrical_axis_point1_valid(params.isParamSetByUser("cylindrical_axis_point1")),
146  _cylindrical_axis_point2_valid(params.isParamSetByUser("cylindrical_axis_point2")),
147  _direction_valid(params.isParamSetByUser("direction")),
148  _verbose(getParam<bool>("verbose")),
149  _spherical_center_point_valid(params.isParamSetByUser("spherical_center_point")),
150  _auto_eigenstrain(getParam<bool>("automatic_eigenstrain_names")),
151  _lagrangian_kernels(getParam<bool>("new_system")),
152  _lk_large_kinematics(_strain == Strain::Finite),
153  _lk_formulation(getParam<MooseEnum>("formulation").getEnum<LKFormulation>()),
154  _lk_locking(getParam<bool>("volumetric_locking_correction")),
155  _lk_homogenization(false),
156  _constraint_types(getParam<MultiMooseEnum>("constraint_types")),
157  _targets(getParam<std::vector<FunctionName>>("targets"))
158 {
159  // determine if incremental strains are to be used
160  if (isParamValid("incremental"))
161  {
162  const bool incremental = getParam<bool>("incremental");
163  if (!incremental && _strain == Strain::Small)
164  _strain_and_increment = StrainAndIncrement::SmallTotal;
165  else if (!incremental && _strain == Strain::Finite)
166  _strain_and_increment = StrainAndIncrement::FiniteTotal;
167  else if (incremental && _strain == Strain::Small)
168  _strain_and_increment = StrainAndIncrement::SmallIncremental;
169  else if (incremental && _strain == Strain::Finite)
170  _strain_and_increment = StrainAndIncrement::FiniteIncremental;
171  else
172  mooseError("Internal error");
173  }
174  else
175  {
176  if (_strain == Strain::Small)
177  {
178  _strain_and_increment = StrainAndIncrement::SmallTotal;
179  mooseInfo("SolidMechanics Action: selecting 'total small strain' formulation. Use "
180  "`incremental = true` to select 'incremental small strain' instead.");
181  }
182  else if (_strain == Strain::Finite)
183  {
184  _strain_and_increment = StrainAndIncrement::FiniteIncremental;
185  mooseInfo("SolidMechanics Action: selecting 'incremental finite strain' formulation.");
186  }
187  else
188  mooseError("Internal error");
189  }
190 
191  // determine if displaced mesh is to be used
192  _use_displaced_mesh = (_strain == Strain::Finite);
193  if (params.isParamSetByUser("use_displaced_mesh") && !_lagrangian_kernels)
194  {
195  bool use_displaced_mesh_param = getParam<bool>("use_displaced_mesh");
196  if (use_displaced_mesh_param != _use_displaced_mesh && params.isParamSetByUser("strain"))
197  mooseError("Wrong combination of use displaced mesh and strain model");
198  _use_displaced_mesh = use_displaced_mesh_param;
199  }
200 
201  // convert vector of VariableName to vector of VariableName
202  for (unsigned int i = 0; i < _ndisp; ++i)
203  _coupled_displacements[i] = _displacements[i];
204 
205  if (_save_in.size() != 0 && _save_in.size() != _ndisp)
206  mooseError("Number of save_in variables should equal to the number of displacement variables ",
207  _ndisp);
208 
209  if (_diag_save_in.size() != 0 && _diag_save_in.size() != _ndisp)
210  mooseError(
211  "Number of diag_save_in variables should equal to the number of displacement variables ",
212  _ndisp);
213 
214  // plane strain consistency check
215  if (_planar_formulation != PlanarFormulation::None)
216  {
217  if (_lagrangian_kernels)
218  mooseDocumentedError(
219  "moose",
220  27340,
221  "Planar formulations are not yet available through the Physics syntax with new_system = "
222  "true. They can be enabled by manually setting up the appropriate objects. Please refer "
223  "to the documentation and regression tests for examples.");
224  if (params.isParamSetByUser("out_of_plane_strain") &&
225  _planar_formulation != PlanarFormulation::WeakPlaneStress)
226  mooseError(
227  "out_of_plane_strain should only be specified with planar_formulation=WEAK_PLANE_STRESS");
228  else if (!params.isParamSetByUser("out_of_plane_strain") &&
229  _planar_formulation == PlanarFormulation::WeakPlaneStress)
230  mooseError("out_of_plane_strain must be specified with planar_formulation=WEAK_PLANE_STRESS");
231  }
232 
233  // convert output variable names to lower case
234  for (const auto & out : getParam<MultiMooseEnum>("generate_output"))
235  {
236  std::string lower(out);
237  std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
238  _generate_output.push_back(lower);
239  }
240 
241  if (!_generate_output.empty())
242  verifyOrderAndFamilyOutputs();
243 
244  // Error if volumetric locking correction is true for 1D problems
245  if (_ndisp == 1 && getParam<bool>("volumetric_locking_correction"))
246  mooseError("Volumetric locking correction should be set to false for 1D problems.");
247 
248  if (!getParam<bool>("add_variables") && params.isParamSetByUser("scaling"))
249  paramError("scaling",
250  "The scaling parameter has no effect unless add_variables is set to true. Did you "
251  "mean to set 'add_variables = true'?");
252 
253  // Get cylindrical axis points if set by user
254  if (_cylindrical_axis_point1_valid && _cylindrical_axis_point2_valid)
255  {
256  _cylindrical_axis_point1 = getParam<Point>("cylindrical_axis_point1");
257  _cylindrical_axis_point2 = getParam<Point>("cylindrical_axis_point2");
258  }
259 
260  // Get spherical center point if set by user
261  if (_spherical_center_point_valid)
262  _spherical_center_point = getParam<Point>("spherical_center_point");
263 
264  // Get direction for tensor component if set by user
265  if (_direction_valid)
266  _direction = getParam<Point>("direction");
267 
268  // Get eigenstrain names if passed by user
269  _eigenstrain_names = getParam<std::vector<MaterialPropertyName>>("eigenstrain_names");
270 
271  // Determine if we're going to use the homogenization system for the new
272  // lagrangian kernels
273  bool ctype_set = params.isParamSetByUser("constraint_types");
274  bool targets_set = params.isParamSetByUser("targets");
275  if (ctype_set || targets_set)
276  {
277  if (!(ctype_set && targets_set))
278  mooseError("To use the Lagrangian kernel homogenization system you "
279  "most provide both the constraint_types and the targets "
280  "parameters");
281  _lk_homogenization = true;
282  // Do consistency checking on the kernel options
283  if (_lk_homogenization && (_lk_formulation == LKFormulation::Updated))
284  mooseError("The Lagrangian kernel homogenization system requires the "
285  "use of formulation = TOTAL");
286  }
287 
288  // Cross check options to weed out incompatible choices for the new lagrangian
289  // kernel system
290  if (_lagrangian_kernels)
291  {
292  if (_use_ad)
293  mooseError("The Lagrangian kernel system is not yet compatible with AD. "
294  "Do not set the use_automatic_differentiation flag.");
295 
296  if (params.isParamSetByUser("use_finite_deform_jacobian"))
297  mooseError("The Lagrangian kernel system always produces the exact "
298  "Jacobian. use_finite_deform_jacobian is redundant and "
299  " should not be set");
300  if (params.isParamSetByUser("global_strain"))
301  mooseError("The Lagrangian kernel system is not compatible with "
302  "the global_strain option. Use the homogenization "
303  " system instead");
304  if (params.isParamSetByUser("decomposition_method"))
305  mooseError("The decomposition_method parameter should not be used "
306  " with the Lagrangian kernel system. Similar options "
307  " for native small deformation material models are "
308  " available as part of the ComputeLagrangianStress "
309  " material system.");
310  }
311  else
312  {
313  if (params.isParamSetByUser("formulation"))
314  mooseError("The StressDiveregenceTensor system always uses an "
315  " updated Lagrangian formulation. Do not set the "
316  " formulation parameter, it is only used with the "
317  " new Lagrangian kernel system.");
318  if (_lk_homogenization)
319  mooseError("The homogenization system can only be used with the "
320  "new Lagrangian kernels");
321  }
322 }
QuasiStaticSolidMechanicsPhysics::_lk_large_kinematics
const bool _lk_large_kinematics
Simplified flag for small/large deformations, Lagrangian kernel system.
Definition: QuasiStaticSolidMechanicsPhysics.h:142
QuasiStaticSolidMechanicsPhysics::_strain_and_increment
enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement _strain_and_increment
QuasiStaticSolidMechanicsPhysics::_save_in
std::vector< AuxVariableName > _save_in
residual debugging
Definition: QuasiStaticSolidMechanicsPhysics.h:56
QuasiStaticSolidMechanicsPhysics::_diag_save_in
std::vector< AuxVariableName > _diag_save_in
Definition: QuasiStaticSolidMechanicsPhysics.h:57
QuasiStaticSolidMechanicsPhysics::_subdomain_ids
std::set< SubdomainID > _subdomain_ids
set generated from the passed in vector of subdomain names
Definition: QuasiStaticSolidMechanicsPhysics.h:66
Action::mooseInfo
void mooseInfo(Args &&... args) const
QuasiStaticSolidMechanicsPhysics::_ndisp
unsigned int _ndisp
Number of displacement variables.
Definition: QuasiStaticSolidMechanicsPhysics.h:49
QuasiStaticSolidMechanicsPhysics::_auto_eigenstrain
const bool _auto_eigenstrain
automatically gather names of eigenstrain tensors provided by simulation objects
Definition: QuasiStaticSolidMechanicsPhysics.h:134
QuasiStaticSolidMechanicsPhysics::_displacements
std::vector< VariableName > _displacements
displacement variables
Definition: QuasiStaticSolidMechanicsPhysics.h:46
QuasiStaticSolidMechanicsPhysics::_generate_output
std::vector< std::string > _generate_output
output materials to generate scalar stress/strain tensor quantities
Definition: QuasiStaticSolidMechanicsPhysics.h:112
QuasiStaticSolidMechanicsPhysicsBase::QuasiStaticSolidMechanicsPhysicsBase
QuasiStaticSolidMechanicsPhysicsBase(const InputParameters &params)
Definition: QuasiStaticSolidMechanicsPhysicsBase.C:250
QuasiStaticSolidMechanicsPhysics::_planar_formulation
enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation _planar_formulation
Action::isParamValid
bool isParamValid(const std::string &name) const
QuasiStaticSolidMechanicsPhysics::_subdomain_names
std::vector< SubdomainName > _subdomain_names
if this vector is not empty the variables, kernels and materials are restricted to these subdomains ...
Definition: QuasiStaticSolidMechanicsPhysics.h:63
Action::mooseDocumentedError
void mooseDocumentedError(const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
QuasiStaticSolidMechanicsPhysics::_use_displaced_mesh
bool _use_displaced_mesh
use displaced mesh (true unless _strain is SMALL)
Definition: QuasiStaticSolidMechanicsPhysics.h:109
QuasiStaticSolidMechanicsPhysics::_strain
enum QuasiStaticSolidMechanicsPhysics::Strain _strain
QuasiStaticSolidMechanicsPhysics::_coupled_displacements
std::vector< VariableName > _coupled_displacements
Coupled displacement variables.
Definition: QuasiStaticSolidMechanicsPhysics.h:52
QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1_valid
bool _cylindrical_axis_point1_valid
booleans used to determine if cylindrical axis points are passed
Definition: QuasiStaticSolidMechanicsPhysics.h:117
QuasiStaticSolidMechanicsPhysics::_lk_locking
bool _lk_locking
Simplified volumetric locking correction flag for new kernels.
Definition: QuasiStaticSolidMechanicsPhysics.h:153
Action::getParam
const T & getParam(const std::string &name) const
Action::paramError
void paramError(const std::string &param, Args... args) const
QuasiStaticSolidMechanicsPhysics::_eigenstrain_names
std::vector< MaterialPropertyName > _eigenstrain_names
Definition: QuasiStaticSolidMechanicsPhysics.h:136
InputParameters::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
QuasiStaticSolidMechanicsPhysics::_lagrangian_kernels
const bool _lagrangian_kernels
New or old kernel system.
Definition: QuasiStaticSolidMechanicsPhysics.h:139
Action::mooseError
void mooseError(Args &&... args) const
QuasiStaticSolidMechanicsPhysics::_spherical_center_point
Point _spherical_center_point
center point for spherical stress/strain quantities
Definition: QuasiStaticSolidMechanicsPhysics.h:131
QuasiStaticSolidMechanicsPhysics::_spherical_center_point_valid
bool _spherical_center_point_valid
booleans used to determine if spherical center point is passed
Definition: QuasiStaticSolidMechanicsPhysics.h:128
QuasiStaticSolidMechanicsPhysics::_base_name
const std::string _base_name
base name for the current master action block
Definition: QuasiStaticSolidMechanicsPhysics.h:106
QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1
Point _cylindrical_axis_point1
points used to determine axis of rotation for cylindrical stress/strain quantities ...
Definition: QuasiStaticSolidMechanicsPhysics.h:123
QuasiStaticSolidMechanicsPhysics::_lk_homogenization
bool _lk_homogenization
Flag indicating if the homogenization system is present for new kernels.
Definition: QuasiStaticSolidMechanicsPhysics.h:156

Member Function Documentation

◆ act()

void QuasiStaticSolidMechanicsPhysics::act ( )
virtual

Implements Action.

Reimplemented in LegacyDynamicTensorMechanicsAction, LegacyTensorMechanicsAction, PoroMechanicsAction, and DynamicSolidMechanicsPhysics.

Definition at line 325 of file QuasiStaticSolidMechanicsPhysics.C.

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

326 {
327  std::string ad_prepend = "";
328  if (_use_ad)
329  ad_prepend = "AD";
330 
331  // Consistency checks across subdomains
332  actSubdomainChecks();
333 
334  // Gather info from all other QuasiStaticSolidMechanicsPhysics
335  actGatherActionParameters();
336 
337  // Deal with the optional AuxVariable based tensor quantity output
338  actOutputGeneration();
339 
340  // Meta action which optionally spawns other actions
341  if (_current_task == "meta_action")
342  {
343  if (_planar_formulation == PlanarFormulation::GeneralizedPlaneStrain)
344  {
345  if (_use_ad)
346  paramError("use_automatic_differentiation", "AD not setup for use with PlaneStrain");
347  // Set the action parameters
348  const std::string type = "GeneralizedPlaneStrainAction";
349  auto action_params = _action_factory.getValidParams(type);
350  action_params.set<bool>("_built_by_moose") = true;
351  action_params.set<std::string>("registered_identifier") = "(AutoBuilt)";
352 
353  // Skipping selected parameters in applyParameters() and then manually setting them only if
354  // they are set by the user is just to prevent both the current and deprecated variants of
355  // these parameters from both getting passed to the UserObject. Once we get rid of the
356  // deprecated versions, we can just set them all with applyParameters().
357  action_params.applyParameters(parameters(),
358  {"use_displaced_mesh",
359  "out_of_plane_pressure",
360  "out_of_plane_pressure_function",
361  "factor",
362  "pressure_factor"});
363  action_params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
364 
365  if (parameters().isParamSetByUser("out_of_plane_pressure"))
366  action_params.set<FunctionName>("out_of_plane_pressure") =
367  getParam<FunctionName>("out_of_plane_pressure");
368  if (parameters().isParamSetByUser("out_of_plane_pressure_function"))
369  action_params.set<FunctionName>("out_of_plane_pressure_function") =
370  getParam<FunctionName>("out_of_plane_pressure_function");
371  if (parameters().isParamSetByUser("factor"))
372  action_params.set<Real>("factor") = getParam<Real>("factor");
373  if (parameters().isParamSetByUser("pressure_factor"))
374  action_params.set<Real>("pressure_factor") = getParam<Real>("pressure_factor");
375 
376  // Create and add the action to the warehouse
377  auto action = MooseSharedNamespace::static_pointer_cast<MooseObjectAction>(
378  _action_factory.create(type, name() + "_gps", action_params));
379  _awh.addActionBlock(action);
380  }
381  }
382 
383  // Add variables
384  else if (_current_task == "add_variable")
385  {
386  // Add variables here only if the CommonSolidMechanicsAction does not exist.
387  // This happens notably if the QuasiStaticSolidMechanics was created by a meta_action
388  const auto common_actions = _awh.getActions<CommonSolidMechanicsAction>();
389  if (common_actions.empty() && getParam<bool>("add_variables"))
390  {
391  auto params = _factory.getValidParams("MooseVariable");
392  // determine necessary order
393  const bool second = _problem->mesh().hasSecondOrderElements();
394 
395  params.set<MooseEnum>("order") = second ? "SECOND" : "FIRST";
396  params.set<MooseEnum>("family") = "LAGRANGE";
397  if (isParamValid("scaling"))
398  params.set<std::vector<Real>>("scaling") = {getParam<Real>("scaling")};
399 
400  // Note how we do not add the block restriction because BISON's meta-actions
401  // currently rely on them not being added.
402 
403  // Loop through the displacement variables
404  for (const auto & disp : _displacements)
405  {
406  // Create displacement variables
407  _problem->addVariable("MooseVariable", disp, params);
408  }
409  }
410 
411  // Homogenization scalar
412  if (_lk_homogenization)
413  {
414  InputParameters params = _factory.getValidParams("MooseVariable");
415  const std::map<bool, std::vector<unsigned int>> mg_order{{true, {1, 4, 9}},
416  {false, {1, 3, 6}}};
417  params.set<MooseEnum>("family") = "SCALAR";
418  params.set<MooseEnum>("order") = mg_order.at(_lk_large_kinematics)[_ndisp - 1];
419  auto fe_type = AddVariableAction::feType(params);
420  auto var_type = AddVariableAction::variableType(fe_type);
421  _problem->addVariable(var_type, _hname, params);
422  }
423  }
424  // Add Materials
425  else if (_current_task == "add_master_action_material")
426  {
427  // Automatic eigenstrain names
428  if (_auto_eigenstrain)
429  actEigenstrainNames();
430 
431  // Easiest just to branch on type here, as the strain systems are completely
432  // different
433  if (_lagrangian_kernels)
434  actLagrangianKernelStrain();
435  else
436  actStressDivergenceTensorsStrain();
437  }
438 
439  // Add Stress Divergence (and optionally WeakPlaneStress) Kernels
440  else if (_current_task == "add_kernel")
441  {
442  for (unsigned int i = 0; i < _ndisp; ++i)
443  {
444  auto tensor_kernel_type = getKernelType();
445  auto params = getKernelParameters(ad_prepend + tensor_kernel_type);
446 
447  std::string kernel_name = "TM_" + name() + Moose::stringify(i);
448 
449  // Set appropriate components for kernels, including in the cases where a planar model is
450  // running in planes other than the x-y plane (defined by _out_of_plane_strain_direction).
451  if (_out_of_plane_direction == OutOfPlaneDirection::x && i == 0)
452  continue;
453  else if (_out_of_plane_direction == OutOfPlaneDirection::y && i == 1)
454  continue;
455 
456  params.set<unsigned int>("component") = i;
457 
458  params.set<NonlinearVariableName>("variable") = _displacements[i];
459 
460  if (_save_in.size() == _ndisp)
461  params.set<std::vector<AuxVariableName>>("save_in") = {_save_in[i]};
462  if (_diag_save_in.size() == _ndisp)
463  params.set<std::vector<AuxVariableName>>("diag_save_in") = {_diag_save_in[i]};
464  if (isParamValid("out_of_plane_strain") && !_lagrangian_kernels)
465  params.set<std::vector<VariableName>>("out_of_plane_strain") = {
466  getParam<VariableName>("out_of_plane_strain")};
467 
468  if (_lk_homogenization)
469  {
470  params.set<std::vector<VariableName>>("macro_gradient") = {_hname};
471  params.set<UserObjectName>("homogenization_constraint") = _integrator_name;
472  }
473 
474  _problem->addKernel(ad_prepend + tensor_kernel_type, kernel_name, params);
475  }
476 
477  if (_planar_formulation == PlanarFormulation::WeakPlaneStress)
478  {
479  auto params = getKernelParameters(ad_prepend + "WeakPlaneStress");
480  std::string wps_kernel_name = "TM_WPS_" + name();
481  params.set<NonlinearVariableName>("variable") = getParam<VariableName>("out_of_plane_strain");
482 
483  _problem->addKernel(ad_prepend + "WeakPlaneStress", wps_kernel_name, params);
484  }
485  }
486  else if (_current_task == "add_scalar_kernel")
487  {
488  if (_lk_homogenization)
489  {
490  InputParameters params = _factory.getValidParams("HomogenizationConstraintScalarKernel");
491  params.set<NonlinearVariableName>("variable") = _hname;
492  params.set<UserObjectName>("homogenization_constraint") = _integrator_name;
493 
494  _problem->addScalarKernel(
495  "HomogenizationConstraintScalarKernel", "HomogenizationConstraints", params);
496  }
497  }
498  else if (_current_task == "add_user_object")
499  {
500  if (_lk_homogenization)
501  {
502  InputParameters params = _factory.getValidParams("HomogenizationConstraint");
503  params.set<MultiMooseEnum>("constraint_types") = _constraint_types;
504  params.set<std::vector<FunctionName>>("targets") = _targets;
505  params.set<bool>("large_kinematics") = _lk_large_kinematics;
506  params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
507  params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR, EXEC_NONLINEAR};
508 
509  _problem->addUserObject("HomogenizationConstraint", _integrator_name, params);
510  }
511  }
512 }
QuasiStaticSolidMechanicsPhysics::_lk_large_kinematics
const bool _lk_large_kinematics
Simplified flag for small/large deformations, Lagrangian kernel system.
Definition: QuasiStaticSolidMechanicsPhysics.h:142
QuasiStaticSolidMechanicsPhysics::_save_in
std::vector< AuxVariableName > _save_in
residual debugging
Definition: QuasiStaticSolidMechanicsPhysics.h:56
QuasiStaticSolidMechanicsPhysics::getKernelParameters
virtual InputParameters getKernelParameters(std::string type)
Definition: QuasiStaticSolidMechanicsPhysics.C:1142
Action::_awh
ActionWarehouse & _awh
QuasiStaticSolidMechanicsPhysics::_diag_save_in
std::vector< AuxVariableName > _diag_save_in
Definition: QuasiStaticSolidMechanicsPhysics.h:57
ActionFactory::getValidParams
InputParameters getValidParams(const std::string &name)
QuasiStaticSolidMechanicsPhysics::_ndisp
unsigned int _ndisp
Number of displacement variables.
Definition: QuasiStaticSolidMechanicsPhysics.h:49
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
QuasiStaticSolidMechanicsPhysics::_auto_eigenstrain
const bool _auto_eigenstrain
automatically gather names of eigenstrain tensors provided by simulation objects
Definition: QuasiStaticSolidMechanicsPhysics.h:134
ActionWarehouse::addActionBlock
void addActionBlock(std::shared_ptr< Action > blk)
CommonSolidMechanicsAction
Store common tensor mechanics parameters.
Definition: CommonSolidMechanicsAction.h:17
QuasiStaticSolidMechanicsPhysics::_displacements
std::vector< VariableName > _displacements
displacement variables
Definition: QuasiStaticSolidMechanicsPhysics.h:46
Action::name
virtual const std::string & name() const
ActionFactory::create
std::shared_ptr< Action > create(const std::string &action, const std::string &action_name, InputParameters &parameters)
QuasiStaticSolidMechanicsPhysics::_planar_formulation
enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation _planar_formulation
Action::isParamValid
bool isParamValid(const std::string &name) const
Action::_factory
Factory & _factory
QuasiStaticSolidMechanicsPhysics::_subdomain_names
std::vector< SubdomainName > _subdomain_names
if this vector is not empty the variables, kernels and materials are restricted to these subdomains ...
Definition: QuasiStaticSolidMechanicsPhysics.h:63
QuasiStaticSolidMechanicsPhysics::_use_displaced_mesh
bool _use_displaced_mesh
use displaced mesh (true unless _strain is SMALL)
Definition: QuasiStaticSolidMechanicsPhysics.h:109
Action::type
const std::string & type() const
Action::_current_task
const std::string & _current_task
AddVariableAction::variableType
static std::string variableType(const libMesh::FEType &fe_type, const bool is_fv=false, const bool is_array=false)
Action::paramError
void paramError(const std::string &param, Args... args) const
Action::_action_factory
ActionFactory & _action_factory
EXEC_LINEAR
const ExecFlagType EXEC_LINEAR
Moose::stringify
std::string stringify(const T &t)
EXEC_NONLINEAR
const ExecFlagType EXEC_NONLINEAR
InputParameters::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
AddVariableAction::feType
static libMesh::FEType feType(const InputParameters &params)
QuasiStaticSolidMechanicsPhysics::_lagrangian_kernels
const bool _lagrangian_kernels
New or old kernel system.
Definition: QuasiStaticSolidMechanicsPhysics.h:139
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::parameters
const InputParameters & parameters() const
ActionWarehouse::getActions
std::vector< const T *> getActions()
QuasiStaticSolidMechanicsPhysics::_lk_homogenization
bool _lk_homogenization
Flag indicating if the homogenization system is present for new kernels.
Definition: QuasiStaticSolidMechanicsPhysics.h:156
EXEC_INITIAL
const ExecFlagType EXEC_INITIAL

◆ actEigenstrainNames()

void QuasiStaticSolidMechanicsPhysics::actEigenstrainNames ( )
protected

Definition at line 645 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

646 {
647  // Create containers for collecting blockIDs and eigenstrain names from materials
648  std::map<std::string, std::set<SubdomainID>> material_eigenstrain_map;
649  std::set<std::string> eigenstrain_set;
650 
651  std::set<MaterialPropertyName> verified_eigenstrain_names;
652 
653  std::map<std::string, std::string> remove_add_map;
654  std::set<std::string> remove_reduced_set;
655 
656  // Loop over all the materials(eigenstrains) already created
657  auto materials = _problem->getMaterialWarehouse().getObjects();
658  for (auto & mat : materials)
659  {
660  std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(mat);
661  const InputParameters & mat_params = mat->parameters();
662  auto & mat_name = mat->type();
663 
664  // Check for eigenstrain names, only deal with those materials
665  if (mat_params.isParamValid("eigenstrain_name"))
666  {
667  std::shared_ptr<MaterialData> mat_dat;
668  auto name = mat_params.get<std::string>("eigenstrain_name");
669 
670  // Check for base_name prefix
671  if (mat_params.isParamValid("base_name"))
672  name = mat_params.get<std::string>("base_name") + '_' + name;
673 
674  // Check block restrictions
675  if (!blk)
676  mooseError("Internal error, Material object that does not inherit form BlockRestricted");
677  const std::set<SubdomainID> & blocks =
678  blk->blockRestricted() ? blk->blockIDs() : blk->meshBlockIDs();
679 
680  if (std::includes(blocks.begin(), blocks.end(), _subdomain_ids.begin(), _subdomain_ids.end()))
681  {
682  material_eigenstrain_map[name].insert(blocks.begin(), blocks.end());
683  eigenstrain_set.insert(name);
684  }
685  }
686 
687  // Account for reduced eigenstrains and CompositeEigenstrains
688  if (mat_name == "ComputeReducedOrderEigenstrain")
689  {
690  auto input_eigenstrain_names =
691  mat_params.get<std::vector<MaterialPropertyName>>("input_eigenstrain_names");
692  remove_reduced_set.insert(input_eigenstrain_names.begin(), input_eigenstrain_names.end());
693  }
694  // Account for CompositeEigenstrains
695  if (mat_name == "CompositeEigenstrain")
696  {
697  auto remove_list = mat_params.get<std::vector<MaterialPropertyName>>("tensors");
698  for (auto i : remove_list)
699  remove_reduced_set.insert(i);
700  }
701 
702  // Account for MaterialADConverter , add or remove later
703  if (mat_name == "RankTwoTensorMaterialADConverter")
704  {
705  std::vector<MaterialPropertyName> remove_list;
706  std::vector<MaterialPropertyName> add_list;
707 
708  if (mat_params.isParamValid("ad_props_out") && mat_params.isParamValid("reg_props_in") &&
709  _use_ad)
710  {
711  remove_list = mat_params.get<std::vector<MaterialPropertyName>>("reg_props_in");
712  add_list = mat_params.get<std::vector<MaterialPropertyName>>("ad_props_out");
713  }
714  if (mat_params.isParamValid("ad_props_in") && mat_params.isParamValid("reg_props_out") &&
715  !_use_ad)
716  {
717  remove_list = mat_params.get<std::vector<MaterialPropertyName>>("ad_props_in");
718  add_list = mat_params.get<std::vector<MaterialPropertyName>>("reg_props_out");
719  }
720 
721  // These vectors are the same size as checked in MaterialADConverter
722  for (unsigned int index = 0; index < remove_list.size(); index++)
723  remove_add_map.emplace(remove_list[index], add_list[index]);
724  }
725  }
726  // All the materials have been accounted for, now remove or add parts
727 
728  // Remove names which aren't eigenstrains (converter properties)
729  for (auto remove_add_index : remove_add_map)
730  {
731  const bool is_in = eigenstrain_set.find(remove_add_index.first) != eigenstrain_set.end();
732  if (is_in)
733  {
734  eigenstrain_set.erase(remove_add_index.first);
735  eigenstrain_set.insert(remove_add_index.second);
736  }
737  }
738  for (auto index : remove_reduced_set)
739  eigenstrain_set.erase(index);
740 
741  // Compare the blockIDs set of eigenstrain names with the vector of _eigenstrain_names for the
742  // current subdomainID
743  std::set_union(eigenstrain_set.begin(),
744  eigenstrain_set.end(),
745  _eigenstrain_names.begin(),
746  _eigenstrain_names.end(),
747  std::inserter(verified_eigenstrain_names, verified_eigenstrain_names.begin()));
748 
749  // Ensure the eigenstrain names previously passed include any missing names
750  _eigenstrain_names.resize(verified_eigenstrain_names.size());
751  std::copy(verified_eigenstrain_names.begin(),
752  verified_eigenstrain_names.end(),
753  _eigenstrain_names.begin());
754 
755  Moose::out << COLOR_CYAN << "*** Automatic Eigenstrain Names ***"
756  << "\n"
757  << _name << ": " << Moose::stringify(_eigenstrain_names) << "\n"
758  << COLOR_DEFAULT << std::flush;
759 }
blocks
char ** blocks
QuasiStaticSolidMechanicsPhysics::_subdomain_ids
std::set< SubdomainID > _subdomain_ids
set generated from the passed in vector of subdomain names
Definition: QuasiStaticSolidMechanicsPhysics.h:66
Action::name
virtual const std::string & name() const
Moose::stringify
std::string stringify(const T &t)
Action::_name
const std::string _name
QuasiStaticSolidMechanicsPhysics::_eigenstrain_names
std::vector< MaterialPropertyName > _eigenstrain_names
Definition: QuasiStaticSolidMechanicsPhysics.h:136
Action::mooseError
void mooseError(Args &&... args) const
Action::_problem
std::shared_ptr< FEProblemBase > & _problem

◆ actGatherActionParameters()

void QuasiStaticSolidMechanicsPhysics::actGatherActionParameters ( )
protected

Definition at line 920 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

921 {
922  // Gather info about all other solid mechanics physics when we add variables
923  if (_current_task == "validate_coordinate_systems" && getParam<bool>("add_variables"))
924  {
925  auto actions = _awh.getActions<QuasiStaticSolidMechanicsPhysics>();
926  for (const auto & action : actions)
927  {
928  const auto size_before = _subdomain_id_union.size();
929  const auto added_size = action->_subdomain_ids.size();
930  _subdomain_id_union.insert(action->_subdomain_ids.begin(), action->_subdomain_ids.end());
931  const auto size_after = _subdomain_id_union.size();
932 
933  if (size_after != size_before + added_size)
934  mooseError("The block restrictions in the SolidMechanics/QuasiStatic actions must be "
935  "non-overlapping.");
936 
937  if (added_size == 0 && actions.size() > 1)
938  mooseError(
939  "No SolidMechanics/QuasiStatic action can be block unrestricted if more than one "
940  "SolidMechanics/QuasiStatic action is specified.");
941  }
942  }
943 }
QuasiStaticSolidMechanicsPhysics::_subdomain_id_union
std::set< SubdomainID > _subdomain_id_union
set generated from the combined block restrictions of all SolidMechanics/Master action blocks ...
Definition: QuasiStaticSolidMechanicsPhysics.h:69
Action::_awh
ActionWarehouse & _awh
Action::_current_task
const std::string & _current_task
Action::mooseError
void mooseError(Args &&... args) const
ActionWarehouse::getActions
std::vector< const T *> getActions()

◆ actLagrangianKernelStrain()

void QuasiStaticSolidMechanicsPhysics::actLagrangianKernelStrain ( )
protected

Definition at line 946 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

947 {
948  std::string type;
949  if (_coord_system == Moose::COORD_XYZ)
950  type = "ComputeLagrangianStrain";
951  else if (_coord_system == Moose::COORD_RZ)
952  type = "ComputeLagrangianStrainAxisymmetricCylindrical";
953  else if (_coord_system == Moose::COORD_RSPHERICAL)
954  type = "ComputeLagrangianStrainCentrosymmetricSpherical";
955  else
956  mooseError("Unsupported coordinate system");
957 
958  auto params = _factory.getValidParams(type);
959 
960  if (isParamValid("strain_base_name"))
961  params.set<std::string>("base_name") = getParam<std::string>("strain_base_name");
962 
963  params.set<std::vector<VariableName>>("displacements") = _coupled_displacements;
964  params.set<std::vector<MaterialPropertyName>>("eigenstrain_names") = _eigenstrain_names;
965  params.set<bool>("large_kinematics") = _lk_large_kinematics;
966  params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
967 
968  // Error if volumetric locking correction is on for higher-order elements
969  if (_problem->mesh().hasSecondOrderElements() && _lk_locking)
970  mooseError("Volumetric locking correction should not be used for "
971  "higher-order elements.");
972 
973  params.set<bool>("stabilize_strain") = _lk_locking;
974 
975  if (_lk_homogenization)
976  {
977  params.set<std::vector<MaterialPropertyName>>("homogenization_gradient_names") = {
978  _homogenization_strain_name};
979  }
980 
981  _problem->addMaterial(type, name() + "_strain", params);
982 
983  // Add the homogenization strain calculator
984  if (_lk_homogenization)
985  {
986  std::string type = "ComputeHomogenizedLagrangianStrain";
987  auto params = _factory.getValidParams(type);
988 
989  params.set<MaterialPropertyName>("homogenization_gradient_name") = _homogenization_strain_name;
990  params.set<std::vector<VariableName>>("macro_gradient") = {_hname};
991  params.set<UserObjectName>("homogenization_constraint") = _integrator_name;
992 
993  _problem->addMaterial(type, name() + "_compute_" + _homogenization_strain_name, params);
994  }
995 }
QuasiStaticSolidMechanicsPhysics::_lk_large_kinematics
const bool _lk_large_kinematics
Simplified flag for small/large deformations, Lagrangian kernel system.
Definition: QuasiStaticSolidMechanicsPhysics.h:142
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
Moose::COORD_RSPHERICAL
COORD_RSPHERICAL
Action::name
virtual const std::string & name() const
Action::isParamValid
bool isParamValid(const std::string &name) const
Action::_factory
Factory & _factory
QuasiStaticSolidMechanicsPhysics::_subdomain_names
std::vector< SubdomainName > _subdomain_names
if this vector is not empty the variables, kernels and materials are restricted to these subdomains ...
Definition: QuasiStaticSolidMechanicsPhysics.h:63
QuasiStaticSolidMechanicsPhysics::_coupled_displacements
std::vector< VariableName > _coupled_displacements
Coupled displacement variables.
Definition: QuasiStaticSolidMechanicsPhysics.h:52
Action::type
const std::string & type() const
QuasiStaticSolidMechanicsPhysics::_lk_locking
bool _lk_locking
Simplified volumetric locking correction flag for new kernels.
Definition: QuasiStaticSolidMechanicsPhysics.h:153
QuasiStaticSolidMechanicsPhysics::_eigenstrain_names
std::vector< MaterialPropertyName > _eigenstrain_names
Definition: QuasiStaticSolidMechanicsPhysics.h:136
Action::mooseError
void mooseError(Args &&... args) const
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
QuasiStaticSolidMechanicsPhysics::_lk_homogenization
bool _lk_homogenization
Flag indicating if the homogenization system is present for new kernels.
Definition: QuasiStaticSolidMechanicsPhysics.h:156

◆ actOutputGeneration()

void QuasiStaticSolidMechanicsPhysics::actOutputGeneration ( )
protected

Definition at line 564 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

565 {
566  if (_current_task == "add_material")
567  actOutputMatProp();
568 
569  // Add variables (optional)
570  if (_current_task == "add_aux_variable")
571  {
572  unsigned int index = 0;
573  for (auto out : _generate_output)
574  {
575  const auto & order = _material_output_order[index];
576  const auto & family = _material_output_family[index];
577 
578  std::string type = (order == "CONSTANT" && family == "MONOMIAL")
579  ? "MooseVariableConstMonomial"
580  : "MooseVariable";
581 
582  // Create output helper aux variables
583  auto params = _factory.getValidParams(type);
584  params.set<MooseEnum>("order") = order;
585  params.set<MooseEnum>("family") = family;
586 
587  if (family == "MONOMIAL")
588  _problem->addAuxVariable(type, _base_name + out, params);
589  else
590  _problem->addVariable(type, _base_name + out, params);
591 
592  index++;
593  }
594  }
595 
596  // Add output AuxKernels
597  else if (_current_task == "add_aux_kernel")
598  {
599  std::string ad_prepend = _use_ad ? "AD" : "";
600  // Loop through output aux variables
601  unsigned int index = 0;
602  for (auto out : _generate_output)
603  {
604  if (_material_output_family[index] == "MONOMIAL")
605  {
606  InputParameters params = emptyInputParameters();
607 
608  params = _factory.getValidParams("MaterialRealAux");
609  params.applyParameters(parameters());
610  params.set<MaterialPropertyName>("property") = _base_name + out;
611  params.set<AuxVariableName>("variable") = _base_name + out;
612  params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
613 
614  _problem->addAuxKernel(
615  ad_prepend + "MaterialRealAux", _base_name + out + '_' + name(), params);
616  }
617  index++;
618  }
619  }
620  else if (_current_task == "add_kernel")
621  {
622  std::string ad_prepend = _use_ad ? "AD" : "";
623  // Loop through output aux variables
624  unsigned int index = 0;
625  for (auto out : _generate_output)
626  {
627  if (_material_output_family[index] != "MONOMIAL")
628  {
629  InputParameters params = emptyInputParameters();
630 
631  params = _factory.getValidParams("MaterialPropertyValue");
632  params.applyParameters(parameters());
633  params.set<MaterialPropertyName>("prop_name") = _base_name + out;
634  params.set<NonlinearVariableName>("variable") = _base_name + out;
635 
636  _problem->addKernel(
637  ad_prepend + "MaterialPropertyValue", _base_name + out + '_' + name(), params);
638  }
639  index++;
640  }
641  }
642 }
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
QuasiStaticSolidMechanicsPhysics::_generate_output
std::vector< std::string > _generate_output
output materials to generate scalar stress/strain tensor quantities
Definition: QuasiStaticSolidMechanicsPhysics.h:112
Action::name
virtual const std::string & name() const
emptyInputParameters
InputParameters emptyInputParameters()
Action::_factory
Factory & _factory
Action::type
const std::string & type() const
Action::_current_task
const std::string & _current_task
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::parameters
const InputParameters & parameters() const
QuasiStaticSolidMechanicsPhysics::_base_name
const std::string _base_name
base name for the current master action block
Definition: QuasiStaticSolidMechanicsPhysics.h:106

◆ actOutputMatProp()

void QuasiStaticSolidMechanicsPhysics::actOutputMatProp ( )
protected

Definition at line 812 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by actOutputGeneration().

813 {
814  std::string ad_prepend = _use_ad ? "AD" : "";
815 
816  if (_current_task == "add_material")
817  {
818  // Add output Materials
819  for (auto out : _generate_output)
820  {
821  InputParameters params = emptyInputParameters();
822 
823  // RankTwoCartesianComponent
824  if (
825  [&]()
826  {
827  for (const auto & r2q : _rank_two_cartesian_component_table)
828  for (unsigned int a = 0; a < 3; ++a)
829  for (unsigned int b = 0; b < 3; ++b)
830  if (r2q.first + '_' + _component_table[a] + _component_table[b] == out)
831  {
832  auto type = ad_prepend + "RankTwoCartesianComponent";
833  params = _factory.getValidParams(type);
834  params.set<MaterialPropertyName>("rank_two_tensor") = _base_name + r2q.second;
835  params.set<unsigned int>("index_i") = a;
836  params.set<unsigned int>("index_j") = b;
837 
838  params.applyParameters(parameters());
839  params.set<MaterialPropertyName>("property_name") = _base_name + out;
840  _problem->addMaterial(type, _base_name + out + '_' + name(), params);
841  return true;
842  }
843  return false;
844  }())
845  continue;
846 
847  // RankTwoDirectionalComponent
848  if (setupOutput(out,
849  _rank_two_directional_component_table,
850  [&](std::string prop_name, std::string invariant)
851  {
852  auto type = ad_prepend + "RankTwoDirectionalComponent";
853  params = _factory.getValidParams(type);
854  params.set<MaterialPropertyName>("rank_two_tensor") =
855  _base_name + prop_name;
856  params.set<MooseEnum>("invariant") = invariant;
857  params.applyParameters(parameters());
858  params.set<MaterialPropertyName>("property_name") = _base_name + out;
859  _problem->addMaterial(type, _base_name + out + '_' + name(), params);
860  }))
861  continue;
862 
863  // RankTwoInvariant
864  if (setupOutput(out,
865  _rank_two_invariant_table,
866  [&](std::string prop_name, std::string invariant)
867  {
868  auto type = ad_prepend + "RankTwoInvariant";
869  params = _factory.getValidParams(type);
870  params.set<MaterialPropertyName>("rank_two_tensor") =
871  _base_name + prop_name;
872  params.set<MooseEnum>("invariant") = invariant;
873  params.applyParameters(parameters());
874  params.set<MaterialPropertyName>("property_name") = _base_name + out;
875  _problem->addMaterial(type, _base_name + out + '_' + name(), params);
876  }))
877  continue;
878 
879  // RankTwoCylindricalComponent
880  if (setupOutput(
881  out,
882  _rank_two_cylindrical_component_table,
883  [&](std::string prop_name, std::string component)
884  {
885  if (_coord_system == Moose::COORD_RSPHERICAL)
886  mooseError(
887  "Cannot use cylindrical component output in a spherical coordinate system.");
888  auto type = ad_prepend + "RankTwoCylindricalComponent";
889  params = _factory.getValidParams(type);
890  params.set<MaterialPropertyName>("rank_two_tensor") = _base_name + prop_name;
891  params.set<MooseEnum>("cylindrical_component") = component;
892  params.applyParameters(parameters());
893  params.set<MaterialPropertyName>("property_name") = _base_name + out;
894  _problem->addMaterial(type, _base_name + out + '_' + name(), params);
895  }))
896  continue;
897 
898  // RankTwoSphericalComponent
899  if (setupOutput(out,
900  _rank_two_spherical_component_table,
901  [&](std::string prop_name, std::string component)
902  {
903  auto type = ad_prepend + "RankTwoSphericalComponent";
904  params = _factory.getValidParams(type);
905  params.set<MaterialPropertyName>("rank_two_tensor") =
906  _base_name + prop_name;
907  params.set<MooseEnum>("spherical_component") = component;
908  params.applyParameters(parameters());
909  params.set<MaterialPropertyName>("property_name") = _base_name + out;
910  _problem->addMaterial(type, _base_name + out + '_' + name(), params);
911  }))
912  continue;
913 
914  paramError("generate_output", "Unable to add output Material for '", out, "'");
915  }
916  }
917 }
QuasiStaticSolidMechanicsPhysics::setupOutput
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 ...
Definition: QuasiStaticSolidMechanicsPhysics.h:173
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_invariant_table
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_invariant_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:29
NS::component
static const std::string component
Definition: NS.h:153
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cylindrical_component_table
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_cylindrical_component_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:33
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
Moose::COORD_RSPHERICAL
COORD_RSPHERICAL
QuasiStaticSolidMechanicsPhysics::_generate_output
std::vector< std::string > _generate_output
output materials to generate scalar stress/strain tensor quantities
Definition: QuasiStaticSolidMechanicsPhysics.h:112
Action::name
virtual const std::string & name() const
QuasiStaticSolidMechanicsPhysicsBase::_component_table
static const std::vector< char > _component_table
table data for output generation
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:27
emptyInputParameters
InputParameters emptyInputParameters()
Action::_factory
Factory & _factory
Action::type
const std::string & type() const
Action::_current_task
const std::string & _current_task
Action::paramError
void paramError(const std::string &param, Args... args) const
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_directional_component_table
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_directional_component_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:31
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cartesian_component_table
static std::map< std::string, std::string > _rank_two_cartesian_component_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:42
Action::mooseError
void mooseError(Args &&... args) const
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::parameters
const InputParameters & parameters() const
QuasiStaticSolidMechanicsPhysics::_base_name
const std::string _base_name
base name for the current master action block
Definition: QuasiStaticSolidMechanicsPhysics.h:106
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_spherical_component_table
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_spherical_component_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:35

◆ actStressDivergenceTensorsStrain()

void QuasiStaticSolidMechanicsPhysics::actStressDivergenceTensorsStrain ( )
protected

Definition at line 998 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

999 {
1000  std::string ad_prepend = _use_ad ? "AD" : "";
1001 
1002  std::string type;
1003 
1004  // no plane strain
1005  if (_planar_formulation == PlanarFormulation::None)
1006  {
1007  std::map<std::pair<Moose::CoordinateSystemType, StrainAndIncrement>, std::string> type_map = {
1008  {{Moose::COORD_XYZ, StrainAndIncrement::SmallTotal}, "ComputeSmallStrain"},
1009  {{Moose::COORD_XYZ, StrainAndIncrement::SmallIncremental}, "ComputeIncrementalStrain"},
1010  {{Moose::COORD_XYZ, StrainAndIncrement::FiniteIncremental}, "ComputeFiniteStrain"},
1011  {{Moose::COORD_RZ, StrainAndIncrement::SmallTotal}, "ComputeAxisymmetricRZSmallStrain"},
1012  {{Moose::COORD_RZ, StrainAndIncrement::SmallIncremental},
1013  "ComputeAxisymmetricRZIncrementalStrain"},
1014  {{Moose::COORD_RZ, StrainAndIncrement::FiniteIncremental},
1015  "ComputeAxisymmetricRZFiniteStrain"},
1016  {{Moose::COORD_RSPHERICAL, StrainAndIncrement::SmallTotal}, "ComputeRSphericalSmallStrain"},
1017  {{Moose::COORD_RSPHERICAL, StrainAndIncrement::SmallIncremental},
1018  "ComputeRSphericalIncrementalStrain"},
1019  {{Moose::COORD_RSPHERICAL, StrainAndIncrement::FiniteIncremental},
1020  "ComputeRSphericalFiniteStrain"}};
1021 
1022  auto type_it = type_map.find(std::make_pair(_coord_system, _strain_and_increment));
1023  if (type_it != type_map.end())
1024  type = type_it->second;
1025  else
1026  mooseError("Unsupported strain formulation");
1027  }
1028  else if (_planar_formulation == PlanarFormulation::WeakPlaneStress ||
1029  _planar_formulation == PlanarFormulation::PlaneStrain ||
1030  _planar_formulation == PlanarFormulation::GeneralizedPlaneStrain)
1031  {
1032  if (_use_ad && (_planar_formulation == PlanarFormulation::PlaneStrain ||
1033  _planar_formulation == PlanarFormulation::GeneralizedPlaneStrain))
1034  paramError("use_automatic_differentiation",
1035  "AD not setup for use with PlaneStrain or GeneralizedPlaneStrain");
1036 
1037  std::map<std::pair<Moose::CoordinateSystemType, StrainAndIncrement>, std::string> type_map = {
1038  {{Moose::COORD_XYZ, StrainAndIncrement::SmallTotal}, "ComputePlaneSmallStrain"},
1039  {{Moose::COORD_XYZ, StrainAndIncrement::SmallIncremental}, "ComputePlaneIncrementalStrain"},
1040  {{Moose::COORD_XYZ, StrainAndIncrement::FiniteIncremental}, "ComputePlaneFiniteStrain"},
1041  {{Moose::COORD_RZ, StrainAndIncrement::SmallTotal}, "ComputeAxisymmetric1DSmallStrain"},
1042  {{Moose::COORD_RZ, StrainAndIncrement::SmallIncremental},
1043  "ComputeAxisymmetric1DIncrementalStrain"},
1044  {{Moose::COORD_RZ, StrainAndIncrement::FiniteIncremental},
1045  "ComputeAxisymmetric1DFiniteStrain"}};
1046 
1047  // choose kernel type based on coordinate system
1048  auto type_it = type_map.find(std::make_pair(_coord_system, _strain_and_increment));
1049  if (type_it != type_map.end())
1050  type = type_it->second;
1051  else
1052  mooseError("Unsupported coordinate system for plane strain.");
1053  }
1054  else
1055  mooseError("Unsupported planar formulation");
1056 
1057  // set material parameters
1058  auto params = _factory.getValidParams(ad_prepend + type);
1059  params.applyParameters(
1060  parameters(),
1061  {"displacements", "use_displaced_mesh", "out_of_plane_strain", "scalar_out_of_plane_strain"});
1062 
1063  if (isParamValid("strain_base_name"))
1064  params.set<std::string>("base_name") = getParam<std::string>("strain_base_name");
1065 
1066  params.set<std::vector<VariableName>>("displacements") = _coupled_displacements;
1067  params.set<bool>("use_displaced_mesh") = false;
1068 
1069  if (isParamValid("scalar_out_of_plane_strain"))
1070  params.set<std::vector<VariableName>>("scalar_out_of_plane_strain") = {
1071  getParam<VariableName>("scalar_out_of_plane_strain")};
1072 
1073  if (isParamValid("out_of_plane_strain"))
1074  params.set<std::vector<VariableName>>("out_of_plane_strain") = {
1075  getParam<VariableName>("out_of_plane_strain")};
1076 
1077  params.set<std::vector<MaterialPropertyName>>("eigenstrain_names") = _eigenstrain_names;
1078 
1079  _problem->addMaterial(ad_prepend + type, name() + "_strain", params);
1080 }
QuasiStaticSolidMechanicsPhysics::_strain_and_increment
enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement _strain_and_increment
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
Moose::COORD_RSPHERICAL
COORD_RSPHERICAL
Action::name
virtual const std::string & name() const
QuasiStaticSolidMechanicsPhysics::_planar_formulation
enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation _planar_formulation
Action::isParamValid
bool isParamValid(const std::string &name) const
Action::_factory
Factory & _factory
QuasiStaticSolidMechanicsPhysics::_coupled_displacements
std::vector< VariableName > _coupled_displacements
Coupled displacement variables.
Definition: QuasiStaticSolidMechanicsPhysics.h:52
Action::type
const std::string & type() const
Action::paramError
void paramError(const std::string &param, Args... args) const
QuasiStaticSolidMechanicsPhysics::_eigenstrain_names
std::vector< MaterialPropertyName > _eigenstrain_names
Definition: QuasiStaticSolidMechanicsPhysics.h:136
Action::mooseError
void mooseError(Args &&... args) const
Action::_problem
std::shared_ptr< FEProblemBase > & _problem
Action::parameters
const InputParameters & parameters() const

◆ actSubdomainChecks()

void QuasiStaticSolidMechanicsPhysics::actSubdomainChecks ( )
protected

Definition at line 515 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

516 {
517  // Do the coordinate system check only once the problem is created
518  if (_current_task == "setup_mesh_complete")
519  {
520  // get subdomain IDs
521  for (auto & name : _subdomain_names)
522  {
523  auto id = _mesh->getSubdomainID(name);
524  if (id == Moose::INVALID_BLOCK_ID)
525  paramError("block", "Subdomain \"" + name + "\" not found in mesh.");
526  else
527  _subdomain_ids.insert(id);
528  }
529  }
530 
531  if (_current_task == "validate_coordinate_systems")
532  {
533  // use either block restriction list or list of all subdomains in the mesh
534  const auto & check_subdomains =
535  _subdomain_ids.empty() ? _problem->mesh().meshSubdomains() : _subdomain_ids;
536  if (check_subdomains.empty())
537  mooseError("No subdomains found");
538 
539  // make sure all subdomains are using the same coordinate system
540  _coord_system = _problem->getCoordSystem(*check_subdomains.begin());
541  for (auto subdomain : check_subdomains)
542  if (_problem->getCoordSystem(subdomain) != _coord_system)
543  mooseError("The SolidMechanics action requires all subdomains to have the same coordinate "
544  "system.");
545 
546  if (_coord_system == Moose::COORD_RZ)
547  {
548  if (_out_of_plane_direction != OutOfPlaneDirection::z)
549  mooseError("'out_of_plane_direction' must be 'z' for axisymmetric simulations");
550  }
551  else if (_planar_formulation != PlanarFormulation::None)
552  {
553  if (_out_of_plane_direction == OutOfPlaneDirection::z && _ndisp != 2)
554  mooseError(
555  "Must specify two displacements for plane strain when the out of plane direction is z");
556  else if (_out_of_plane_direction != OutOfPlaneDirection::z && _ndisp != 3)
557  mooseError("Must specify three displacements for plane strain when the out of plane "
558  "direction is x or y");
559  }
560  }
561 }
QuasiStaticSolidMechanicsPhysics::_subdomain_ids
std::set< SubdomainID > _subdomain_ids
set generated from the passed in vector of subdomain names
Definition: QuasiStaticSolidMechanicsPhysics.h:66
QuasiStaticSolidMechanicsPhysics::_ndisp
unsigned int _ndisp
Number of displacement variables.
Definition: QuasiStaticSolidMechanicsPhysics.h:49
Action::name
virtual const std::string & name() const
QuasiStaticSolidMechanicsPhysics::_planar_formulation
enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation _planar_formulation
Moose::INVALID_BLOCK_ID
const SubdomainID INVALID_BLOCK_ID
QuasiStaticSolidMechanicsPhysics::_subdomain_names
std::vector< SubdomainName > _subdomain_names
if this vector is not empty the variables, kernels and materials are restricted to these subdomains ...
Definition: QuasiStaticSolidMechanicsPhysics.h:63
Action::_current_task
const std::string & _current_task
Action::paramError
void paramError(const std::string &param, Args... args) const
Action::_mesh
std::shared_ptr< MooseMesh > & _mesh
Action::mooseError
void mooseError(Args &&... args) const
Action::_problem
std::shared_ptr< FEProblemBase > & _problem

◆ addCartesianComponentOutput()

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

Definition at line 334 of file QuasiStaticSolidMechanicsPhysicsBase.C.

336 {
337  if (prop_name.empty())
338  // the enum name is the actual tensor material property name
339  _rank_two_cartesian_component_table.emplace(enum_name, enum_name);
340  else
341  // supply a different name for the enum options (this is done for
342  // 'strain' -> 'mechanical_strain' in the TMA)
343  _rank_two_cartesian_component_table.emplace(enum_name, prop_name);
344 }
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cartesian_component_table
static std::map< std::string, std::string > _rank_two_cartesian_component_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:42

◆ getKernelParameters()

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

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1142 of file QuasiStaticSolidMechanicsPhysics.C.

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

1143 {
1144  InputParameters params = _factory.getValidParams(type);
1145  params.applyParameters(
1146  parameters(),
1147  {"displacements", "use_displaced_mesh", "save_in", "diag_save_in", "out_of_plane_strain"});
1148 
1149  params.set<std::vector<VariableName>>("displacements") = _coupled_displacements;
1150 
1151  if (_lagrangian_kernels)
1152  {
1153  params.set<bool>("use_displaced_mesh") =
1154  (_lk_large_kinematics && (_lk_formulation == LKFormulation::Updated));
1155  params.set<bool>("large_kinematics") = _lk_large_kinematics;
1156  params.set<bool>("stabilize_strain") = _lk_locking;
1157  }
1158  else
1159  params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
1160 
1161  return params;
1162 }
QuasiStaticSolidMechanicsPhysics::_lk_large_kinematics
const bool _lk_large_kinematics
Simplified flag for small/large deformations, Lagrangian kernel system.
Definition: QuasiStaticSolidMechanicsPhysics.h:142
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
InputParameters::applyParameters
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
Action::_factory
Factory & _factory
QuasiStaticSolidMechanicsPhysics::_use_displaced_mesh
bool _use_displaced_mesh
use displaced mesh (true unless _strain is SMALL)
Definition: QuasiStaticSolidMechanicsPhysics.h:109
QuasiStaticSolidMechanicsPhysics::_coupled_displacements
std::vector< VariableName > _coupled_displacements
Coupled displacement variables.
Definition: QuasiStaticSolidMechanicsPhysics.h:52
Action::type
const std::string & type() const
QuasiStaticSolidMechanicsPhysics::_lk_locking
bool _lk_locking
Simplified volumetric locking correction flag for new kernels.
Definition: QuasiStaticSolidMechanicsPhysics.h:153
QuasiStaticSolidMechanicsPhysics::_lagrangian_kernels
const bool _lagrangian_kernels
New or old kernel system.
Definition: QuasiStaticSolidMechanicsPhysics.h:139
Action::parameters
const InputParameters & parameters() const

◆ getKernelType()

std::string QuasiStaticSolidMechanicsPhysics::getKernelType ( )
protectedvirtual

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1083 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by act().

1084 {
1085  if (_lagrangian_kernels)
1086  {
1087  std::string type;
1088  if (_coord_system == Moose::COORD_XYZ)
1089  {
1090  if (_lk_homogenization)
1091  type = "HomogenizedTotalLagrangianStressDivergence";
1092  else if (_lk_formulation == LKFormulation::Total)
1093  type = "TotalLagrangianStressDivergence";
1094  else if (_lk_formulation == LKFormulation::Updated)
1095  type = "UpdatedLagrangianStressDivergence";
1096  else
1097  mooseError("Unknown formulation type");
1098  }
1099  else if (_coord_system == Moose::COORD_RZ)
1100  {
1101  if (_lk_homogenization)
1102  mooseError("The Lagrangian mechanics kernels do not yet support homogenization in "
1103  "coordinate systems other than Cartesian.");
1104  else if (_lk_formulation == LKFormulation::Total)
1105  type = "TotalLagrangianStressDivergenceAxisymmetricCylindrical";
1106  else if (_lk_formulation == LKFormulation::Updated)
1107  mooseError("The Lagrangian mechanics kernels do not yet support the updated Lagrangian "
1108  "formulation in RZ coordinates.");
1109  }
1110  else if (_coord_system == Moose::COORD_RSPHERICAL)
1111  {
1112  if (_lk_homogenization)
1113  mooseError("The Lagrangian mechanics kernels do not yet support homogenization in "
1114  "coordinate systems other than Cartesian.");
1115  else if (_lk_formulation == LKFormulation::Total)
1116  type = "TotalLagrangianStressDivergenceCentrosymmetricSpherical";
1117  else if (_lk_formulation == LKFormulation::Updated)
1118  mooseError("The Lagrangian mechanics kernels do not yet support the updated Lagrangian "
1119  "formulation in RZ coordinates.");
1120  }
1121  else
1122  mooseError("Unsupported coordinate system");
1123  return type;
1124  }
1125  else
1126  {
1127  std::map<Moose::CoordinateSystemType, std::string> type_map = {
1128  {Moose::COORD_XYZ, "StressDivergenceTensors"},
1129  {Moose::COORD_RZ, "StressDivergenceRZTensors"},
1130  {Moose::COORD_RSPHERICAL, "StressDivergenceRSphericalTensors"}};
1131 
1132  // choose kernel type based on coordinate system
1133  auto type_it = type_map.find(_coord_system);
1134  if (type_it != type_map.end())
1135  return type_it->second;
1136  else
1137  mooseError("Unsupported coordinate system");
1138  }
1139 }
Moose::COORD_RSPHERICAL
COORD_RSPHERICAL
Action::type
const std::string & type() const
QuasiStaticSolidMechanicsPhysics::_lagrangian_kernels
const bool _lagrangian_kernels
New or old kernel system.
Definition: QuasiStaticSolidMechanicsPhysics.h:139
Action::mooseError
void mooseError(Args &&... args) const
QuasiStaticSolidMechanicsPhysics::_lk_homogenization
bool _lk_homogenization
Flag indicating if the homogenization system is present for new kernels.
Definition: QuasiStaticSolidMechanicsPhysics.h:156

◆ materialOutputFamilies()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies ( )
staticinherited

Definition at line 299 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

300 {
301  return MultiMooseEnum("MONOMIAL LAGRANGE");
302 }

◆ materialOutputOrders()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders ( )
staticinherited

Definition at line 291 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

292 {
293  auto orders = AddAuxVariableAction::getAuxVariableOrders().getRawNames();
294 
295  return MultiMooseEnum(orders);
296 }
MooseEnum::getRawNames
std::string getRawNames() const
AddAuxVariableAction::getAuxVariableOrders
static MooseEnum getAuxVariableOrders()

◆ outputPropertiesType()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType ( )
staticinherited

Definition at line 305 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

306 {
307  std::string options = "";
308  for (auto & r2tc : _rank_two_cartesian_component_table)
309  for (unsigned int a = 0; a < 3; ++a)
310  for (unsigned int b = 0; b < 3; ++b)
311  options += (options == "" ? "" : " ") + r2tc.first + '_' + _component_table[a] +
312  _component_table[b];
313 
314  for (auto & r2i : _rank_two_invariant_table)
315  for (auto & t : r2i.second.second)
316  options += " " + r2i.first + "_" + t;
317 
318  for (auto & r2sdc : _rank_two_directional_component_table)
319  for (auto & r : r2sdc.second.second)
320  options += " " + r2sdc.first + "_" + r;
321 
322  for (auto & r2cc : _rank_two_cylindrical_component_table)
323  for (auto & r : r2cc.second.second)
324  options += " " + r2cc.first + "_" + r;
325 
326  for (auto & r2sc : _rank_two_spherical_component_table)
327  for (auto & r : r2sc.second.second)
328  options += " " + r2sc.first + "_" + r;
329 
330  return MultiMooseEnum(options, "", true);
331 }
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_invariant_table
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_invariant_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:29
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cylindrical_component_table
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_cylindrical_component_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:33
QuasiStaticSolidMechanicsPhysicsBase::_component_table
static const std::vector< char > _component_table
table data for output generation
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:27
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_directional_component_table
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_directional_component_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:31
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cartesian_component_table
static std::map< std::string, std::string > _rank_two_cartesian_component_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:42
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_spherical_component_table
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_spherical_component_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:35

◆ setupOutput()

template<typename T , typename T2 >
bool QuasiStaticSolidMechanicsPhysics::setupOutput ( std::string  out,
T  table,
T2  setup 
)
protected

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

Definition at line 173 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actOutputMatProp().

174 {
175  for (const auto & t1 : table)
176  {
177  // find the officially supported properties
178  for (const auto & t2 : t1.second.second)
179  if (t1.first + '_' + t2 == out)
180  {
181  const auto it = _rank_two_cartesian_component_table.find(t2);
182  if (it != _rank_two_cartesian_component_table.end())
183  {
184  setup(it->second, t1.second.first);
185  return true;
186  }
187  else
188  mooseError("Internal error. The permitted tensor shortcuts must be keys in the "
189  "'_rank_two_cartesian_component_table'.");
190  }
191 
192  // check for custom properties
193  auto prefix = t1.first + '_';
194  if (out.substr(0, prefix.length()) == prefix)
195  {
196  setup(out.substr(prefix.length()), t1.second.first);
197  return true;
198  }
199  }
200 
201  return false;
202 }
QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cartesian_component_table
static std::map< std::string, std::string > _rank_two_cartesian_component_table
Definition: QuasiStaticSolidMechanicsPhysicsBase.h:42
out
OStreamProxy out
setup
void setup(EquationSystems &systems, Mesh &mesh, GetPot &args)
Action::mooseError
void mooseError(Args &&... args) const

◆ validParams()

InputParameters QuasiStaticSolidMechanicsPhysics::validParams ( )
static

Definition at line 54 of file QuasiStaticSolidMechanicsPhysics.C.

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

55 {
56  InputParameters params = QuasiStaticSolidMechanicsPhysicsBase::validParams();
57  params.addClassDescription("Set up stress divergence kernels with coordinate system aware logic");
58 
59  // parameters specified here only appear in the input file sub-blocks of the solid mechanics
60  // action, not in the common parameters area
61  params.addParam<std::vector<SubdomainName>>("block",
62  {},
63  "The list of ids of the blocks (subdomain) "
64  "that the stress divergence kernels will be "
65  "applied to");
66  params.addParamNamesToGroup("block", "Advanced");
67 
68  params.addParam<MultiMooseEnum>("additional_generate_output",
69  QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType(),
70  "Add scalar quantity output for stress and/or strain (will be "
71  "appended to the list in `generate_output`)");
72  params.addParam<MultiMooseEnum>(
73  "additional_material_output_order",
74  QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders(),
75  "Specifies the order of the FE shape function to use for this variable.");
76 
77  params.addParam<MultiMooseEnum>(
78  "additional_material_output_family",
79  QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies(),
80  "Specifies the family of FE shape functions to use for this variable.");
81 
82  params.addParamNamesToGroup("additional_generate_output additional_material_output_order "
83  "additional_material_output_family",
84  "Output");
85  params.addParam<std::string>(
86  "strain_base_name",
87  "The base name used for the strain. If not provided, it will be set equal to base_name");
88  params.addParam<std::vector<TagName>>(
89  "extra_vector_tags",
90  "The tag names for extra vectors that residual data should be saved into");
91  params.addParam<std::vector<TagName>>("absolute_value_vector_tags",
92  "The tag names for extra vectors that the absolute value "
93  "of the residual should be accumulated into");
94  params.addParam<Real>("scaling", "The scaling to apply to the displacement variables");
95  params.addParam<Point>(
96  "cylindrical_axis_point1",
97  "Starting point for direction of axis of rotation for cylindrical stress/strain.");
98  params.addParam<Point>(
99  "cylindrical_axis_point2",
100  "Ending point for direction of axis of rotation for cylindrical stress/strain.");
101  params.addParam<Point>("spherical_center_point",
102  "Center point of the spherical coordinate system.");
103  params.addParam<Point>("direction", "Direction stress/strain is calculated in");
104  params.addParam<bool>("automatic_eigenstrain_names",
105  false,
106  "Collects all material eigenstrains and passes to required strain "
107  "calculator within TMA internally.");
108 
109  // Homogenization system input
110  MultiMooseEnum constraintType("strain stress");
111  params.addParam<MultiMooseEnum>("constraint_types",
112  Homogenization::constraintType,
113  "Type of each constraint: "
114  "stress or strain.");
115  params.addParam<std::vector<FunctionName>>("targets",
116  {},
117  "Functions giving the target "
118  "values of each constraint.");
119 
120  params.addParamNamesToGroup("scaling", "Variables");
121  params.addParamNamesToGroup("strain_base_name automatic_eigenstrain_names", "Strain");
122  params.addParamNamesToGroup(
123  "cylindrical_axis_point1 cylindrical_axis_point2 spherical_center_point direction",
124  "Coordinate system");
125 
126  return params;
127 }
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)
Homogenization::constraintType
const MultiMooseEnum constraintType("strain stress none")
Moose constraint type, for input.
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)

◆ verifyOrderAndFamilyOutputs()

void QuasiStaticSolidMechanicsPhysics::verifyOrderAndFamilyOutputs ( )
protected

Definition at line 762 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics().

763 {
764  // Ensure material output order and family vectors are same size as generate output
765 
766  // check number of supplied orders and families
767  if (_material_output_order.size() > 1 && _material_output_order.size() < _generate_output.size())
768  paramError("material_output_order",
769  "The number of orders assigned to material outputs must be: 0 to be assigned "
770  "CONSTANT; 1 to assign all outputs the same value, or the same size as the number "
771  "of generate outputs listed.");
772 
773  if (_material_output_family.size() > 1 &&
774  _material_output_family.size() < _generate_output.size())
775  paramError("material_output_family",
776  "The number of families assigned to material outputs must be: 0 to be assigned "
777  "MONOMIAL; 1 to assign all outputs the same value, or the same size as the number "
778  "of generate outputs listed.");
779 
780  // if no value was provided, chose the default CONSTANT
781  if (_material_output_order.size() == 0)
782  _material_output_order.setAdditionalValue("CONSTANT");
783 
784  // For only one order, make all orders the same magnitude
785  if (_material_output_order.size() == 1)
786  _material_output_order =
787  std::vector<std::string>(_generate_output.size(), _material_output_order[0]);
788 
789  if (_verbose)
790  Moose::out << COLOR_CYAN << "*** Automatic applied material output orders ***"
791  << "\n"
792  << _name << ": " << Moose::stringify(_material_output_order) << "\n"
793  << COLOR_DEFAULT << std::flush;
794 
795  // if no value was provided, chose the default MONOMIAL
796  if (_material_output_family.size() == 0)
797  _material_output_family.setAdditionalValue("MONOMIAL");
798 
799  // For only one family, make all families that value
800  if (_material_output_family.size() == 1)
801  _material_output_family =
802  std::vector<std::string>(_generate_output.size(), _material_output_family[0]);
803 
804  if (_verbose)
805  Moose::out << COLOR_CYAN << "*** Automatic applied material output families ***"
806  << "\n"
807  << _name << ": " << Moose::stringify(_material_output_family) << "\n"
808  << COLOR_DEFAULT << std::flush;
809 }
MultiMooseEnum::setAdditionalValue
void setAdditionalValue(const std::string &names)
MultiMooseEnum::size
unsigned int size() const
QuasiStaticSolidMechanicsPhysics::_generate_output
std::vector< std::string > _generate_output
output materials to generate scalar stress/strain tensor quantities
Definition: QuasiStaticSolidMechanicsPhysics.h:112
Action::paramError
void paramError(const std::string &param, Args... args) const
Moose::stringify
std::string stringify(const T &t)
Action::_name
const std::string _name

Member Data Documentation

◆ _auto_eigenstrain

const bool QuasiStaticSolidMechanicsPhysics::_auto_eigenstrain
protected

automatically gather names of eigenstrain tensors provided by simulation objects

Definition at line 134 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act().

◆ _base_name

const std::string QuasiStaticSolidMechanicsPhysics::_base_name
protected

base name for the current master action block

Definition at line 106 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actOutputGeneration(), and actOutputMatProp().

◆ _component_table

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

table data for output generation

Definition at line 27 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _constraint_types

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_constraint_types
protected

Definition at line 167 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act().

◆ _coord_system

Moose::CoordinateSystemType QuasiStaticSolidMechanicsPhysics::_coord_system
protected

Definition at line 60 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _coupled_displacements

std::vector<VariableName> QuasiStaticSolidMechanicsPhysics::_coupled_displacements
protected

Coupled displacement variables.

Definition at line 52 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _cylindrical_axis_point1

Point QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1
protected

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

Definition at line 123 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point1_valid

bool QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1_valid
protected

booleans used to determine if cylindrical axis points are passed

Definition at line 117 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point2

Point QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point2
protected

Definition at line 124 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point2_valid

bool QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point2_valid
protected

Definition at line 118 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _diag_save_in

std::vector<AuxVariableName> QuasiStaticSolidMechanicsPhysics::_diag_save_in
protected

Definition at line 57 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), and QuasiStaticSolidMechanicsPhysics().

◆ _direction

Point QuasiStaticSolidMechanicsPhysics::_direction
protected

Definition at line 125 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _direction_valid

bool QuasiStaticSolidMechanicsPhysics::_direction_valid
protected

Definition at line 119 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _displacements

std::vector<VariableName> QuasiStaticSolidMechanicsPhysics::_displacements
protected

displacement variables

Definition at line 46 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _eigenstrain_names

std::vector<MaterialPropertyName> QuasiStaticSolidMechanicsPhysics::_eigenstrain_names
protected

Definition at line 136 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _generate_output

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

output materials to generate scalar stress/strain tensor quantities

Definition at line 112 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _hname

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

Definition at line 161 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), and actLagrangianKernelStrain().

◆ _homogenization_strain_name

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

Definition at line 165 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actLagrangianKernelStrain().

◆ _integrator_name

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

Definition at line 163 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), and actLagrangianKernelStrain().

◆ _lagrangian_kernels

const bool QuasiStaticSolidMechanicsPhysics::_lagrangian_kernels
protected

New or old kernel system.

Definition at line 139 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_formulation

const LKFormulation QuasiStaticSolidMechanicsPhysics::_lk_formulation
protected

Definition at line 150 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_homogenization

bool QuasiStaticSolidMechanicsPhysics::_lk_homogenization
protected

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

Definition at line 156 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_large_kinematics

const bool QuasiStaticSolidMechanicsPhysics::_lk_large_kinematics
protected

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

Definition at line 142 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_locking

bool QuasiStaticSolidMechanicsPhysics::_lk_locking
protected

Simplified volumetric locking correction flag for new kernels.

Definition at line 153 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actLagrangianKernelStrain(), and getKernelParameters().

◆ _material_output_family

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_material_output_family
protected

Definition at line 114 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actOutputGeneration(), and verifyOrderAndFamilyOutputs().

◆ _material_output_order

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_material_output_order
protected

Definition at line 113 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actOutputGeneration(), and verifyOrderAndFamilyOutputs().

◆ _ndisp

unsigned int QuasiStaticSolidMechanicsPhysics::_ndisp
protected

Number of displacement variables.

Definition at line 49 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _order_mapper

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

Definition at line 159 of file QuasiStaticSolidMechanicsPhysics.h.

◆ _out_of_plane_direction

const OutOfPlaneDirection QuasiStaticSolidMechanicsPhysics::_out_of_plane_direction
protected

Definition at line 103 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), and actSubdomainChecks().

◆ _planar_formulation

enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation QuasiStaticSolidMechanicsPhysics::_planar_formulation
protected

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

◆ _rank_two_cartesian_component_table

std::map< std::string, std::string > QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cartesian_component_table
staticprotectedinherited
Initial value:
= {
{"strain", "total_strain"},
{"mechanical_strain", "mechanical_strain"},
{"stress", "stress"},
{"cauchy_stress", "cauchy_stress"},
{"deformation_gradient", "deformation_gradient"},
{"pk1_stress", "pk1_stress"},
{"pk2_stress", "pk2_stress"},
{"small_stress", "small_stress"},
{"elastic_strain", "elastic_strain"},
{"plastic_strain", "plastic_strain"},
{"creep_strain", "creep_strain"},
{"creep_stress", "creep_stress"}}

Definition at line 42 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _rank_two_cylindrical_component_table

const std::map< std::string, std::pair< std::string, std::vector< std::string > > > QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cylindrical_component_table
staticinherited
Initial value:
= {
{"axial",
{"AxialStress", {"stress", "strain", "plastic_strain", "creep_strain", "elastic_strain"}}},
{"hoop",
{"HoopStress", {"stress", "strain", "plastic_strain", "creep_strain", "elastic_strain"}}},
{"radial", {"RadialStress", {"stress", "strain"}}}}

Definition at line 33 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _rank_two_directional_component_table

const std::map< std::string, std::pair< std::string, std::vector< std::string > > > QuasiStaticSolidMechanicsPhysicsBase::_rank_two_directional_component_table
staticinherited
Initial value:
= {
{"directional", {"Direction", {"stress", "strain"}}}}

Definition at line 31 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _rank_two_invariant_table

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

Definition at line 29 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _rank_two_spherical_component_table

const std::map< std::string, std::pair< std::string, std::vector< std::string > > > QuasiStaticSolidMechanicsPhysicsBase::_rank_two_spherical_component_table
staticinherited
Initial value:
= {
{"spherical_hoop",
{"HoopStress", {"stress", "strain", "plastic_strain", "creep_strain", "elastic_strain"}}},
{"spherical_radial", {"RadialStress", {"stress", "strain"}}}}

Definition at line 35 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _save_in

std::vector<AuxVariableName> QuasiStaticSolidMechanicsPhysics::_save_in
protected

residual debugging

Definition at line 56 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), and QuasiStaticSolidMechanicsPhysics().

◆ _spherical_center_point

Point QuasiStaticSolidMechanicsPhysics::_spherical_center_point
protected

center point for spherical stress/strain quantities

Definition at line 131 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _spherical_center_point_valid

bool QuasiStaticSolidMechanicsPhysics::_spherical_center_point_valid
protected

booleans used to determine if spherical center point is passed

Definition at line 128 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _strain

enum QuasiStaticSolidMechanicsPhysics::Strain QuasiStaticSolidMechanicsPhysics::_strain
protected

Referenced by QuasiStaticSolidMechanicsPhysics().

◆ _strain_and_increment

enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement QuasiStaticSolidMechanicsPhysics::_strain_and_increment
protected

Referenced by actStressDivergenceTensorsStrain(), and QuasiStaticSolidMechanicsPhysics().

◆ _subdomain_id_union

std::set<SubdomainID> QuasiStaticSolidMechanicsPhysics::_subdomain_id_union
protected

set generated from the combined block restrictions of all SolidMechanics/Master action blocks

Definition at line 69 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actGatherActionParameters().

◆ _subdomain_ids

std::set<SubdomainID> QuasiStaticSolidMechanicsPhysics::_subdomain_ids
protected

set generated from the passed in vector of subdomain names

Definition at line 66 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by actEigenstrainNames(), and actSubdomainChecks().

◆ _subdomain_names

std::vector<SubdomainName> QuasiStaticSolidMechanicsPhysics::_subdomain_names
protected

if this vector is not empty the variables, kernels and materials are restricted to these subdomains

Definition at line 63 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act(), actLagrangianKernelStrain(), and actSubdomainChecks().

◆ _targets

std::vector<FunctionName> QuasiStaticSolidMechanicsPhysics::_targets
protected

Definition at line 168 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by act().

◆ _use_ad

const bool QuasiStaticSolidMechanicsPhysicsBase::_use_ad
protectedinherited

Definition at line 44 of file QuasiStaticSolidMechanicsPhysicsBase.h.

Referenced by DynamicSolidMechanicsPhysics::act(), act(), actEigenstrainNames(), actOutputGeneration(), actOutputMatProp(), actStressDivergenceTensorsStrain(), PoroMechanicsAction::PoroMechanicsAction(), and QuasiStaticSolidMechanicsPhysics().

◆ _use_displaced_mesh

bool QuasiStaticSolidMechanicsPhysics::_use_displaced_mesh
protected

use displaced mesh (true unless _strain is SMALL)

Definition at line 109 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _verbose

bool QuasiStaticSolidMechanicsPhysics::_verbose
protected

Definition at line 120 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by verifyOrderAndFamilyOutputs().

The documentation for this class was generated from the following files:
Generated on Fri Jul 18 2025 13:50:30 for https://mooseframework.inl.gov by   doxygen 1.8.14