#include <PoroMechanicsAction.h>

Inheritance diagram for PoroMechanicsAction:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PoroMechanicsAction (const InputParameters &params)

virtual void	act ()

void	timedAct ()

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

MooseObjectName	uniqueActionName () const

const std::string &	specificTaskName () const

const std::set< std::string > &	getAllTasks () const

void	appendTask (const std::string &task)

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static MultiMooseEnum	outputPropertiesType ()

static MultiMooseEnum	materialOutputOrders ()

static MultiMooseEnum	materialOutputFamilies ()

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

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node)

Public Attributes
const ConsoleStream	_console

Static Public Attributes
static const std::string	unique_action_name_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME


static const std::vector< char >	_component_table = {'x', 'y', 'z'}
	table data for output generation 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

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator


std::vector< VariableName >	_displacements
	displacement variables 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.

   {
     Total,
     Updated
   };

◆ OutOfPlaneDirection

enum QuasiStaticSolidMechanicsPhysics::OutOfPlaneDirection

strongprotectedinherited

Enumerator
x
y
z

Definition at line 96 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     x,
     y,
     z
   };

◆ PlanarFormulation

enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation

strongprotectedinherited

use an out of plane stress/strain formulation

Enumerator
None
WeakPlaneStress
PlaneStrain
GeneralizedPlaneStrain

Definition at line 88 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     None,
     WeakPlaneStress,
     PlaneStrain,
     GeneralizedPlaneStrain,
   } _planar_formulation;

◆ Strain

enum QuasiStaticSolidMechanicsPhysics::Strain

strongprotectedinherited

strain formulation

Enumerator
Small
Finite

Definition at line 72 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     Small,
     Finite
   } _strain;

◆ StrainAndIncrement

enum QuasiStaticSolidMechanicsPhysics::StrainAndIncrement

strongprotectedinherited

strain formulation

Enumerator
SmallTotal
FiniteTotal
SmallIncremental
FiniteIncremental

Definition at line 79 of file QuasiStaticSolidMechanicsPhysics.h.

   {
     SmallTotal,
     FiniteTotal,
     SmallIncremental,
     FiniteIncremental
   } _strain_and_increment;

Constructor & Destructor Documentation

◆ PoroMechanicsAction()

PoroMechanicsAction::PoroMechanicsAction ( const InputParameters & params )

Definition at line 32 of file PoroMechanicsAction.C.

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

Member Function Documentation

◆ act()

void PoroMechanicsAction::act ( )

virtual

Reimplemented from QuasiStaticSolidMechanicsPhysics.

Definition at line 40 of file PoroMechanicsAction.C.

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

◆ actEigenstrainNames()

void QuasiStaticSolidMechanicsPhysics::actEigenstrainNames ( )

protectedinherited

Definition at line 632 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

 {
   // Create containers for collecting blockIDs and eigenstrain names from materials
   std::map<std::string, std::set<SubdomainID>> material_eigenstrain_map;
   std::set<std::string> eigenstrain_set;
 
   std::set<MaterialPropertyName> verified_eigenstrain_names;
 
   std::map<std::string, std::string> remove_add_map;
   std::set<std::string> remove_reduced_set;
 
   // Loop over all the materials(eigenstrains) already created
   auto materials = _problem->getMaterialWarehouse().getObjects();
   for (auto & mat : materials)
   {
     std::shared_ptr<BlockRestrictable> blk = std::dynamic_pointer_cast<BlockRestrictable>(mat);
     const InputParameters & mat_params = mat->parameters();
     auto & mat_name = mat->type();
 
     // Check for eigenstrain names, only deal with those materials
     if (mat_params.isParamValid("eigenstrain_name"))
     {
       std::shared_ptr<MaterialData> mat_dat;
       auto name = mat_params.get<std::string>("eigenstrain_name");
 
       // Check for base_name prefix
       if (mat_params.isParamValid("base_name"))
         name = mat_params.get<std::string>("base_name") + '_' + name;
 
       // Check block restrictions
       if (!blk)
         mooseError("Internal error, Material object that does not inherit form BlockRestricted");
       const std::set<SubdomainID> & blocks =
           blk->blockRestricted() ? blk->blockIDs() : blk->meshBlockIDs();
 
       if (std::includes(blocks.begin(), blocks.end(), _subdomain_ids.begin(), _subdomain_ids.end()))
       {
         material_eigenstrain_map[name].insert(blocks.begin(), blocks.end());
         eigenstrain_set.insert(name);
       }
     }
 
     // Account for reduced eigenstrains and CompositeEigenstrains
     if (mat_name == "ComputeReducedOrderEigenstrain")
     {
       auto input_eigenstrain_names =
           mat_params.get<std::vector<MaterialPropertyName>>("input_eigenstrain_names");
       remove_reduced_set.insert(input_eigenstrain_names.begin(), input_eigenstrain_names.end());
     }
     // Account for CompositeEigenstrains
     if (mat_name == "CompositeEigenstrain")
     {
       auto remove_list = mat_params.get<std::vector<MaterialPropertyName>>("tensors");
       for (auto i : remove_list)
         remove_reduced_set.insert(i);
     }
 
     // Account for MaterialADConverter , add or remove later
     if (mat_name == "RankTwoTensorMaterialADConverter")
     {
       std::vector<MaterialPropertyName> remove_list;
       std::vector<MaterialPropertyName> add_list;
 
       if (mat_params.isParamValid("ad_props_out") && mat_params.isParamValid("reg_props_in") &&
           _use_ad)
       {
         remove_list = mat_params.get<std::vector<MaterialPropertyName>>("reg_props_in");
         add_list = mat_params.get<std::vector<MaterialPropertyName>>("ad_props_out");
       }
       if (mat_params.isParamValid("ad_props_in") && mat_params.isParamValid("reg_props_out") &&
           !_use_ad)
       {
         remove_list = mat_params.get<std::vector<MaterialPropertyName>>("ad_props_in");
         add_list = mat_params.get<std::vector<MaterialPropertyName>>("reg_props_out");
       }
 
       // These vectors are the same size as checked in MaterialADConverter
       for (unsigned int index = 0; index < remove_list.size(); index++)
         remove_add_map.emplace(remove_list[index], add_list[index]);
     }
   }
   // All the materials have been accounted for, now remove or add parts
 
   // Remove names which aren't eigenstrains (converter properties)
   for (auto remove_add_index : remove_add_map)
   {
     const bool is_in = eigenstrain_set.find(remove_add_index.first) != eigenstrain_set.end();
     if (is_in)
     {
       eigenstrain_set.erase(remove_add_index.first);
       eigenstrain_set.insert(remove_add_index.second);
     }
   }
   for (auto index : remove_reduced_set)
     eigenstrain_set.erase(index);
 
   // Compare the blockIDs set of eigenstrain names with the vector of _eigenstrain_names for the
   // current subdomainID
   std::set_union(eigenstrain_set.begin(),
                  eigenstrain_set.end(),
                  _eigenstrain_names.begin(),
                  _eigenstrain_names.end(),
                  std::inserter(verified_eigenstrain_names, verified_eigenstrain_names.begin()));
 
   // Ensure the eigenstrain names previously passed include any missing names
   _eigenstrain_names.resize(verified_eigenstrain_names.size());
   std::copy(verified_eigenstrain_names.begin(),
             verified_eigenstrain_names.end(),
             _eigenstrain_names.begin());
 
   Moose::out << COLOR_CYAN << "*** Automatic Eigenstrain Names ***"
              << "\n"
              << _name << ": " << Moose::stringify(_eigenstrain_names) << "\n"
              << COLOR_DEFAULT << std::flush;
 }

◆ actGatherActionParameters()

void QuasiStaticSolidMechanicsPhysics::actGatherActionParameters ( )

protectedinherited

Definition at line 907 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

 {
   // Gather info about all other solid mechanics physics when we add variables
   if (_current_task == "validate_coordinate_systems" && getParam<bool>("add_variables"))
   {
     auto actions = _awh.getActions<QuasiStaticSolidMechanicsPhysics>();
     for (const auto & action : actions)
     {
       const auto size_before = _subdomain_id_union.size();
       const auto added_size = action->_subdomain_ids.size();
       _subdomain_id_union.insert(action->_subdomain_ids.begin(), action->_subdomain_ids.end());
       const auto size_after = _subdomain_id_union.size();
 
       if (size_after != size_before + added_size)
         mooseError("The block restrictions in the SolidMechanics/QuasiStatic actions must be "
                    "non-overlapping.");
 
       if (added_size == 0 && actions.size() > 1)
         mooseError(
             "No SolidMechanics/QuasiStatic action can be block unrestricted if more than one "
             "SolidMechanics/QuasiStatic action is specified.");
     }
   }
 }

◆ actLagrangianKernelStrain()

void QuasiStaticSolidMechanicsPhysics::actLagrangianKernelStrain ( )

protectedinherited

Definition at line 933 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

 {
   std::string type;
   if (_coord_system == Moose::COORD_XYZ)
     type = "ComputeLagrangianStrain";
   else if (_coord_system == Moose::COORD_RZ)
     type = "ComputeLagrangianStrainAxisymmetricCylindrical";
   else if (_coord_system == Moose::COORD_RSPHERICAL)
     type = "ComputeLagrangianStrainCentrosymmetricSpherical";
   else
     mooseError("Unsupported coordinate system");
 
   auto params = _factory.getValidParams(type);
 
   if (isParamValid("strain_base_name"))
     params.set<std::string>("base_name") = getParam<std::string>("strain_base_name");
 
   params.set<std::vector<VariableName>>("displacements") = _coupled_displacements;
   params.set<std::vector<MaterialPropertyName>>("eigenstrain_names") = _eigenstrain_names;
   params.set<bool>("large_kinematics") = _lk_large_kinematics;
   params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
   // Error if volumetric locking correction is on for higher-order elements
   if (_problem->mesh().hasSecondOrderElements() && _lk_locking)
     mooseError("Volumetric locking correction should not be used for "
                "higher-order elements.");
 
   params.set<bool>("stabilize_strain") = _lk_locking;
 
   if (_lk_homogenization)
   {
     params.set<std::vector<MaterialPropertyName>>("homogenization_gradient_names") = {
         _homogenization_strain_name};
   }
 
   _problem->addMaterial(type, name() + "_strain", params);
 
   // Add the homogenization strain calculator
   if (_lk_homogenization)
   {
     std::string type = "ComputeHomogenizedLagrangianStrain";
     auto params = _factory.getValidParams(type);
 
     params.set<MaterialPropertyName>("homogenization_gradient_name") = _homogenization_strain_name;
     params.set<std::vector<VariableName>>("macro_gradient") = {_hname};
     params.set<MultiMooseEnum>("constraint_types") = _constraint_types;
     params.set<std::vector<FunctionName>>("targets") = _targets;
 
     _problem->addMaterial(type, name() + "_compute_" + _homogenization_strain_name, params);
   }
 }

◆ actOutputGeneration()

void QuasiStaticSolidMechanicsPhysics::actOutputGeneration ( )

protectedinherited

Definition at line 551 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

 {
   if (_current_task == "add_material")
     actOutputMatProp();
 
   // Add variables (optional)
   if (_current_task == "add_aux_variable")
   {
     unsigned int index = 0;
     for (auto out : _generate_output)
     {
       const auto & order = _material_output_order[index];
       const auto & family = _material_output_family[index];
 
       std::string type = (order == "CONSTANT" && family == "MONOMIAL")
                              ? "MooseVariableConstMonomial"
                              : "MooseVariable";
 
       // Create output helper aux variables
       auto params = _factory.getValidParams(type);
       params.set<MooseEnum>("order") = order;
       params.set<MooseEnum>("family") = family;
 
       if (family == "MONOMIAL")
         _problem->addAuxVariable(type, _base_name + out, params);
       else
         _problem->addVariable(type, _base_name + out, params);
 
       index++;
     }
   }
 
   // Add output AuxKernels
   else if (_current_task == "add_aux_kernel")
   {
     std::string ad_prepend = _use_ad ? "AD" : "";
     // Loop through output aux variables
     unsigned int index = 0;
     for (auto out : _generate_output)
     {
       if (_material_output_family[index] == "MONOMIAL")
       {
         InputParameters params = emptyInputParameters();
 
         params = _factory.getValidParams("MaterialRealAux");
         params.applyParameters(parameters());
         params.set<MaterialPropertyName>("property") = _base_name + out;
         params.set<AuxVariableName>("variable") = _base_name + out;
         params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
 
         _problem->addAuxKernel(
             ad_prepend + "MaterialRealAux", _base_name + out + '_' + name(), params);
       }
       index++;
     }
   }
   else if (_current_task == "add_kernel")
   {
     std::string ad_prepend = _use_ad ? "AD" : "";
     // Loop through output aux variables
     unsigned int index = 0;
     for (auto out : _generate_output)
     {
       if (_material_output_family[index] != "MONOMIAL")
       {
         InputParameters params = emptyInputParameters();
 
         params = _factory.getValidParams("MaterialPropertyValue");
         params.applyParameters(parameters());
         params.set<MaterialPropertyName>("prop_name") = _base_name + out;
         params.set<NonlinearVariableName>("variable") = _base_name + out;
 
         _problem->addKernel(
             ad_prepend + "MaterialPropertyValue", _base_name + out + '_' + name(), params);
       }
       index++;
     }
   }
 }

◆ actOutputMatProp()

void QuasiStaticSolidMechanicsPhysics::actOutputMatProp ( )

protectedinherited

Definition at line 799 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::actOutputGeneration().

 {
   std::string ad_prepend = _use_ad ? "AD" : "";
 
   if (_current_task == "add_material")
   {
     // Add output Materials
     for (auto out : _generate_output)
     {
       InputParameters params = emptyInputParameters();
 
       // RankTwoCartesianComponent
       if (
           [&]()
           {
             for (const auto & r2q : _rank_two_cartesian_component_table)
               for (unsigned int a = 0; a < 3; ++a)
                 for (unsigned int b = 0; b < 3; ++b)
                   if (r2q.first + '_' + _component_table[a] + _component_table[b] == out)
                   {
                     auto type = ad_prepend + "RankTwoCartesianComponent";
                     params = _factory.getValidParams(type);
                     params.set<MaterialPropertyName>("rank_two_tensor") = _base_name + r2q.second;
                     params.set<unsigned int>("index_i") = a;
                     params.set<unsigned int>("index_j") = b;
 
                     params.applyParameters(parameters());
                     params.set<MaterialPropertyName>("property_name") = _base_name + out;
                     _problem->addMaterial(type, _base_name + out + '_' + name(), params);
                     return true;
                   }
             return false;
           }())
         continue;
 
       // RankTwoDirectionalComponent
       if (setupOutput(out,
                       _rank_two_directional_component_table,
                       [&](std::string prop_name, std::string invariant)
                       {
                         auto type = ad_prepend + "RankTwoDirectionalComponent";
                         params = _factory.getValidParams(type);
                         params.set<MaterialPropertyName>("rank_two_tensor") =
                             _base_name + prop_name;
                         params.set<MooseEnum>("invariant") = invariant;
                         params.applyParameters(parameters());
                         params.set<MaterialPropertyName>("property_name") = _base_name + out;
                         _problem->addMaterial(type, _base_name + out + '_' + name(), params);
                       }))
         continue;
 
       // RankTwoInvariant
       if (setupOutput(out,
                       _rank_two_invariant_table,
                       [&](std::string prop_name, std::string invariant)
                       {
                         auto type = ad_prepend + "RankTwoInvariant";
                         params = _factory.getValidParams(type);
                         params.set<MaterialPropertyName>("rank_two_tensor") =
                             _base_name + prop_name;
                         params.set<MooseEnum>("invariant") = invariant;
                         params.applyParameters(parameters());
                         params.set<MaterialPropertyName>("property_name") = _base_name + out;
                         _problem->addMaterial(type, _base_name + out + '_' + name(), params);
                       }))
         continue;
 
       // RankTwoCylindricalComponent
       if (setupOutput(
               out,
               _rank_two_cylindrical_component_table,
               [&](std::string prop_name, std::string component)
               {
                 if (_coord_system == Moose::COORD_RSPHERICAL)
                   mooseError(
                       "Cannot use cylindrical component output in a spherical coordinate system.");
                 auto type = ad_prepend + "RankTwoCylindricalComponent";
                 params = _factory.getValidParams(type);
                 params.set<MaterialPropertyName>("rank_two_tensor") = _base_name + prop_name;
                 params.set<MooseEnum>("cylindrical_component") = component;
                 params.applyParameters(parameters());
                 params.set<MaterialPropertyName>("property_name") = _base_name + out;
                 _problem->addMaterial(type, _base_name + out + '_' + name(), params);
               }))
         continue;
 
       // RankTwoSphericalComponent
       if (setupOutput(out,
                       _rank_two_spherical_component_table,
                       [&](std::string prop_name, std::string component)
                       {
                         auto type = ad_prepend + "RankTwoSphericalComponent";
                         params = _factory.getValidParams(type);
                         params.set<MaterialPropertyName>("rank_two_tensor") =
                             _base_name + prop_name;
                         params.set<MooseEnum>("spherical_component") = component;
                         params.applyParameters(parameters());
                         params.set<MaterialPropertyName>("property_name") = _base_name + out;
                         _problem->addMaterial(type, _base_name + out + '_' + name(), params);
                       }))
         continue;
 
       paramError("generate_output", "Unable to add output Material for '", out, "'");
     }
   }
 }

◆ actStressDivergenceTensorsStrain()

void QuasiStaticSolidMechanicsPhysics::actStressDivergenceTensorsStrain ( )

protectedinherited

Definition at line 986 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

 {
   std::string ad_prepend = _use_ad ? "AD" : "";
 
   std::string type;
 
   // no plane strain
   if (_planar_formulation == PlanarFormulation::None)
   {
     std::map<std::pair<Moose::CoordinateSystemType, StrainAndIncrement>, std::string> type_map = {
         {{Moose::COORD_XYZ, StrainAndIncrement::SmallTotal}, "ComputeSmallStrain"},
         {{Moose::COORD_XYZ, StrainAndIncrement::SmallIncremental}, "ComputeIncrementalStrain"},
         {{Moose::COORD_XYZ, StrainAndIncrement::FiniteIncremental}, "ComputeFiniteStrain"},
         {{Moose::COORD_RZ, StrainAndIncrement::SmallTotal}, "ComputeAxisymmetricRZSmallStrain"},
         {{Moose::COORD_RZ, StrainAndIncrement::SmallIncremental},
          "ComputeAxisymmetricRZIncrementalStrain"},
         {{Moose::COORD_RZ, StrainAndIncrement::FiniteIncremental},
          "ComputeAxisymmetricRZFiniteStrain"},
         {{Moose::COORD_RSPHERICAL, StrainAndIncrement::SmallTotal}, "ComputeRSphericalSmallStrain"},
         {{Moose::COORD_RSPHERICAL, StrainAndIncrement::SmallIncremental},
          "ComputeRSphericalIncrementalStrain"},
         {{Moose::COORD_RSPHERICAL, StrainAndIncrement::FiniteIncremental},
          "ComputeRSphericalFiniteStrain"}};
 
     auto type_it = type_map.find(std::make_pair(_coord_system, _strain_and_increment));
     if (type_it != type_map.end())
       type = type_it->second;
     else
       mooseError("Unsupported strain formulation");
   }
   else if (_planar_formulation == PlanarFormulation::WeakPlaneStress ||
            _planar_formulation == PlanarFormulation::PlaneStrain ||
            _planar_formulation == PlanarFormulation::GeneralizedPlaneStrain)
   {
     if (_use_ad && (_planar_formulation == PlanarFormulation::PlaneStrain ||
                     _planar_formulation == PlanarFormulation::GeneralizedPlaneStrain))
       paramError("use_automatic_differentiation",
                  "AD not setup for use with PlaneStrain or GeneralizedPlaneStrain");
 
     std::map<std::pair<Moose::CoordinateSystemType, StrainAndIncrement>, std::string> type_map = {
         {{Moose::COORD_XYZ, StrainAndIncrement::SmallTotal}, "ComputePlaneSmallStrain"},
         {{Moose::COORD_XYZ, StrainAndIncrement::SmallIncremental}, "ComputePlaneIncrementalStrain"},
         {{Moose::COORD_XYZ, StrainAndIncrement::FiniteIncremental}, "ComputePlaneFiniteStrain"},
         {{Moose::COORD_RZ, StrainAndIncrement::SmallTotal}, "ComputeAxisymmetric1DSmallStrain"},
         {{Moose::COORD_RZ, StrainAndIncrement::SmallIncremental},
          "ComputeAxisymmetric1DIncrementalStrain"},
         {{Moose::COORD_RZ, StrainAndIncrement::FiniteIncremental},
          "ComputeAxisymmetric1DFiniteStrain"}};
 
     // choose kernel type based on coordinate system
     auto type_it = type_map.find(std::make_pair(_coord_system, _strain_and_increment));
     if (type_it != type_map.end())
       type = type_it->second;
     else
       mooseError("Unsupported coordinate system for plane strain.");
   }
   else
     mooseError("Unsupported planar formulation");
 
   // set material parameters
   auto params = _factory.getValidParams(ad_prepend + type);
   params.applyParameters(
       parameters(),
       {"displacements", "use_displaced_mesh", "out_of_plane_strain", "scalar_out_of_plane_strain"});
 
   if (isParamValid("strain_base_name"))
     params.set<std::string>("base_name") = getParam<std::string>("strain_base_name");
 
   params.set<std::vector<VariableName>>("displacements") = _coupled_displacements;
   params.set<bool>("use_displaced_mesh") = false;
 
   if (isParamValid("scalar_out_of_plane_strain"))
     params.set<std::vector<VariableName>>("scalar_out_of_plane_strain") = {
         getParam<VariableName>("scalar_out_of_plane_strain")};
 
   if (isParamValid("out_of_plane_strain"))
     params.set<std::vector<VariableName>>("out_of_plane_strain") = {
         getParam<VariableName>("out_of_plane_strain")};
 
   params.set<std::vector<MaterialPropertyName>>("eigenstrain_names") = _eigenstrain_names;
 
   _problem->addMaterial(ad_prepend + type, name() + "_strain", params);
 }

◆ actSubdomainChecks()

void QuasiStaticSolidMechanicsPhysics::actSubdomainChecks ( )

protectedinherited

Definition at line 502 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

 {
   // Do the coordinate system check only once the problem is created
   if (_current_task == "setup_mesh_complete")
   {
     // get subdomain IDs
     for (auto & name : _subdomain_names)
     {
       auto id = _mesh->getSubdomainID(name);
       if (id == Moose::INVALID_BLOCK_ID)
         paramError("block", "Subdomain \"" + name + "\" not found in mesh.");
       else
         _subdomain_ids.insert(id);
     }
   }
 
   if (_current_task == "validate_coordinate_systems")
   {
     // use either block restriction list or list of all subdomains in the mesh
     const auto & check_subdomains =
         _subdomain_ids.empty() ? _problem->mesh().meshSubdomains() : _subdomain_ids;
     if (check_subdomains.empty())
       mooseError("No subdomains found");
 
     // make sure all subdomains are using the same coordinate system
     _coord_system = _problem->getCoordSystem(*check_subdomains.begin());
     for (auto subdomain : check_subdomains)
       if (_problem->getCoordSystem(subdomain) != _coord_system)
         mooseError("The SolidMechanics action requires all subdomains to have the same coordinate "
                    "system.");
 
     if (_coord_system == Moose::COORD_RZ)
     {
       if (_out_of_plane_direction != OutOfPlaneDirection::z)
         mooseError("'out_of_plane_direction' must be 'z' for axisymmetric simulations");
     }
     else if (_planar_formulation != PlanarFormulation::None)
     {
       if (_out_of_plane_direction == OutOfPlaneDirection::z && _ndisp != 2)
         mooseError(
             "Must specify two displacements for plane strain when the out of plane direction is z");
       else if (_out_of_plane_direction != OutOfPlaneDirection::z && _ndisp != 3)
         mooseError("Must specify three displacements for plane strain when the out of plane "
                    "direction is x or y");
     }
   }
 }

◆ addCartesianComponentOutput()

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

staticinherited

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

◆ getKernelParameters()

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

protectedvirtualinherited

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1130 of file QuasiStaticSolidMechanicsPhysics.C.

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

 {
   InputParameters params = _factory.getValidParams(type);
   params.applyParameters(
       parameters(),
       {"displacements", "use_displaced_mesh", "save_in", "diag_save_in", "out_of_plane_strain"});
 
   params.set<std::vector<VariableName>>("displacements") = _coupled_displacements;
 
   if (_lagrangian_kernels)
   {
     params.set<bool>("use_displaced_mesh") =
         (_lk_large_kinematics && (_lk_formulation == LKFormulation::Updated));
     params.set<bool>("large_kinematics") = _lk_large_kinematics;
     params.set<bool>("stabilize_strain") = _lk_locking;
   }
   else
     params.set<bool>("use_displaced_mesh") = _use_displaced_mesh;
 
   return params;
 }

◆ getKernelType()

std::string QuasiStaticSolidMechanicsPhysics::getKernelType ( )

protectedvirtualinherited

Reimplemented in DynamicSolidMechanicsPhysics.

Definition at line 1071 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::act().

 {
   if (_lagrangian_kernels)
   {
     std::string type;
     if (_coord_system == Moose::COORD_XYZ)
     {
       if (_lk_homogenization)
         type = "HomogenizedTotalLagrangianStressDivergence";
       else if (_lk_formulation == LKFormulation::Total)
         type = "TotalLagrangianStressDivergence";
       else if (_lk_formulation == LKFormulation::Updated)
         type = "UpdatedLagrangianStressDivergence";
       else
         mooseError("Unknown formulation type");
     }
     else if (_coord_system == Moose::COORD_RZ)
     {
       if (_lk_homogenization)
         mooseError("The Lagrangian mechanics kernels do not yet support homogenization in "
                    "coordinate systems other than Cartesian.");
       else if (_lk_formulation == LKFormulation::Total)
         type = "TotalLagrangianStressDivergenceAxisymmetricCylindrical";
       else if (_lk_formulation == LKFormulation::Updated)
         mooseError("The Lagrangian mechanics kernels do not yet support the updated Lagrangian "
                    "formulation in RZ coordinates.");
     }
     else if (_coord_system == Moose::COORD_RSPHERICAL)
     {
       if (_lk_homogenization)
         mooseError("The Lagrangian mechanics kernels do not yet support homogenization in "
                    "coordinate systems other than Cartesian.");
       else if (_lk_formulation == LKFormulation::Total)
         type = "TotalLagrangianStressDivergenceCentrosymmetricSpherical";
       else if (_lk_formulation == LKFormulation::Updated)
         mooseError("The Lagrangian mechanics kernels do not yet support the updated Lagrangian "
                    "formulation in RZ coordinates.");
     }
     else
       mooseError("Unsupported coordinate system");
     return type;
   }
   else
   {
     std::map<Moose::CoordinateSystemType, std::string> type_map = {
         {Moose::COORD_XYZ, "StressDivergenceTensors"},
         {Moose::COORD_RZ, "StressDivergenceRZTensors"},
         {Moose::COORD_RSPHERICAL, "StressDivergenceRSphericalTensors"}};
 
     // choose kernel type based on coordinate system
     auto type_it = type_map.find(_coord_system);
     if (type_it != type_map.end())
       return type_it->second;
     else
       mooseError("Unsupported coordinate system");
   }
 }

◆ materialOutputFamilies()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies ( )

staticinherited

Definition at line 299 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

 {
   return MultiMooseEnum("MONOMIAL LAGRANGE");
 }

◆ materialOutputOrders()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders ( )

staticinherited

Definition at line 291 of file QuasiStaticSolidMechanicsPhysicsBase.C.

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

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

◆ outputPropertiesType()

MultiMooseEnum QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType ( )

staticinherited

Definition at line 305 of file QuasiStaticSolidMechanicsPhysicsBase.C.

Referenced by QuasiStaticSolidMechanicsPhysicsBase::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);
 }

◆ setupOutput()

template<typename T , typename T2 >

bool QuasiStaticSolidMechanicsPhysics::setupOutput	(	std::string	out,
		T	table,
		T2	setup
	)

protectedinherited

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

Definition at line 173 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::actOutputMatProp().

 {
   for (const auto & t1 : table)
   {
     // find the officially supported properties
     for (const auto & t2 : t1.second.second)
       if (t1.first + '_' + t2 == out)
       {
         const auto it = _rank_two_cartesian_component_table.find(t2);
         if (it != _rank_two_cartesian_component_table.end())
         {
           setup(it->second, t1.second.first);
           return true;
         }
         else
           mooseError("Internal error. The permitted tensor shortcuts must be keys in the "
                      "'_rank_two_cartesian_component_table'.");
       }
 
     // check for custom properties
     auto prefix = t1.first + '_';
     if (out.substr(0, prefix.length()) == prefix)
     {
       setup(out.substr(prefix.length()), t1.second.first);
       return true;
     }
   }
 
   return false;
 }

◆ validParams()

InputParameters PoroMechanicsAction::validParams ( )

static

Definition at line 24 of file PoroMechanicsAction.C.

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

◆ verifyOrderAndFamilyOutputs()

void QuasiStaticSolidMechanicsPhysics::verifyOrderAndFamilyOutputs ( )

protectedinherited

Definition at line 749 of file QuasiStaticSolidMechanicsPhysics.C.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

 {
   // Ensure material output order and family vectors are same size as generate output
 
   // check number of supplied orders and families
   if (_material_output_order.size() > 1 && _material_output_order.size() < _generate_output.size())
     paramError("material_output_order",
                "The number of orders assigned to material outputs must be: 0 to be assigned "
                "CONSTANT; 1 to assign all outputs the same value, or the same size as the number "
                "of generate outputs listed.");
 
   if (_material_output_family.size() > 1 &&
       _material_output_family.size() < _generate_output.size())
     paramError("material_output_family",
                "The number of families assigned to material outputs must be: 0 to be assigned "
                "MONOMIAL; 1 to assign all outputs the same value, or the same size as the number "
                "of generate outputs listed.");
 
   // if no value was provided, chose the default CONSTANT
   if (_material_output_order.size() == 0)
     _material_output_order.setAdditionalValue("CONSTANT");
 
   // For only one order, make all orders the same magnitude
   if (_material_output_order.size() == 1)
     _material_output_order =
         std::vector<std::string>(_generate_output.size(), _material_output_order[0]);
 
   if (_verbose)
     Moose::out << COLOR_CYAN << "*** Automatic applied material output orders ***"
                << "\n"
                << _name << ": " << Moose::stringify(_material_output_order) << "\n"
                << COLOR_DEFAULT << std::flush;
 
   // if no value was provided, chose the default MONOMIAL
   if (_material_output_family.size() == 0)
     _material_output_family.setAdditionalValue("MONOMIAL");
 
   // For only one family, make all families that value
   if (_material_output_family.size() == 1)
     _material_output_family =
         std::vector<std::string>(_generate_output.size(), _material_output_family[0]);
 
   if (_verbose)
     Moose::out << COLOR_CYAN << "*** Automatic applied material output families ***"
                << "\n"
                << _name << ": " << Moose::stringify(_material_output_family) << "\n"
                << COLOR_DEFAULT << std::flush;
 }

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

table data for output generation

Definition at line 27 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _constraint_types

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_constraint_types

protectedinherited

Definition at line 167 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _coord_system

Moose::CoordinateSystemType QuasiStaticSolidMechanicsPhysics::_coord_system

protectedinherited

Definition at line 60 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _coupled_displacements

std::vector<VariableName> QuasiStaticSolidMechanicsPhysics::_coupled_displacements

protectedinherited

Coupled displacement variables.

Definition at line 52 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _cylindrical_axis_point1

Point QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point1

protectedinherited

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

Definition at line 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

Definition at line 124 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _cylindrical_axis_point2_valid

bool QuasiStaticSolidMechanicsPhysics::_cylindrical_axis_point2_valid

protectedinherited

Definition at line 118 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _diag_save_in

std::vector<AuxVariableName> QuasiStaticSolidMechanicsPhysics::_diag_save_in

protectedinherited

Definition at line 57 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _direction

Point QuasiStaticSolidMechanicsPhysics::_direction

protectedinherited

Definition at line 125 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _direction_valid

bool QuasiStaticSolidMechanicsPhysics::_direction_valid

protectedinherited

Definition at line 119 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::QuasiStaticSolidMechanicsPhysics().

◆ _displacements

std::vector<VariableName> QuasiStaticSolidMechanicsPhysics::_displacements

protectedinherited

displacement variables

Definition at line 46 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _eigenstrain_names

std::vector<MaterialPropertyName> QuasiStaticSolidMechanicsPhysics::_eigenstrain_names

protectedinherited

Definition at line 136 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _generate_output

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

protectedinherited

output materials to generate scalar stress/strain tensor quantities

Definition at line 112 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _hname

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

protectedinherited

Definition at line 161 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _homogenization_strain_name

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

protectedinherited

Definition at line 165 of file QuasiStaticSolidMechanicsPhysics.h.

Referenced by QuasiStaticSolidMechanicsPhysics::actLagrangianKernelStrain().

◆ _integrator_name

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

protectedinherited

Definition at line 163 of file QuasiStaticSolidMechanicsPhysics.h.

◆ _lagrangian_kernels

const bool QuasiStaticSolidMechanicsPhysics::_lagrangian_kernels

protectedinherited

New or old kernel system.

Definition at line 139 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_formulation

const LKFormulation QuasiStaticSolidMechanicsPhysics::_lk_formulation

protectedinherited

Definition at line 150 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_homogenization

bool QuasiStaticSolidMechanicsPhysics::_lk_homogenization

protectedinherited

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

Definition at line 156 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _lk_large_kinematics

const bool QuasiStaticSolidMechanicsPhysics::_lk_large_kinematics

protectedinherited

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

Definition at line 142 of file QuasiStaticSolidMechanicsPhysics.h.

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

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

Definition at line 114 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _material_output_order

MultiMooseEnum QuasiStaticSolidMechanicsPhysics::_material_output_order

protectedinherited

Definition at line 113 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _ndisp

unsigned int QuasiStaticSolidMechanicsPhysics::_ndisp

protectedinherited

Number of displacement variables.

Definition at line 49 of file QuasiStaticSolidMechanicsPhysics.h.

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

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

Definition at line 103 of file QuasiStaticSolidMechanicsPhysics.h.

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

◆ _planar_formulation

enum QuasiStaticSolidMechanicsPhysics::PlanarFormulation QuasiStaticSolidMechanicsPhysics::_planar_formulation

protectedinherited

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

◆ _rank_two_cartesian_component_table

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

staticprotectedinherited

Initial value:

= {
        {"strain", "total_strain"},
        {"mechanical_strain", "mechanical_strain"},
        {"stress", "stress"},
        {"cauchy_stress", "cauchy_stress"},
        {"deformation_gradient", "deformation_gradient"},
        {"pk1_stress", "pk1_stress"},
        {"pk2_stress", "pk2_stress"},
        {"small_stress", "small_stress"},
        {"elastic_strain", "elastic_strain"},
        {"plastic_strain", "plastic_strain"},
        {"creep_strain", "creep_strain"},
        {"creep_stress", "creep_stress"}}

Definition at line 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

Definition at line 29 of file QuasiStaticSolidMechanicsPhysicsBase.h.

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

◆ _rank_two_spherical_component_table

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

staticinherited

Initial value:

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