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
PoroMechanicsAction Class Reference

#include <PoroMechanicsAction.h>

Inheritance diagram for PoroMechanicsAction:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 PoroMechanicsAction (const InputParameters &params)
 
virtual void act ()
 
void timedAct ()
 
virtual void addRelationshipManagers (Moose::RelationshipManagerType when_type)
 
MooseObjectName uniqueActionName () const
 
const std::string & specificTaskName () const
 
const std::set< std::string > & getAllTasks () const
 
void appendTask (const std::string &task)
 
MooseAppgetMooseApp () 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 InputParametersparameters () 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
 
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
 
PerfGraphperfGraph ()
 
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 14 of file PoroMechanicsAction.h.

Member Enumeration Documentation

◆ LKFormulation

enum QuasiStaticSolidMechanicsPhysics::LKFormulation
strongprotectedinherited

New kernel system kinematics types.

Enumerator
Total 
Updated 

Definition at line 145 of file QuasiStaticSolidMechanicsPhysics.h.

146  {
147  Total,
148  Updated
149  };

◆ OutOfPlaneDirection

Enumerator

Definition at line 96 of file QuasiStaticSolidMechanicsPhysics.h.

97  {
98  x,
99  y,
100  z
101  };
const std::vector< double > y
const std::vector< double > x

◆ PlanarFormulation

use an out of plane stress/strain formulation

Enumerator
None 
WeakPlaneStress 
PlaneStrain 
GeneralizedPlaneStrain 

Definition at line 88 of file QuasiStaticSolidMechanicsPhysics.h.

89  {
90  None,
92  PlaneStrain,
enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation _planar_formulation

◆ Strain

enum QuasiStaticSolidMechanicsPhysics::Strain
strongprotectedinherited

strain formulation

Enumerator
Small 
Finite 

Definition at line 72 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ StrainAndIncrement

strain formulation

Enumerator
SmallTotal 
FiniteTotal 
SmallIncremental 
FiniteIncremental 

Definition at line 79 of file QuasiStaticSolidMechanicsPhysics.h.

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

Constructor & Destructor Documentation

◆ PoroMechanicsAction()

PoroMechanicsAction::PoroMechanicsAction ( const InputParameters params)

Definition at line 32 of file PoroMechanicsAction.C.

34 {
35  if (_use_ad)
36  paramError("use_ad", "AD not setup for use with PoroMechanicsAction");
37 }
QuasiStaticSolidMechanicsPhysics(const InputParameters &params)
void paramError(const std::string &param, Args... args) const

Member Function Documentation

◆ act()

void PoroMechanicsAction::act ( )
virtual

Reimplemented from QuasiStaticSolidMechanicsPhysics.

Definition at line 40 of file PoroMechanicsAction.C.

41 {
43 
44  if (_current_task == "add_kernel")
45  {
46  // Prepare displacements and set value for dim
47  std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
48  unsigned int dim = displacements.size();
49 
50  // all the kernels added below have pore pressure as a coupled variable
51  // add this to the kernel's params
52  std::string type("PoroMechanicsCoupling");
54  VariableName pp_var(getParam<VariableName>("porepressure"));
55  params.addCoupledVar("porepressure", "");
56  params.set<std::vector<VariableName>>("porepressure") = {pp_var};
57 
58  // now add the kernels
59  for (unsigned int i = 0; i < dim; ++i)
60  {
61  std::string kernel_name = "PoroMechanics" + Moose::stringify(i);
62 
63  params.set<unsigned int>("component") = i;
64  params.set<NonlinearVariableName>("variable") = displacements[i];
65 
66  _problem->addKernel(type, kernel_name, params);
67  }
68  }
69 }
unsigned int dim
T & set(const std::string &name, bool quiet_mode=false)
InputParameters getValidParams(const std::string &name) const
Factory & _factory
const std::string & type() const
const std::string & _current_task
std::string stringify(const T &t)
void addCoupledVar(const std::string &name, const std::string &doc_string)
std::shared_ptr< FEProblemBase > & _problem

◆ actEigenstrainNames()

void QuasiStaticSolidMechanicsPhysics::actEigenstrainNames ( )
protectedinherited

Definition at line 645 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 }
char ** blocks
std::set< SubdomainID > _subdomain_ids
set generated from the passed in vector of subdomain names
virtual const std::string & name() const
std::string stringify(const T &t)
const std::string _name
std::vector< MaterialPropertyName > _eigenstrain_names
void mooseError(Args &&... args) const
std::shared_ptr< FEProblemBase > & _problem

◆ actGatherActionParameters()

void QuasiStaticSolidMechanicsPhysics::actGatherActionParameters ( )
protectedinherited

Definition at line 920 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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  {
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 }
std::set< SubdomainID > _subdomain_id_union
set generated from the combined block restrictions of all SolidMechanics/Master action blocks ...
ActionWarehouse & _awh
const std::string & _current_task
void mooseError(Args &&... args) const
std::vector< const T *> getActions()

◆ actLagrangianKernelStrain()

void QuasiStaticSolidMechanicsPhysics::actLagrangianKernelStrain ( )
protectedinherited

Definition at line 946 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

947 {
948  std::string type;
950  type = "ComputeLagrangianStrain";
951  else if (_coord_system == Moose::COORD_RZ)
952  type = "ComputeLagrangianStrainAxisymmetricCylindrical";
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") = {
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 }
const bool _lk_large_kinematics
Simplified flag for small/large deformations, Lagrangian kernel system.
T & set(const std::string &name, bool quiet_mode=false)
InputParameters getValidParams(const std::string &name) const
COORD_RSPHERICAL
virtual const std::string & name() const
bool isParamValid(const std::string &name) const
Factory & _factory
std::vector< SubdomainName > _subdomain_names
if this vector is not empty the variables, kernels and materials are restricted to these subdomains ...
std::vector< VariableName > _coupled_displacements
Coupled displacement variables.
const std::string & type() const
bool _lk_locking
Simplified volumetric locking correction flag for new kernels.
std::vector< MaterialPropertyName > _eigenstrain_names
void mooseError(Args &&... args) const
std::shared_ptr< FEProblemBase > & _problem
bool _lk_homogenization
Flag indicating if the homogenization system is present for new kernels.

◆ actOutputGeneration()

void QuasiStaticSolidMechanicsPhysics::actOutputGeneration ( )
protectedinherited

Definition at line 564 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

565 {
566  if (_current_task == "add_material")
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  {
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  {
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 }
T & set(const std::string &name, bool quiet_mode=false)
InputParameters getValidParams(const std::string &name) const
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
std::vector< std::string > _generate_output
output materials to generate scalar stress/strain tensor quantities
virtual const std::string & name() const
InputParameters emptyInputParameters()
Factory & _factory
const std::string & type() const
const std::string & _current_task
std::shared_ptr< FEProblemBase > & _problem
const InputParameters & parameters() const
const std::string _base_name
base name for the current master action block

◆ actOutputMatProp()

void QuasiStaticSolidMechanicsPhysics::actOutputMatProp ( )
protectedinherited

Definition at line 812 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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  {
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,
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,
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,
883  [&](std::string prop_name, std::string component)
884  {
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,
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 }
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 ...
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_invariant_table
static const std::string component
Definition: NS.h:153
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_cylindrical_component_table
T & set(const std::string &name, bool quiet_mode=false)
InputParameters getValidParams(const std::string &name) const
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
COORD_RSPHERICAL
std::vector< std::string > _generate_output
output materials to generate scalar stress/strain tensor quantities
virtual const std::string & name() const
static const std::vector< char > _component_table
table data for output generation
InputParameters emptyInputParameters()
Factory & _factory
const std::string & type() const
const std::string & _current_task
void paramError(const std::string &param, Args... args) const
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
void mooseError(Args &&... args) const
std::shared_ptr< FEProblemBase > & _problem
const InputParameters & parameters() const
const std::string _base_name
base name for the current master action block
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_spherical_component_table

◆ actStressDivergenceTensorsStrain()

void QuasiStaticSolidMechanicsPhysics::actStressDivergenceTensorsStrain ( )
protectedinherited

Definition at line 998 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

999 {
1000  std::string ad_prepend = _use_ad ? "AD" : "";
1001 
1002  std::string type;
1003 
1004  // no plane strain
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"},
1013  "ComputeAxisymmetricRZIncrementalStrain"},
1015  "ComputeAxisymmetricRZFiniteStrain"},
1016  {{Moose::COORD_RSPHERICAL, StrainAndIncrement::SmallTotal}, "ComputeRSphericalSmallStrain"},
1018  "ComputeRSphericalIncrementalStrain"},
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  }
1031  {
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"},
1043  "ComputeAxisymmetric1DIncrementalStrain"},
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 }
enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement _strain_and_increment
InputParameters getValidParams(const std::string &name) const
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
COORD_RSPHERICAL
virtual const std::string & name() const
enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation _planar_formulation
bool isParamValid(const std::string &name) const
Factory & _factory
std::vector< VariableName > _coupled_displacements
Coupled displacement variables.
const std::string & type() const
void paramError(const std::string &param, Args... args) const
std::vector< MaterialPropertyName > _eigenstrain_names
void mooseError(Args &&... args) const
std::shared_ptr< FEProblemBase > & _problem
const InputParameters & parameters() const

◆ actSubdomainChecks()

void QuasiStaticSolidMechanicsPhysics::actSubdomainChecks ( )
protectedinherited

Definition at line 515 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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 
547  {
549  mooseError("'out_of_plane_direction' must be 'z' for axisymmetric simulations");
550  }
552  {
554  mooseError(
555  "Must specify two displacements for plane strain when the out of plane direction is z");
557  mooseError("Must specify three displacements for plane strain when the out of plane "
558  "direction is x or y");
559  }
560  }
561 }
std::set< SubdomainID > _subdomain_ids
set generated from the passed in vector of subdomain names
unsigned int _ndisp
Number of displacement variables.
virtual const std::string & name() const
enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation _planar_formulation
const SubdomainID INVALID_BLOCK_ID
std::vector< SubdomainName > _subdomain_names
if this vector is not empty the variables, kernels and materials are restricted to these subdomains ...
const std::string & _current_task
void paramError(const std::string &param, Args... args) const
std::shared_ptr< MooseMesh > & _mesh
void mooseError(Args &&... args) const
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 }
static std::map< std::string, std::string > _rank_two_cartesian_component_table

◆ getKernelParameters()

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

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1142 of file QuasiStaticSolidMechanicsPhysics.C.

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

1143 {
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") =
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 }
const bool _lk_large_kinematics
Simplified flag for small/large deformations, Lagrangian kernel system.
T & set(const std::string &name, bool quiet_mode=false)
InputParameters getValidParams(const std::string &name) const
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
Factory & _factory
bool _use_displaced_mesh
use displaced mesh (true unless _strain is SMALL)
std::vector< VariableName > _coupled_displacements
Coupled displacement variables.
const std::string & type() const
bool _lk_locking
Simplified volumetric locking correction flag for new kernels.
const bool _lagrangian_kernels
New or old kernel system.
const InputParameters & parameters() const

◆ getKernelType()

std::string QuasiStaticSolidMechanicsPhysics::getKernelType ( )
protectedvirtualinherited

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1083 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

1084 {
1085  if (_lagrangian_kernels)
1086  {
1087  std::string type;
1089  {
1090  if (_lk_homogenization)
1091  type = "HomogenizedTotalLagrangianStressDivergence";
1093  type = "TotalLagrangianStressDivergence";
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.");
1105  type = "TotalLagrangianStressDivergenceAxisymmetricCylindrical";
1107  mooseError("The Lagrangian mechanics kernels do not yet support the updated Lagrangian "
1108  "formulation in RZ coordinates.");
1109  }
1111  {
1112  if (_lk_homogenization)
1113  mooseError("The Lagrangian mechanics kernels do not yet support homogenization in "
1114  "coordinate systems other than Cartesian.");
1116  type = "TotalLagrangianStressDivergenceCentrosymmetricSpherical";
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 }
COORD_RSPHERICAL
const std::string & type() const
const bool _lagrangian_kernels
New or old kernel system.
void mooseError(Args &&... args) const
bool _lk_homogenization
Flag indicating if the homogenization system is present for new kernels.

◆ materialOutputFamilies()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies ( )
staticinherited

◆ materialOutputOrders()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders ( )
staticinherited

Definition at line 291 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

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

◆ outputPropertiesType()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType ( )
staticinherited

Definition at line 305 of file QuasiStaticSolidMechanicsPhysicsBase.C.

Referenced by QuasiStaticSolidMechanicsPhysicsBase::validParams(), and QuasiStaticSolidMechanicsPhysics::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] +
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 }
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_cylindrical_component_table
static const std::vector< char > _component_table
table data for output generation
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
static const std::map< std::string, std::pair< std::string, std::vector< std::string > > > _rank_two_spherical_component_table

◆ setupOutput()

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

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

Definition at line 173 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::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 }
static std::map< std::string, std::string > _rank_two_cartesian_component_table
OStreamProxy out
void setup(EquationSystems &systems, Mesh &mesh, GetPot &args)
void mooseError(Args &&... args) const

◆ validParams()

InputParameters PoroMechanicsAction::validParams ( )
static

Definition at line 24 of file PoroMechanicsAction.C.

25 {
27  params.addRequiredParam<VariableName>("porepressure", "The pore pressure variable");
28  params.addClassDescription("Adds the poro-mechanics coupling term");
29  return params;
30 }
void addRequiredParam(const std::string &name, const std::string &doc_string)
void addClassDescription(const std::string &doc_string)

◆ verifyOrderAndFamilyOutputs()

void QuasiStaticSolidMechanicsPhysics::verifyOrderAndFamilyOutputs ( )
protectedinherited

Definition at line 762 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::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
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 &&
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)
783 
784  // For only one order, make all orders the same magnitude
785  if (_material_output_order.size() == 1)
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)
798 
799  // For only one family, make all families that value
800  if (_material_output_family.size() == 1)
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 }
void setAdditionalValue(const std::string &names)
unsigned int size() const
std::vector< std::string > _generate_output
output materials to generate scalar stress/strain tensor quantities
void paramError(const std::string &param, Args... args) const
std::string stringify(const T &t)
const std::string _name

Member Data Documentation

◆ _auto_eigenstrain

const bool QuasiStaticSolidMechanicsPhysics::_auto_eigenstrain
protectedinherited

automatically gather names of eigenstrain tensors provided by simulation objects

Definition at line 134 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

◆ _base_name

const std::string QuasiStaticSolidMechanicsPhysics::_base_name
protectedinherited

base name for the current master action block

Definition at line 106 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _component_table

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

◆ _constraint_types

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_constraint_types
protectedinherited

◆ _coord_system

Moose::CoordinateSystemType QuasiStaticSolidMechanicsPhysics::_coord_system
protectedinherited

◆ _coupled_displacements

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

◆ _cylindrical_axis_point1

Point QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1
protectedinherited

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

Definition at line 123 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point1_valid

bool QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1_valid
protectedinherited

booleans used to determine if cylindrical axis points are passed

Definition at line 117 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point2

Point QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point2
protectedinherited

◆ _cylindrical_axis_point2_valid

bool QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point2_valid
protectedinherited

◆ _diag_save_in

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

◆ _direction

Point QuasiStaticSolidMechanicsPhysics::_direction
protectedinherited

◆ _direction_valid

bool QuasiStaticSolidMechanicsPhysics::_direction_valid
protectedinherited

◆ _displacements

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

◆ _eigenstrain_names

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

◆ _generate_output

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

◆ _hname

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

◆ _homogenization_strain_name

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

◆ _integrator_name

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

◆ _lagrangian_kernels

const bool QuasiStaticSolidMechanicsPhysics::_lagrangian_kernels
protectedinherited

◆ _lk_formulation

const LKFormulation QuasiStaticSolidMechanicsPhysics::_lk_formulation
protectedinherited

◆ _lk_homogenization

bool QuasiStaticSolidMechanicsPhysics::_lk_homogenization
protectedinherited

◆ _lk_large_kinematics

const bool QuasiStaticSolidMechanicsPhysics::_lk_large_kinematics
protectedinherited

◆ _lk_locking

bool QuasiStaticSolidMechanicsPhysics::_lk_locking
protectedinherited

Simplified volumetric locking correction flag for new kernels.

Definition at line 153 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _material_output_family

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_material_output_family
protectedinherited

◆ _material_output_order

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_material_output_order
protectedinherited

◆ _ndisp

unsigned int QuasiStaticSolidMechanicsPhysics::_ndisp
protectedinherited

◆ _order_mapper

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

Definition at line 159 of file QuasiStaticSolidMechanicsPhysics.h.

◆ _out_of_plane_direction

const OutOfPlaneDirection QuasiStaticSolidMechanicsPhysics::_out_of_plane_direction
protectedinherited

◆ _planar_formulation

enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation QuasiStaticSolidMechanicsPhysics::_planar_formulation
protectedinherited

◆ _rank_two_cartesian_component_table

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

Definition at line 42 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _rank_two_cylindrical_component_table

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

Definition at line 33 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _rank_two_directional_component_table

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

Definition at line 31 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _rank_two_invariant_table

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

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

◆ _save_in

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

◆ _spherical_center_point

Point QuasiStaticSolidMechanicsPhysics::_spherical_center_point
protectedinherited

center point for spherical stress/strain quantities

Definition at line 131 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _spherical_center_point_valid

bool QuasiStaticSolidMechanicsPhysics::_spherical_center_point_valid
protectedinherited

booleans used to determine if spherical center point is passed

Definition at line 128 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _strain

enum QuasiStaticSolidMechanicsPhysics::Strain QuasiStaticSolidMechanicsPhysics::_strain
protectedinherited

◆ _strain_and_increment

enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement QuasiStaticSolidMechanicsPhysics::_strain_and_increment
protectedinherited

◆ _subdomain_id_union

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

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

Definition at line 69 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::actGatherActionParameters().

◆ _subdomain_ids

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

set generated from the passed in vector of subdomain names

Definition at line 66 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _subdomain_names

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

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 QuasiStaticSolidMechanicsPhysics::act(), QuasiStaticSolidMechanicsPhysics::actLagrangianKernelStrain(), and QuasiStaticSolidMechanicsPhysics::actSubdomainChecks().

◆ _targets

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

◆ _use_ad

const bool QuasiStaticSolidMechanicsPhysicsBase::_use_ad
protectedinherited

◆ _use_displaced_mesh

bool QuasiStaticSolidMechanicsPhysics::_use_displaced_mesh
protectedinherited

◆ _verbose

bool QuasiStaticSolidMechanicsPhysics::_verbose
protectedinherited

The documentation for this class was generated from the following files: