https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
GlobalStrainAction Class Reference

#include <GlobalStrainAction.h>

Inheritance diagram for GlobalStrainAction:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 GlobalStrainAction (const InputParameters &params)
 
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)
 
MooseAppgetMooseApp () const
 
const std::string & type () const
 
virtual const std::string & name () const
 
std::string typeAndName () const
 
std::string errorPrefix (const std::string &error_type) const
 
void callMooseError (std::string msg, const bool with_prefix) const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
const InputParametersparameters () const
 
MooseObjectName uniqueName () const
 
const T & getParam (const std::string &name) const
 
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 
const T * queryParam (const std::string &name) const
 
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 
getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 
bool isParamValid (const std::string &name) const
 
bool isParamSetByUser (const std::string &nm) const
 
void paramError (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramInfo (const std::string &param, Args... args) const
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void mooseError (Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseInfo (Args &&... args) const
 
std::string getDataFileName (const std::string &param) const
 
std::string getDataFileNameByName (const std::string &relative_path) const
 
std::string getDataFilePath (const std::string &relative_path) const
 
PerfGraphperfGraph ()
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static InputParameters validParams ()
 

Public Attributes

const ConsoleStream _console
 

Static Public Attributes

static constexpr auto SYSTEM
 
static constexpr auto NAME
 

Protected Member Functions

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

std::vector< VariableName > _disp
 
std::vector< AuxVariableName > _aux_disp
 
std::vector< AuxVariableName > _global_disp
 
std::vector< SubdomainName > _block_names
 
std::set< SubdomainID_block_ids
 
std::string _registered_identifier
 
std::string _specific_task_name
 
std::set< std::string > _all_tasks
 
ActionWarehouse_awh
 
const std::string & _current_task
 
std::shared_ptr< MooseMesh > & _mesh
 
std::shared_ptr< MooseMesh > & _displaced_mesh
 
std::shared_ptr< FEProblemBase > & _problem
 
PerfID _act_timer
 
MooseApp_app
 
const std::string _type
 
const std::string _name
 
const InputParameters_pars
 
Factory_factory
 
ActionFactory_action_factory
 
MooseApp_pg_moose_app
 
const std::string _prefix
 
const Parallel::Communicator & _communicator
 

Detailed Description

Definition at line 14 of file GlobalStrainAction.h.

Constructor & Destructor Documentation

◆ GlobalStrainAction()

GlobalStrainAction::GlobalStrainAction ( const InputParameters params)

Definition at line 53 of file GlobalStrainAction.C.

54  : Action(params),
55  _disp(getParam<std::vector<VariableName>>("displacements")),
56  _aux_disp(getParam<std::vector<AuxVariableName>>("auxiliary_displacements")),
57  _global_disp(getParam<std::vector<AuxVariableName>>("global_displacements")),
58  _block_names(getParam<std::vector<SubdomainName>>("block")),
59  _block_ids()
60 {
61  if (_aux_disp.size() != _disp.size())
62  mooseError("Number of auxiliary displacement variables should be equal to the number of "
63  "nonlinear displacement variables, i.e., ",
64  _disp.size());
65 }
std::vector< AuxVariableName > _aux_disp
std::vector< VariableName > _disp
Action(const InputParameters &parameters)
std::vector< SubdomainName > _block_names
std::set< SubdomainID > _block_ids
const T & getParam(const std::string &name) const
void mooseError(Args &&... args) const
std::vector< AuxVariableName > _global_disp

Member Function Documentation

◆ act()

void GlobalStrainAction::act ( )
overridevirtual

Implements Action.

Definition at line 68 of file GlobalStrainAction.C.

69 {
70  // get subdomain IDs
71  for (auto & name : _block_names)
72  _block_ids.insert(_problem->mesh().getSubdomainID(name));
73 
74  // user object name
75  const std::string uo_name = _name + "_GlobalStrainUserObject";
76 
77  //
78  // Add user object
79  //
80  if (_current_task == "add_user_object")
81  {
82  std::string uo_type = "GlobalStrainUserObject";
83  InputParameters params = _factory.getValidParams(uo_type);
84  params.applyParameters(parameters());
85  params.set<bool>("use_displaced_mesh") = false;
86  params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR, EXEC_NONLINEAR};
87 
88  _problem->addUserObject(uo_type, uo_name, params);
89  }
90 
91  //
92  // Add scalar kernel
93  //
94  else if (_current_task == "add_scalar_kernel")
95  {
96  std::string sk_type = "GlobalStrain";
97  InputParameters params = _factory.getValidParams(sk_type);
98  params.applyParameters(parameters());
99  params.set<bool>("use_displaced_mesh") = false;
100  params.set<NonlinearVariableName>("variable") = getParam<VariableName>("scalar_global_strain");
101  params.set<UserObjectName>("global_strain_uo") = uo_name;
102 
103  _problem->addScalarKernel(sk_type, _name + "_GlobalStrain", params);
104  }
105 
106  //
107  // Add ComputeGlobalStrain material
108  //
109  else if (_current_task == "add_material")
110  {
111  std::string mat_type = "ComputeGlobalStrain";
112  InputParameters params = _factory.getValidParams(mat_type);
113  params.applyParameters(parameters(), {"scalar_global_strain"});
114  params.set<bool>("use_displaced_mesh") = false;
115  params.set<std::vector<VariableName>>("scalar_global_strain") = {
116  getParam<VariableName>("scalar_global_strain")};
117  params.set<UserObjectName>("global_strain_uo") = uo_name;
118 
119  _problem->addMaterial(mat_type, _name + "_global_strain", params);
120  }
121 
122  //
123  // Add auxiliary displacement variables
124  //
125  else if (_current_task == "add_aux_variable")
126  {
127  auto params = _factory.getValidParams("MooseVariable");
128  // determine necessary order
129  const bool second = _problem->mesh().hasSecondOrderElements();
130 
131  params.set<MooseEnum>("order") = second ? "SECOND" : "FIRST";
132  params.set<MooseEnum>("family") = "LAGRANGE";
133 
134  for (unsigned int i = 0; i < _aux_disp.size(); ++i)
135  {
136  std::string aux_var_name = _aux_disp[i];
137 
138  _problem->addAuxVariable("MooseVariable", aux_var_name, params);
139  }
140 
141  for (unsigned int i = 0; i < _global_disp.size(); ++i)
142  {
143  std::string aux_var_name = _global_disp[i];
144 
145  _problem->addAuxVariable("MooseVariable", aux_var_name, params);
146  }
147  }
148 
149  //
150  // Add aux kernels for computing global displacements
151  //
152  else if (_current_task == "add_aux_kernel")
153  {
154  for (unsigned int i = 0; i < _aux_disp.size(); ++i)
155  {
156  std::string aux_var_name = _aux_disp[i];
157 
158  std::string aux_type = "GlobalDisplacementAux";
159  InputParameters params = _factory.getValidParams(aux_type);
160  params.applyParameters(parameters(), {"scalar_global_strain"});
161  params.set<AuxVariableName>("variable") = aux_var_name;
162  params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
163  params.set<bool>("use_displaced_mesh") = false;
164  params.set<bool>("output_global_displacement") = false;
165  params.set<std::vector<VariableName>>("scalar_global_strain") = {
166  getParam<VariableName>("scalar_global_strain")};
167  params.set<UserObjectName>("global_strain_uo") = uo_name;
168  params.set<unsigned int>("component") = i;
169 
170  _problem->addAuxKernel(aux_type, aux_var_name + '_' + name(), params);
171  }
172 
173  for (unsigned int i = 0; i < _global_disp.size(); ++i)
174  {
175  std::string aux_var_name = _global_disp[i];
176 
177  std::string aux_type = "GlobalDisplacementAux";
178  InputParameters params = _factory.getValidParams(aux_type);
179  params.applyParameters(parameters(), {"scalar_global_strain"});
180  params.set<AuxVariableName>("variable") = aux_var_name;
181  params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
182  params.set<bool>("use_displaced_mesh") = false;
183  params.set<bool>("output_global_displacement") = true;
184  params.set<std::vector<VariableName>>("scalar_global_strain") = {
185  getParam<VariableName>("scalar_global_strain")};
186  params.set<UserObjectName>("global_strain_uo") = uo_name;
187  params.set<unsigned int>("component") = i;
188 
189  _problem->addAuxKernel(aux_type, aux_var_name + '_' + name(), params);
190  }
191  }
192 }
std::vector< AuxVariableName > _aux_disp
T & set(const std::string &name, bool quiet_mode=false)
InputParameters getValidParams(const std::string &name) const
void applyParameters(const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
virtual const std::string & name() const
Factory & _factory
std::vector< SubdomainName > _block_names
std::set< SubdomainID > _block_ids
const std::string & _current_task
const ExecFlagType EXEC_LINEAR
const std::string _name
const ExecFlagType EXEC_NONLINEAR
std::shared_ptr< FEProblemBase > & _problem
const InputParameters & parameters() const
std::vector< AuxVariableName > _global_disp
const ExecFlagType EXEC_INITIAL

◆ validParams()

InputParameters GlobalStrainAction::validParams ( )
static

Definition at line 30 of file GlobalStrainAction.C.

31 {
33  params.addClassDescription("Set up the GlobalStrainAction environment");
34  params.addRequiredParam<VariableName>("scalar_global_strain",
35  "Scalar variable for global strain");
36  params.addParam<std::vector<VariableName>>("displacements", {}, "The displacement variables");
37  params.addParam<std::vector<AuxVariableName>>(
38  "auxiliary_displacements",
39  "The auxliary displacement variables to be calculated from scalar variables");
40  params.addParam<std::vector<AuxVariableName>>(
41  "global_displacements",
42  "The global displacement variables to be calculated from scalar variables");
43  params.addParam<std::vector<Real>>("applied_stress_tensor",
44  "Vector of values defining the constant applied stress "
45  "to add, in order 11, 22, 33, 23, 13, 12");
46  params.addParam<std::string>("base_name", "Material property base name");
47  params.addParam<std::vector<SubdomainName>>(
48  "block", {}, "The block id where this variable lives");
49 
50  return params;
51 }
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
void addRequiredParam(const std::string &name, const std::string &doc_string)
static InputParameters validParams()
void addClassDescription(const std::string &doc_string)

Member Data Documentation

◆ _aux_disp

std::vector<AuxVariableName> GlobalStrainAction::_aux_disp
protected

Definition at line 25 of file GlobalStrainAction.h.

Referenced by act(), and GlobalStrainAction().

◆ _block_ids

std::set<SubdomainID> GlobalStrainAction::_block_ids
protected

Definition at line 29 of file GlobalStrainAction.h.

Referenced by act().

◆ _block_names

std::vector<SubdomainName> GlobalStrainAction::_block_names
protected

Definition at line 28 of file GlobalStrainAction.h.

Referenced by act().

◆ _disp

std::vector<VariableName> GlobalStrainAction::_disp
protected

Definition at line 24 of file GlobalStrainAction.h.

Referenced by GlobalStrainAction().

◆ _global_disp

std::vector<AuxVariableName> GlobalStrainAction::_global_disp
protected

Definition at line 26 of file GlobalStrainAction.h.

Referenced by act().


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