24 #include "libmesh/string_to_enum.h" 33 "validate_coordinate_systems");
47 "add_master_action_material");
57 params.
addClassDescription(
"Set up stress divergence kernels with coordinate system aware logic");
61 params.
addParam<std::vector<SubdomainName>>(
"block",
63 "The list of ids of the blocks (subdomain) " 64 "that the stress divergence kernels will be " 70 "Add scalar quantity output for stress and/or strain (will be " 71 "appended to the list in `generate_output`)");
73 "additional_material_output_order",
75 "Specifies the order of the FE shape function to use for this variable.");
78 "additional_material_output_family",
80 "Specifies the family of FE shape functions to use for this variable.");
83 "additional_material_output_family",
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>>(
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");
96 "cylindrical_axis_point1",
97 "Starting point for direction of axis of rotation for cylindrical stress/strain.");
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",
106 "Collects all material eigenstrains and passes to required strain " 107 "calculator within TMA internally.");
113 "Type of each constraint: strain, stress, or none. The types are specified in the " 114 "column-major order, and there must be 9 entries in total.");
115 params.
addParam<std::vector<FunctionName>>(
116 "targets", {},
"Functions giving the targets to hit for constraint types that are not none.");
121 "cylindrical_axis_point1 cylindrical_axis_point2 spherical_center_point direction",
122 "Coordinate system");
129 _displacements(getParam<
std::vector<VariableName>>(
"displacements")),
130 _ndisp(_displacements.size()),
131 _coupled_displacements(_ndisp),
132 _save_in(getParam<
std::vector<AuxVariableName>>(
"save_in")),
133 _diag_save_in(getParam<
std::vector<AuxVariableName>>(
"diag_save_in")),
134 _subdomain_names(getParam<
std::vector<SubdomainName>>(
"block")),
138 _out_of_plane_direction(
140 _base_name(isParamValid(
"base_name") ? getParam<
std::string>(
"base_name") +
"_" :
""),
141 _material_output_order(getParam<
MultiMooseEnum>(
"material_output_order")),
142 _material_output_family(getParam<
MultiMooseEnum>(
"material_output_family")),
143 _cylindrical_axis_point1_valid(params.isParamSetByUser(
"cylindrical_axis_point1")),
144 _cylindrical_axis_point2_valid(params.isParamSetByUser(
"cylindrical_axis_point2")),
145 _direction_valid(params.isParamSetByUser(
"direction")),
146 _verbose(getParam<bool>(
"verbose")),
147 _spherical_center_point_valid(params.isParamSetByUser(
"spherical_center_point")),
148 _auto_eigenstrain(getParam<bool>(
"automatic_eigenstrain_names")),
149 _lagrangian_kernels(getParam<bool>(
"new_system")),
150 _lk_large_kinematics(_strain ==
Strain::Finite),
152 _lk_locking(getParam<bool>(
"volumetric_locking_correction")),
153 _lk_homogenization(false),
155 _targets(getParam<
std::vector<FunctionName>>(
"targets"))
160 const bool incremental = getParam<bool>(
"incremental");
177 mooseInfo(
"SolidMechanics Action: selecting 'total small strain' formulation. Use " 178 "`incremental = true` to select 'incremental small strain' instead.");
183 mooseInfo(
"SolidMechanics Action: selecting 'incremental finite strain' formulation.");
193 bool use_displaced_mesh_param = getParam<bool>(
"use_displaced_mesh");
195 mooseError(
"Wrong combination of use displaced mesh and strain model");
200 for (
unsigned int i = 0; i <
_ndisp; ++i)
204 mooseError(
"Number of save_in variables should equal to the number of displacement variables ",
209 "Number of diag_save_in variables should equal to the number of displacement variables ",
219 "Planar formulations are not yet available through the Physics syntax with new_system = " 220 "true. They can be enabled by manually setting up the appropriate objects. Please refer " 221 "to the documentation and regression tests for examples.");
225 "out_of_plane_strain should only be specified with planar_formulation=WEAK_PLANE_STRESS");
228 mooseError(
"out_of_plane_strain must be specified with planar_formulation=WEAK_PLANE_STRESS");
232 for (
const auto &
out : getParam<MultiMooseEnum>(
"generate_output"))
234 std::string lower(
out);
235 std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
243 if (
_ndisp == 1 && getParam<bool>(
"volumetric_locking_correction"))
244 mooseError(
"Volumetric locking correction should be set to false for 1D problems.");
248 "The scaling parameter has no effect unless add_variables is set to true. Did you " 249 "mean to set 'add_variables = true'?");
267 _eigenstrain_names = getParam<std::vector<MaterialPropertyName>>(
"eigenstrain_names");
273 if (ctype_set || targets_set)
275 if (!(ctype_set && targets_set))
276 mooseError(
"To use the Lagrangian kernel homogenization system you " 277 "most provide both the constraint_types and the targets " 282 mooseError(
"The Lagrangian kernel homogenization system requires the " 283 "use of formulation = TOTAL");
291 mooseError(
"The Lagrangian kernel system is not yet compatible with AD. " 292 "Do not set the use_automatic_differentiation flag.");
295 mooseError(
"The Lagrangian kernel system always produces the exact " 296 "Jacobian. use_finite_deform_jacobian is redundant and " 297 " should not be set");
299 mooseError(
"The Lagrangian kernel system is not compatible with " 300 "the global_strain option. Use the homogenization " 303 mooseError(
"The decomposition_method parameter should not be used " 304 " with the Lagrangian kernel system. Similar options " 305 " for native small deformation material models are " 306 " available as part of the ComputeLagrangianStress " 307 " material system.");
312 mooseError(
"The StressDiveregenceTensor system always uses an " 313 " updated Lagrangian formulation. Do not set the " 314 " formulation parameter, it is only used with the " 315 " new Lagrangian kernel system.");
317 mooseError(
"The homogenization system can only be used with the " 318 "new Lagrangian kernels");
325 std::string ad_prepend =
"";
344 paramError(
"use_automatic_differentiation",
"AD not setup for use with PlaneStrain");
346 const std::string
type =
"GeneralizedPlaneStrainAction";
348 action_params.
set<
bool>(
"_built_by_moose") =
true;
349 action_params.set<std::string>(
"registered_identifier") =
"(AutoBuilt)";
356 {
"use_displaced_mesh",
357 "out_of_plane_pressure",
358 "out_of_plane_pressure_function",
364 action_params.set<FunctionName>(
"out_of_plane_pressure") =
365 getParam<FunctionName>(
"out_of_plane_pressure");
367 action_params.set<FunctionName>(
"out_of_plane_pressure_function") =
368 getParam<FunctionName>(
"out_of_plane_pressure_function");
370 action_params.set<
Real>(
"factor") = getParam<Real>(
"factor");
372 action_params.set<
Real>(
"pressure_factor") = getParam<Real>(
"pressure_factor");
387 if (common_actions.empty() && getParam<bool>(
"add_variables"))
391 const bool second =
_problem->mesh().hasSecondOrderElements();
393 params.set<
MooseEnum>(
"order") = second ?
"SECOND" :
"FIRST";
394 params.set<
MooseEnum>(
"family") =
"LAGRANGE";
396 params.set<std::vector<Real>>(
"scaling") = {getParam<Real>(
"scaling")};
405 _problem->addVariable(
"MooseVariable", disp, params);
413 const std::map<bool, std::vector<unsigned int>> mg_order_max{{
true, {1, 4, 9}},
415 std::size_t mg_order = 0;
424 "Number of non-none constraint types must not be greater than ",
454 for (
unsigned int i = 0; i <
_ndisp; ++i)
468 params.set<
unsigned int>(
"component") = i;
470 params.set<NonlinearVariableName>(
"variable") =
_displacements[i];
473 params.set<std::vector<AuxVariableName>>(
"save_in") = {
_save_in[i]};
475 params.set<std::vector<AuxVariableName>>(
"diag_save_in") = {
_diag_save_in[i]};
477 params.set<std::vector<VariableName>>(
"out_of_plane_strain") = {
478 getParam<VariableName>(
"out_of_plane_strain")};
482 params.set<std::vector<VariableName>>(
"scalar_variable") = {
_hname};
484 params.set<std::vector<FunctionName>>(
"targets") =
_targets;
487 _problem->addKernel(ad_prepend + tensor_kernel_type, kernel_name, params);
493 std::string wps_kernel_name =
"TM_WPS_" +
name();
494 params.set<NonlinearVariableName>(
"variable") = getParam<VariableName>(
"out_of_plane_strain");
496 _problem->addKernel(ad_prepend +
"WeakPlaneStress", wps_kernel_name, params);
512 paramError(
"block",
"Subdomain \"" +
name +
"\" not found in mesh.");
521 const auto & check_subdomains =
523 if (check_subdomains.empty())
528 for (
auto subdomain : check_subdomains)
530 mooseError(
"The SolidMechanics action requires all subdomains to have the same coordinate " 536 mooseError(
"'out_of_plane_direction' must be 'z' for axisymmetric simulations");
542 "Must specify two displacements for plane strain when the out of plane direction is z");
544 mooseError(
"Must specify three displacements for plane strain when the out of plane " 545 "direction is x or y");
559 unsigned int index = 0;
565 std::string
type = (order ==
"CONSTANT" && family ==
"MONOMIAL")
566 ?
"MooseVariableConstMonomial" 572 params.set<
MooseEnum>(
"family") = family;
574 if (family ==
"MONOMIAL")
586 std::string ad_prepend =
_use_ad ?
"AD" :
"";
588 unsigned int index = 0;
609 std::string ad_prepend =
_use_ad ?
"AD" :
"";
611 unsigned int index = 0;
635 std::map<std::string, std::set<SubdomainID>> material_eigenstrain_map;
636 std::set<std::string> eigenstrain_set;
638 std::set<MaterialPropertyName> verified_eigenstrain_names;
640 std::map<std::string, std::string> remove_add_map;
641 std::set<std::string> remove_reduced_set;
644 auto materials =
_problem->getMaterialWarehouse().getObjects();
645 for (
auto & mat : materials)
647 std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<
BlockRestrictable>(mat);
649 auto & mat_name = mat->type();
652 if (mat_params.isParamValid(
"eigenstrain_name"))
654 std::shared_ptr<MaterialData> mat_dat;
655 auto name = mat_params.get<std::string>(
"eigenstrain_name");
658 if (mat_params.isParamValid(
"base_name"))
659 name = mat_params.get<std::string>(
"base_name") +
'_' +
name;
663 mooseError(
"Internal error, Material object that does not inherit form BlockRestricted");
664 const std::set<SubdomainID> &
blocks =
665 blk->blockRestricted() ? blk->blockIDs() : blk->meshBlockIDs();
670 eigenstrain_set.insert(
name);
675 if (mat_name ==
"ComputeReducedOrderEigenstrain")
677 auto input_eigenstrain_names =
678 mat_params.get<std::vector<MaterialPropertyName>>(
"input_eigenstrain_names");
679 remove_reduced_set.insert(input_eigenstrain_names.begin(), input_eigenstrain_names.end());
682 if (mat_name ==
"CompositeEigenstrain")
684 auto remove_list = mat_params.get<std::vector<MaterialPropertyName>>(
"tensors");
685 for (
auto i : remove_list)
686 remove_reduced_set.insert(i);
690 if (mat_name ==
"RankTwoTensorMaterialADConverter")
692 std::vector<MaterialPropertyName> remove_list;
693 std::vector<MaterialPropertyName> add_list;
695 if (mat_params.isParamValid(
"ad_props_out") && mat_params.isParamValid(
"reg_props_in") &&
698 remove_list = mat_params.get<std::vector<MaterialPropertyName>>(
"reg_props_in");
699 add_list = mat_params.get<std::vector<MaterialPropertyName>>(
"ad_props_out");
701 if (mat_params.isParamValid(
"ad_props_in") && mat_params.isParamValid(
"reg_props_out") &&
704 remove_list = mat_params.get<std::vector<MaterialPropertyName>>(
"ad_props_in");
705 add_list = mat_params.get<std::vector<MaterialPropertyName>>(
"reg_props_out");
709 for (
unsigned int index = 0; index < remove_list.size(); index++)
710 remove_add_map.emplace(remove_list[index], add_list[index]);
716 for (
auto remove_add_index : remove_add_map)
718 const bool is_in = eigenstrain_set.find(remove_add_index.first) != eigenstrain_set.end();
721 eigenstrain_set.erase(remove_add_index.first);
722 eigenstrain_set.insert(remove_add_index.second);
725 for (
auto index : remove_reduced_set)
726 eigenstrain_set.erase(index);
730 std::set_union(eigenstrain_set.begin(),
731 eigenstrain_set.end(),
734 std::inserter(verified_eigenstrain_names, verified_eigenstrain_names.begin()));
738 std::copy(verified_eigenstrain_names.begin(),
739 verified_eigenstrain_names.end(),
742 Moose::out << COLOR_CYAN <<
"*** Automatic Eigenstrain Names ***" 745 << COLOR_DEFAULT << std::flush;
756 "The number of orders assigned to material outputs must be: 0 to be assigned " 757 "CONSTANT; 1 to assign all outputs the same value, or the same size as the number " 758 "of generate outputs listed.");
763 "The number of families assigned to material outputs must be: 0 to be assigned " 764 "MONOMIAL; 1 to assign all outputs the same value, or the same size as the number " 765 "of generate outputs listed.");
777 Moose::out << COLOR_CYAN <<
"*** Automatic applied material output orders ***" 780 << COLOR_DEFAULT << std::flush;
792 Moose::out << COLOR_CYAN <<
"*** Automatic applied material output families ***" 795 << COLOR_DEFAULT << std::flush;
801 std::string ad_prepend =
_use_ad ?
"AD" :
"";
815 for (
unsigned int a = 0;
a < 3; ++
a)
816 for (
unsigned int b = 0;
b < 3; ++
b)
819 auto type = ad_prepend +
"RankTwoCartesianComponent";
820 params = _factory.getValidParams(type);
821 params.set<MaterialPropertyName>(
"rank_two_tensor") = _base_name + r2q.second;
822 params.set<unsigned int>(
"index_i") = a;
823 params.set<unsigned int>(
"index_j") = b;
825 params.applyParameters(parameters());
826 params.set<MaterialPropertyName>(
"property_name") = _base_name + out;
827 _problem->addMaterial(type, _base_name + out +
'_' + name(), params);
837 [&](std::string prop_name, std::string invariant)
839 auto type = ad_prepend +
"RankTwoDirectionalComponent";
841 params.
set<MaterialPropertyName>(
"rank_two_tensor") =
853 [&](std::string prop_name, std::string invariant)
855 auto type = ad_prepend +
"RankTwoInvariant";
857 params.
set<MaterialPropertyName>(
"rank_two_tensor") =
870 [&](std::string prop_name, std::string
component)
874 "Cannot use cylindrical component output in a spherical coordinate system.");
875 auto type = ad_prepend +
"RankTwoCylindricalComponent";
877 params.
set<MaterialPropertyName>(
"rank_two_tensor") =
_base_name + prop_name;
888 [&](std::string prop_name, std::string
component)
890 auto type = ad_prepend +
"RankTwoSphericalComponent";
892 params.
set<MaterialPropertyName>(
"rank_two_tensor") =
901 paramError(
"generate_output",
"Unable to add output Material for '",
out,
"'");
910 if (
_current_task ==
"validate_coordinate_systems" && getParam<bool>(
"add_variables"))
913 for (
const auto & action : actions)
916 const auto added_size = action->_subdomain_ids.size();
920 if (size_after != size_before + added_size)
921 mooseError(
"The block restrictions in the SolidMechanics/QuasiStatic actions must be " 924 if (added_size == 0 && actions.size() > 1)
926 "No SolidMechanics/QuasiStatic action can be block unrestricted if more than one " 927 "SolidMechanics/QuasiStatic action is specified.");
937 type =
"ComputeLagrangianStrain";
939 type =
"ComputeLagrangianStrainAxisymmetricCylindrical";
941 type =
"ComputeLagrangianStrainCentrosymmetricSpherical";
948 params.
set<std::string>(
"base_name") = getParam<std::string>(
"strain_base_name");
951 params.set<std::vector<MaterialPropertyName>>(
"eigenstrain_names") =
_eigenstrain_names;
957 mooseError(
"Volumetric locking correction should not be used for " 958 "higher-order elements.");
960 params.set<
bool>(
"stabilize_strain") =
_lk_locking;
964 params.set<std::vector<MaterialPropertyName>>(
"homogenization_gradient_names") = {
973 std::string
type =
"ComputeHomogenizedLagrangianStrain";
977 params.set<std::vector<VariableName>>(
"macro_gradient") = {
_hname};
979 params.set<std::vector<FunctionName>>(
"targets") =
_targets;
988 std::string ad_prepend =
_use_ad ?
"AD" :
"";
995 std::map<std::pair<Moose::CoordinateSystemType, StrainAndIncrement>, std::string> type_map = {
1001 "ComputeAxisymmetricRZIncrementalStrain"},
1003 "ComputeAxisymmetricRZFiniteStrain"},
1006 "ComputeRSphericalIncrementalStrain"},
1008 "ComputeRSphericalFiniteStrain"}};
1011 if (type_it != type_map.end())
1012 type = type_it->second;
1014 mooseError(
"Unsupported strain formulation");
1023 "AD not setup for use with PlaneStrain or GeneralizedPlaneStrain");
1025 std::map<std::pair<Moose::CoordinateSystemType, StrainAndIncrement>, std::string> type_map = {
1031 "ComputeAxisymmetric1DIncrementalStrain"},
1033 "ComputeAxisymmetric1DFiniteStrain"}};
1037 if (type_it != type_map.end())
1038 type = type_it->second;
1040 mooseError(
"Unsupported coordinate system for plane strain.");
1043 mooseError(
"Unsupported planar formulation");
1049 {
"displacements",
"use_displaced_mesh",
"out_of_plane_strain",
"scalar_out_of_plane_strain"});
1052 params.set<std::string>(
"base_name") = getParam<std::string>(
"strain_base_name");
1055 params.set<
bool>(
"use_displaced_mesh") =
false;
1058 params.set<std::vector<VariableName>>(
"scalar_out_of_plane_strain") = {
1059 getParam<VariableName>(
"scalar_out_of_plane_strain")};
1062 params.set<std::vector<VariableName>>(
"out_of_plane_strain") = {
1063 getParam<VariableName>(
"out_of_plane_strain")};
1065 params.set<std::vector<MaterialPropertyName>>(
"eigenstrain_names") =
_eigenstrain_names;
1079 type =
"HomogenizedTotalLagrangianStressDivergence";
1081 type =
"TotalLagrangianStressDivergence";
1083 type =
"UpdatedLagrangianStressDivergence";
1090 mooseError(
"The Lagrangian mechanics kernels do not yet support homogenization in " 1091 "coordinate systems other than Cartesian.");
1093 type =
"TotalLagrangianStressDivergenceAxisymmetricCylindrical";
1095 mooseError(
"The Lagrangian mechanics kernels do not yet support the updated Lagrangian " 1096 "formulation in RZ coordinates.");
1101 mooseError(
"The Lagrangian mechanics kernels do not yet support homogenization in " 1102 "coordinate systems other than Cartesian.");
1104 type =
"TotalLagrangianStressDivergenceCentrosymmetricSpherical";
1106 mooseError(
"The Lagrangian mechanics kernels do not yet support the updated Lagrangian " 1107 "formulation in RZ coordinates.");
1115 std::map<Moose::CoordinateSystemType, std::string> type_map = {
1122 if (type_it != type_map.end())
1123 return type_it->second;
1135 {
"displacements",
"use_displaced_mesh",
"save_in",
"diag_save_in",
"out_of_plane_strain"});
1141 params.
set<
bool>(
"use_displaced_mesh") =
const bool _lk_large_kinematics
Simplified flag for small/large deformations, Lagrangian kernel system.
void mooseInfo(Args &&... args) const
MultiMooseEnum _material_output_order
void actGatherActionParameters()
std::set< SubdomainID > _subdomain_id_union
set generated from the combined block restrictions of all SolidMechanics/Master action blocks ...
enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement _strain_and_increment
std::vector< AuxVariableName > _save_in
residual debugging
virtual InputParameters getKernelParameters(std::string type)
const std::string & _name
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 ...
void paramError(const std::string ¶m, Args... args) const
std::vector< AuxVariableName > _diag_save_in
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_invariant_table
std::set< SubdomainID > _subdomain_ids
set generated from the passed in vector of subdomain names
InputParameters getValidParams(const std::string &name)
void setAdditionalValue(const std::string &names)
unsigned int _ndisp
Number of displacement variables.
static const std::string component
void actStressDivergenceTensorsStrain()
const InputParameters & parameters() const
ActionFactory & _action_factory
LKFormulation
New kernel system kinematics types.
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_cylindrical_component_table
InputParameters getValidParams(const std::string &name) const
const bool _auto_eigenstrain
automatically gather names of eigenstrain tensors provided by simulation objects
registerMooseAction("SolidMechanicsApp", QuasiStaticSolidMechanicsPhysics, "meta_action")
unsigned int size() const
void mooseDocumentedError(const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
void addActionBlock(std::shared_ptr< Action > blk)
Store common tensor mechanics parameters.
Moose::CoordinateSystemType _coord_system
const ExecFlagType EXEC_TIMESTEP_END
std::vector< VariableName > _displacements
displacement variables
static MultiMooseEnum materialOutputFamilies()
std::vector< std::string > _generate_output
output materials to generate scalar stress/strain tensor quantities
static const std::vector< char > _component_table
table data for output generation
std::shared_ptr< Action > create(const std::string &action, const std::string &action_name, InputParameters ¶meters)
enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation _planar_formulation
const LKFormulation _lk_formulation
QuasiStaticSolidMechanicsPhysics(const InputParameters ¶ms)
static MultiMooseEnum materialOutputOrders()
const SubdomainID INVALID_BLOCK_ID
void verifyOrderAndFamilyOutputs()
std::vector< SubdomainName > _subdomain_names
if this vector is not empty the variables, kernels and materials are restricted to these subdomains ...
bool _use_displaced_mesh
use displaced mesh (true unless _strain is SMALL)
const std::string & name() const
enum QuasiStaticSolidMechanicsPhysics::Strain _strain
std::vector< VariableName > _coupled_displacements
Coupled displacement variables.
MultiMooseEnum _material_output_family
bool _cylindrical_axis_point1_valid
booleans used to determine if cylindrical axis points are passed
std::vector< FunctionName > _targets
const std::string & type() const
bool _lk_locking
Simplified volumetric locking correction flag for new kernels.
const std::string & _current_task
static std::string variableType(const libMesh::FEType &fe_type, const bool is_fv=false, const bool is_array=false)
std::string stringify(const T &t)
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_directional_component_table
static std::map< std::string, std::string > _rank_two_cartesian_component_table
std::vector< MaterialPropertyName > _eigenstrain_names
const OutOfPlaneDirection _out_of_plane_direction
std::shared_ptr< MooseMesh > & _mesh
static libMesh::FEType feType(const InputParameters ¶ms)
unsigned int get(unsigned int i) const
static InputParameters validParams()
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void actSubdomainChecks()
ConstraintType
Constraint type: stress/PK stress or strain/deformation gradient.
const bool _lagrangian_kernels
New or old kernel system.
void actLagrangianKernelStrain()
static InputParameters validParams()
void mooseError(Args &&... args) const
const std::string _homogenization_strain_name
std::shared_ptr< FEProblemBase > & _problem
Point _spherical_center_point
center point for spherical stress/strain quantities
const MultiMooseEnum constraintType("strain stress none")
Point _cylindrical_axis_point2
bool isParamValid(const std::string &name) const
void actOutputGeneration()
bool _spherical_center_point_valid
booleans used to determine if spherical center point is passed
const std::string _base_name
base name for the current master action block
static MultiMooseEnum outputPropertiesType()
std::vector< const T *> getActions()
bool _cylindrical_axis_point2_valid
auto index_range(const T &sizable)
MultiMooseEnum _constraint_types
PlanarFormulation
use an out of plane stress/strain formulation
void actEigenstrainNames()
virtual std::string getKernelType()
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_spherical_component_table
Point _cylindrical_axis_point1
points used to determine axis of rotation for cylindrical stress/strain quantities ...
bool _lk_homogenization
Flag indicating if the homogenization system is present for new kernels.