Store common tensor mechanics parameters. More...

#include <CommonSolidMechanicsAction.h>

Inheritance diagram for CommonSolidMechanicsAction:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	CommonSolidMechanicsAction (const InputParameters &parameters)

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) 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 void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

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

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

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

Private Member Functions
bool	addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)

virtual std::string	meshPropertyPrefix (const std::string &data_name) const

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

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

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
const ParallelParamObject &	_parent

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

Detailed Description

Store common tensor mechanics parameters.

Definition at line 17 of file CommonSolidMechanicsAction.h.

Constructor & Destructor Documentation

◆ CommonSolidMechanicsAction()

CommonSolidMechanicsAction::CommonSolidMechanicsAction ( const InputParameters & parameters )

Definition at line 28 of file CommonSolidMechanicsAction.C.

  : Action(parameters)
{
}

Member Function Documentation

◆ act()

void CommonSolidMechanicsAction::act ( )

overridevirtual

Implements Action.

Definition at line 34 of file CommonSolidMechanicsAction.C.

{
 
  // check if sub-blocks block are found which will use the common parameters
  auto actions = _awh.getActions<QuasiStaticSolidMechanicsPhysicsBase>();
  if (actions.size() == 0)
    mooseWarning("Common parameters are supplied, but not used in ", parameters().blockLocation());
 
  // Add disp-variables
  if (_current_task == "add_variable")
  {
    // We set these variables first with the "common" (not nested) level parameters
    bool do_add_variables = getParam<bool>("add_variables");
    auto displacement_variables = getParam<std::vector<VariableName>>("displacements");
    bool add_variables_block_restricted = true;
    std::set<SubdomainName> add_variables_blocks;
    bool scaling_set = isParamValid("scaling");
    Real scaling_value = (scaling_set) ? getParam<Real>("scaling") : 1.0;
 
    // Check all nested sub-actions and update the variables keeping track of each selection
    for (const auto & action : actions)
    {
      if (action->getParam<bool>("add_variables"))
      {
        // this sub-action wants the disp-variables added.
        do_add_variables = true;
        const auto v = action->getParam<std::vector<VariableName>>("displacements");
        if (v.size() > 0)
        {
          if (displacement_variables.size() == 0)
            displacement_variables.insert(displacement_variables.end(), v.begin(), v.end());
          else if (displacement_variables != v)
            paramError("displacements",
                       "The vector of displacement variables of the actions differ.");
        }
 
        // with block-restriction?
        if (add_variables_block_restricted && action->isParamValid("block") &&
            action->getParam<std::vector<SubdomainName>>("block").size())
        {
          auto action_blocks = action->getParam<std::vector<SubdomainName>>("block");
          mooseAssert(action_blocks.size(), "Block restriction must not be empty");
          add_variables_blocks.insert(action_blocks.cbegin(), action_blocks.cend());
        }
        else
          add_variables_block_restricted = false;
 
        // scaling?
        if (action->getParam<bool>("add_variables") && action->isParamValid("scaling"))
        {
          const auto scaling = action->getParam<Real>("scaling");
 
          // sanity-check
          if (scaling_set && scaling_value != scaling)
            paramError("scaling", "The scaling parameter of the actions differ.");
 
          // set local scaling variables
          scaling_set = true;
          scaling_value = scaling;
        }
      }
    }
 
    // add the disp-variables, if desired
    if (do_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";
      if (add_variables_block_restricted && add_variables_blocks.size() > 0)
      {
        std::vector<SubdomainName> blks(add_variables_blocks.begin(), add_variables_blocks.end());
        params.set<std::vector<SubdomainName>>("block") = blks;
      }
      if (scaling_set && scaling_value != 1)
        params.set<std::vector<Real>>("scaling") = {scaling_value};
 
      // Loop through the displacement variables
      const auto n = displacement_variables.size();
      if (n == 0)
        paramError("displacements", "The vector of displacement variables is not set.");
      if (n != _problem->mesh().dimension())
        paramError("displacements",
                   "The number of displacement variables differs from the number of dimensions of "
                   "the mesh.");
 
      for (const auto & disp : displacement_variables)
        // Create displacement variables
        _problem->addVariable("MooseVariable", disp, params);
    }
  }
}

◆ validParams()

InputParameters CommonSolidMechanicsAction::validParams ( )

static

Definition at line 21 of file CommonSolidMechanicsAction.C.

{
  InputParameters params = QuasiStaticSolidMechanicsPhysicsBase::validParams();
  params.addClassDescription("Store common solid mechanics parameters");
  return params;
}

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

solid_mechanics/include/actions/CommonSolidMechanicsAction.h
solid_mechanics/src/actions/CommonSolidMechanicsAction.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions