#include <DynamicSolidMechanicsPhysics.h>

Inheritance diagram for DynamicSolidMechanicsPhysics:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	DynamicSolidMechanicsPhysics (const InputParameters &params)

virtual void	act () override

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	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	mooseWarning (Args &&... args) const

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

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

void	mooseDeprecated (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
	usingCombinedWarningSolutionWarnings

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
virtual std::string	getKernelType () override

virtual InputParameters	getKernelParameters (std::string type) override

void	actSubdomainChecks ()

void	actOutputGeneration ()

void	actEigenstrainNames ()

void	actOutputMatProp ()

void	actGatherActionParameters ()

void	verifyOrderAndFamilyOutputs ()

void	actLagrangianKernelStrain ()

void	actStressDivergenceTensorsStrain ()

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

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::vector< AuxVariableName >	_velocities

std::vector< AuxVariableName >	_accelerations

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

◆ DynamicSolidMechanicsPhysics()

DynamicSolidMechanicsPhysics::DynamicSolidMechanicsPhysics ( const InputParameters & params )

Definition at line 81 of file DynamicSolidMechanicsPhysics.C.

   : QuasiStaticSolidMechanicsPhysics(params),
     _velocities(getParam<std::vector<AuxVariableName>>("velocities")),
     _accelerations(getParam<std::vector<AuxVariableName>>("accelerations"))
 {
 }

Member Function Documentation

◆ act()

void DynamicSolidMechanicsPhysics::act ( )

overridevirtual

Reimplemented from QuasiStaticSolidMechanicsPhysics.

Reimplemented in LegacyDynamicTensorMechanicsAction.

Definition at line 89 of file DynamicSolidMechanicsPhysics.C.

 {
   const std::array<std::string, 3> dir{{"x", "y", "z"}};
 
   if (_velocities.size() < _ndisp)
     paramError("velocities", "Supply one velocity variable per displacement direction");
   if (_accelerations.size() < _ndisp)
     paramError("accelerations", "Supply one acceleration variable per displacement direction");
 
   // Add aux variables for velocities and accelerations
   if (_current_task == "add_aux_variable" && getParam<bool>("add_variables"))
   {
     auto params = _factory.getValidParams("MooseVariable");
     // determine necessary order
     const bool second = _problem->mesh().hasSecondOrderElements();
 
     params.set<MooseEnum>("order") = second ? "SECOND" : "FIRST";
     params.set<MooseEnum>("family") = "LAGRANGE";
 
     for (unsigned int i = 0; i < _ndisp; ++i)
     {
       _problem->addAuxVariable("MooseVariable", _velocities[i], params);
       _problem->addAuxVariable("MooseVariable", _accelerations[i], params);
     }
   }
 
   // Add aux kernel for velocities and accelerations
   if (_current_task == "add_aux_kernel")
   {
     //
     // Note: AuxKernels that are limited to TIMESTEP_END to not get their dependencies
     // resolved automatically. Thus we _must_ construct the acceleration kernels _first_.
     // NewmarkAccelAux only uses the old velocity.
     //
 
     // acceleration aux kernels
     for (unsigned int i = 0; i < _ndisp; ++i)
     {
       auto kernel_type = "NewmarkAccelAux";
       auto params = _factory.getValidParams(kernel_type);
       params.set<AuxVariableName>("variable") = _accelerations[i];
       params.set<std::vector<VariableName>>("displacement") = {_displacements[i]};
       params.set<std::vector<VariableName>>("velocity") = {_velocities[i]};
       params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
       params.set<Real>("beta") = getParam<Real>("newmark_beta");
       params.applyParameters(parameters());
       _problem->addAuxKernel(kernel_type, "TM_" + name() + '_' + _accelerations[i], params);
     }
 
     // velocity aux kernels
     for (unsigned int i = 0; i < _ndisp; ++i)
     {
       auto kernel_type = "NewmarkVelAux";
       auto params = _factory.getValidParams(kernel_type);
       params.set<AuxVariableName>("variable") = _velocities[i];
       params.set<std::vector<VariableName>>("acceleration") = {_accelerations[i]};
       params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
       params.set<Real>("gamma") = getParam<Real>("newmark_gamma");
       params.applyParameters(parameters());
       _problem->addAuxKernel(kernel_type, "TM_" + name() + '_' + _velocities[i], params);
     }
   }
 
   // add inertia kernel
   if (_current_task == "add_kernel")
   {
     for (unsigned int i = 0; i < _ndisp; ++i)
     {
       auto kernel_type = _use_ad ? "ADInertialForce" : "InertialForce";
       auto params = _factory.getValidParams(kernel_type);
 
       params.set<NonlinearVariableName>("variable") = _displacements[i];
       params.set<std::vector<VariableName>>("velocity") = {_velocities[i]};
       params.set<std::vector<VariableName>>("acceleration") = {_accelerations[i]};
       params.set<bool>("use_displaced_mesh") = false;
       params.set<Real>("beta") = getParam<Real>("newmark_beta");
       params.set<Real>("gamma") = getParam<Real>("newmark_gamma");
       params.set<Real>("alpha") = getParam<Real>("hht_alpha");
       params.set<MaterialPropertyName>("eta") =
           getParam<MaterialPropertyName>("mass_damping_coefficient");
 
       params.applyParameters(parameters());
 
       _problem->addKernel(kernel_type, "TM_" + name() + "_inertia_" + dir[i], params);
     }
   }
 
   // call parent class method
   QuasiStaticSolidMechanicsPhysics::act();
 }

◆ 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 DynamicSolidMechanicsPhysics::getKernelParameters ( std::string type )

overrideprotectedvirtual

Reimplemented from QuasiStaticSolidMechanicsPhysics.

Definition at line 191 of file DynamicSolidMechanicsPhysics.C.

 {
   InputParameters params = QuasiStaticSolidMechanicsPhysics::getKernelParameters(type);
 
   if (params.isParamDefined("alpha"))
     params.set<Real>("alpha") = getParam<Real>("hht_alpha");
   if (params.isParamDefined("zeta"))
     params.set<MaterialPropertyName>("zeta") =
         getParam<MaterialPropertyName>("stiffness_damping_coefficient");
 
   return params;
 }

◆ getKernelType()

std::string DynamicSolidMechanicsPhysics::getKernelType ( )

overrideprotectedvirtual

Reimplemented from QuasiStaticSolidMechanicsPhysics.

Definition at line 181 of file DynamicSolidMechanicsPhysics.C.

 {
   // choose kernel type based on coordinate system
   if (_coord_system == Moose::COORD_XYZ)
     return "DynamicStressDivergenceTensors";
   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 DynamicSolidMechanicsPhysics::validParams ( )

static

Definition at line 38 of file DynamicSolidMechanicsPhysics.C.

Referenced by LegacyDynamicTensorMechanicsAction::validParams().

 {
   InputParameters params = QuasiStaticSolidMechanicsPhysics::validParams();
   params.addClassDescription("Set up dynamic stress divergence kernels");
   params.addParam<bool>("static_initialization",
                         false,
                         "Set to true get the system to "
                         "equilibrium under gravity by running a "
                         "quasi-static analysis (by solving Ku = F) "
                         "in the first time step.");
 
   params.addParam<std::vector<AuxVariableName>>(
       "velocities",
       std::vector<AuxVariableName>({"vel_x", "vel_y", "vel_z"}),
       "Names of the velocity variables");
   params.addParam<std::vector<AuxVariableName>>(
       "accelerations",
       std::vector<AuxVariableName>({"accel_x", "accel_y", "accel_z"}),
       "Names of the acceleration variables");
   params.addParamNamesToGroup("velocities accelerations", "Variables");
 
   params.addParam<Real>("hht_alpha",
                         0,
                         "alpha parameter for mass dependent numerical damping induced "
                         "by HHT time integration scheme");
   params.addParam<Real>("newmark_beta", 0.25, "beta parameter for Newmark Time integration");
   params.addParam<Real>("newmark_gamma", 0.5, "gamma parameter for Newmark Time integration");
   params.addParam<MaterialPropertyName>("mass_damping_coefficient",
                                         0.0,
                                         "Name of material property or a constant real "
                                         "number defining mass Rayleigh parameter (eta).");
   params.addParam<MaterialPropertyName>("stiffness_damping_coefficient",
                                         0.0,
                                         "Name of material property or a constant real "
                                         "number defining stiffness Rayleigh parameter (zeta).");
   params.addParam<MaterialPropertyName>(
       "density", "density", "Name of Material Property that provides the density");
   params.addParamNamesToGroup("hht_alpha newmark_beta newmark_gamma",
                               "Time integration parameters");
 
   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

◆ _accelerations

std::vector<AuxVariableName> DynamicSolidMechanicsPhysics::_accelerations

protected

Definition at line 28 of file DynamicSolidMechanicsPhysics.h.

Referenced by act().

◆ _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(), 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 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 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"}}}}