#include <QuasiStaticSolidMechanicsPhysicsBase.h>

Inheritance diagram for QuasiStaticSolidMechanicsPhysicsBase:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	QuasiStaticSolidMechanicsPhysicsBase (const InputParameters &params)

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 Member Functions
bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)

virtual void	act ()=0

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

Static Protected Attributes
static std::map< std::string, std::string >	_rank_two_cartesian_component_table

Detailed Description

Definition at line 14 of file QuasiStaticSolidMechanicsPhysicsBase.h.

Constructor & Destructor Documentation

◆ QuasiStaticSolidMechanicsPhysicsBase()

QuasiStaticSolidMechanicsPhysicsBase::QuasiStaticSolidMechanicsPhysicsBase ( const InputParameters & params )

Definition at line 250 of file QuasiStaticSolidMechanicsPhysicsBase.C.

   : Action(parameters), _use_ad(getParam<bool>("use_automatic_differentiation"))
 {
   const auto & params = _app.getInputParameterWarehouse().getInputParameters();
   InputParameters & pars(*(params.find(uniqueActionName())->second.get()));
 
   // check if a container block with common parameters is found
   auto action = _awh.getActions<CommonSolidMechanicsAction>();
   if (action.size() == 1)
     pars.applyParameters(action[0]->parameters());
 
   // append additional_generate_output
   if (isParamValid("additional_generate_output"))
   {
     MultiMooseEnum generate_output = getParam<MultiMooseEnum>("generate_output");
     MultiMooseEnum additional_generate_output =
         getParam<MultiMooseEnum>("additional_generate_output");
 
     MultiMooseEnum material_output_order = getParam<MultiMooseEnum>("material_output_order");
     MultiMooseEnum additional_material_output_order =
         getParam<MultiMooseEnum>("additional_material_output_order");
 
     MultiMooseEnum material_output_family = getParam<MultiMooseEnum>("material_output_family");
     MultiMooseEnum additional_material_output_family =
         getParam<MultiMooseEnum>("additional_material_output_family");
 
     for (auto & output : additional_generate_output)
       generate_output.setAdditionalValue(output);
     for (auto & order : additional_material_output_order)
       material_output_order.setAdditionalValue(order);
     for (auto & family : additional_material_output_family)
       material_output_family.setAdditionalValue(family);
 
     pars.set<MultiMooseEnum>("generate_output") = generate_output;
     pars.set<MultiMooseEnum>("material_output_order") = material_output_order;
     pars.set<MultiMooseEnum>("material_output_family") = material_output_family;
   }
 }

Member Function Documentation

◆ addCartesianComponentOutput()

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

static

Definition at line 334 of file QuasiStaticSolidMechanicsPhysicsBase.C.

 {
   if (prop_name.empty())
     // the enum name is the actual tensor material property name
     _rank_two_cartesian_component_table.emplace(enum_name, enum_name);
   else
     // supply a different name for the enum options (this is done for
     // 'strain' -> 'mechanical_strain' in the TMA)
     _rank_two_cartesian_component_table.emplace(enum_name, prop_name);
 }

◆ materialOutputFamilies()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies ( )

static

Definition at line 299 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

 {
   return MultiMooseEnum("MONOMIAL LAGRANGE");
 }

◆ materialOutputOrders()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders ( )

static

Definition at line 291 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

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

◆ outputPropertiesType()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType ( )

static

Definition at line 305 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

 {
   std::string options = "";
   for (auto & r2tc : _rank_two_cartesian_component_table)
     for (unsigned int a = 0; a < 3; ++a)
       for (unsigned int b = 0; b < 3; ++b)
         options += (options == "" ? "" : " ") + r2tc.first + '_' + _component_table[a] +
                    _component_table[b];
 
   for (auto & r2i : _rank_two_invariant_table)
     for (auto & t : r2i.second.second)
       options += " " + r2i.first + "_" + t;
 
   for (auto & r2sdc : _rank_two_directional_component_table)
     for (auto & r : r2sdc.second.second)
       options += " " + r2sdc.first + "_" + r;
 
   for (auto & r2cc : _rank_two_cylindrical_component_table)
     for (auto & r : r2cc.second.second)
       options += " " + r2cc.first + "_" + r;
 
   for (auto & r2sc : _rank_two_spherical_component_table)
     for (auto & r : r2sc.second.second)
       options += " " + r2sc.first + "_" + r;
 
   return MultiMooseEnum(options, "", true);
 }

◆ validParams()

InputParameters QuasiStaticSolidMechanicsPhysicsBase::validParams ( )

static

Definition at line 137 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

 {
   InputParameters params = Action::validParams();
 
   params.addRequiredParam<std::vector<VariableName>>(
       "displacements", "The nonlinear displacement variables for the problem");
   params.addParam<std::vector<VariableName>>("temperature", "The temperature");
 
   MooseEnum strainType("SMALL FINITE", "SMALL");
   params.addParam<MooseEnum>("strain", strainType, "Strain formulation");
   params.addParam<bool>("incremental",
                         "Use incremental or total strain (if not explicitly specified this "
                         "defaults to incremental for finite strain and total for small strain)");
 
   params.addParam<std::string>("base_name", "Material property base name");
   params.addParam<bool>(
       "volumetric_locking_correction", false, "Flag to correct volumetric locking");
   params.addParam<bool>(
       "use_finite_deform_jacobian", false, "Jacobian for corrotational finite strain");
   params.addParam<bool>("add_variables", false, "Add the displacement variables");
   params.addParam<std::vector<MaterialPropertyName>>(
       "eigenstrain_names", {}, "List of eigenstrains to be applied in this strain calculation");
   params.addParam<bool>("use_automatic_differentiation",
                         false,
                         "Flag to use automatic differentiation (AD) objects when possible");
   // Global Strain
   params.addParam<MaterialPropertyName>(
       "global_strain",
       "Name of the global strain material to be applied in this strain calculation. "
       "The global strain tensor is constant over the whole domain and allows visualization "
       "of the deformed shape with the periodic BC");
 
   // Advanced
   params.addParam<std::vector<AuxVariableName>>("save_in", {}, "The displacement residuals");
   params.addParam<std::vector<AuxVariableName>>(
       "diag_save_in", {}, "The displacement diagonal preconditioner terms");
   params.addParam<MooseEnum>("decomposition_method",
                              ComputeFiniteStrain::decompositionType(),
                              "Methods to calculate the finite strain and rotation increments");
   params.addParamNamesToGroup("save_in diag_save_in", "Advanced");
 
   // Planar Formulation
   MooseEnum planarFormulationType("NONE WEAK_PLANE_STRESS PLANE_STRAIN GENERALIZED_PLANE_STRAIN",
                                   "NONE");
   params.addParam<MooseEnum>(
       "planar_formulation", planarFormulationType, "Out-of-plane stress/strain formulation");
   params.addParam<VariableName>("scalar_out_of_plane_strain",
                                 "Scalar variable for the out-of-plane strain (in y "
                                 "direction for 1D Axisymmetric or in z direction for 2D "
                                 "Cartesian problems)");
   params.addParam<VariableName>("out_of_plane_strain",
                                 "Variable for the out-of-plane strain for plane stress models");
   MooseEnum outOfPlaneDirection("x y z", "z");
   params.addParam<MooseEnum>(
       "out_of_plane_direction", outOfPlaneDirection, "The direction of the out-of-plane strain.");
   params.addDeprecatedParam<FunctionName>(
       "out_of_plane_pressure",
       "Function used to prescribe pressure (applied toward the body) in the out-of-plane direction "
       "(y for 1D Axisymmetric or z for 2D Cartesian problems)",
       "This has been replaced by 'out_of_plane_pressure_function'");
   params.addParam<FunctionName>(
       "out_of_plane_pressure_function",
       "Function used to prescribe pressure (applied toward the body) in the out-of-plane direction "
       "(y for 1D Axisymmetric or z for 2D Cartesian problems)");
   params.addParam<Real>(
       "pressure_factor",
       "Scale factor applied to prescribed out-of-plane pressure (both material and function)");
   params.addParam<MaterialPropertyName>("out_of_plane_pressure_material",
                                         "0",
                                         "Material used to prescribe pressure (applied toward the "
                                         "body) in the out-of-plane direction");
   params.addParamNamesToGroup("planar_formulation scalar_out_of_plane_strain out_of_plane_pressure "
                               "out_of_plane_pressure_material out_of_plane_pressure_function "
                               "pressure_factor out_of_plane_direction out_of_plane_strain",
                               "Out-of-plane stress/strain");
 
   // Output
   params.addParam<MultiMooseEnum>("generate_output",
                                   QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType(),
                                   "Add scalar quantity output for stress and/or strain");
 
   params.addParam<MultiMooseEnum>(
       "material_output_order",
       QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders(),
       "Specifies the order of the FE shape function to use for this variable.");
 
   params.addParam<MultiMooseEnum>(
       "material_output_family",
       QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies(),
       "Specifies the family of FE shape functions to use for this variable.");
   params.addParamNamesToGroup("generate_output material_output_order material_output_family",
                               "Output");
   params.addParam<bool>("verbose", false, "Display extra information.");
 
   params.addParam<bool>("new_system",
                         false,
                         "If true use the new "
                         "LagrangianStressDiverence kernels.");
 
   MooseEnum formulationType("TOTAL UPDATED", "TOTAL");
   params.addParam<MooseEnum>("formulation",
                              formulationType,
                              "Select between the total Lagrangian (TOTAL) "
                              "and updated Lagrangian (UPDATED) formulations "
                              "for the new kernel system.");
 
   params.addParamNamesToGroup("add_variables displacements temperature", "Variables");
   params.addParamNamesToGroup("strain incremental use_finite_deform_jacobian eigenstrain_names",
                               "Strain");
 
   return params;
 }

Member Data Documentation

◆ _component_table

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

static

table data for output generation

Definition at line 27 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _rank_two_cartesian_component_table

std::map< std::string, std::string > QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cartesian_component_table

staticprotected

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(), addCartesianComponentOutput(), 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

static

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

static

Initial value:

= {

{"directional", {"Direction", {"stress", "strain"}}}}

Definition at line 31 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _rank_two_invariant_table

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

static

Definition at line 29 of file QuasiStaticSolidMechanicsPhysicsBase.h.

Referenced by QuasiStaticSolidMechanicsPhysics::actOutputMatProp(), and 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

static

Initial value:

= {
        {"spherical_hoop",
         {"HoopStress", {"stress", "strain", "plastic_strain", "creep_strain", "elastic_strain"}}},
        {"spherical_radial", {"RadialStress", {"stress", "strain"}}}}