MechanicsActionPD Class Reference

Action class to setup peridynamic models for solid mechanics problems. More...

#include <MechanicsActionPD.h>

Inheritance diagram for MechanicsActionPD:

Public Member Functions
	MechanicsActionPD (const InputParameters &params)
virtual void	act () override

Protected Member Functions
virtual std::string	getKernelName ()
	Function to get the kernel name based on the value of member variables: _formulation and _stabilization. More...
virtual InputParameters	getKernelParameters (std::string name)
	Function to get the input parameters for a given kernel name. More...

Protected Attributes
const MooseEnum	_formulation
	Option of which peridynamic model needs to be setup: BOND, ORDINARY_STATE or NONORDINARY_STATE. More...
const MooseEnum	_stabilization
	Option of stabilization scheme for correspondence material model (non-ordinary state based): FORCE or SELF. More...
const MooseEnum	_strain
	Option of strain formulation: SMALL or FINITE. More...
std::vector< SubdomainName >	_subdomain_names
	vector of subdomain names from provided blocks More...
std::set< SubdomainID >	_subdomain_ids
	set of subdomain IDs generated from the passed in vector of subdomain names More...
std::set< SubdomainID >	_subdomain_id_union
	set of SubdomainID generated from the combined block restrictions of all TensorMechanics/Master action blocks More...
std::vector< VariableName >	_displacements
	Displacement variables. More...
const unsigned int	_ndisp
std::vector< AuxVariableName >	_save_in
	Residual debugging. More...
std::vector< AuxVariableName >	_diag_save_in

Detailed Description

Action class to setup peridynamic models for solid mechanics problems.

Definition at line 22 of file MechanicsActionPD.h.

Constructor & Destructor Documentation

MechanicsActionPD()

MechanicsActionPD::MechanicsActionPD

(

const InputParameters &

params

)

Definition at line 68 of file MechanicsActionPD.C.

  : Action(params),
    _displacements(getParam<std::vector<VariableName>>("displacements")),
    _ndisp(_displacements.size()),
    _formulation(getParam<MooseEnum>("formulation")),
    _stabilization(getParam<MooseEnum>("stabilization")),
    _strain(getParam<MooseEnum>("strain")),
    _subdomain_names(getParam<std::vector<SubdomainName>>("block")),
    _subdomain_ids(),
    _save_in(getParam<std::vector<AuxVariableName>>("save_in")),
    _diag_save_in(getParam<std::vector<AuxVariableName>>("diag_save_in"))
{
  // Consistency check
  if (_save_in.size() != 0 && _save_in.size() != _ndisp)
    mooseError("Number of save_in variables should equal to the number of displacement variables ",
               _ndisp);
 
  if (_diag_save_in.size() != 0 && _diag_save_in.size() != _ndisp)
    mooseError(
        "Number of diag_save_in variables should equal to the number of displacement variables ",
        _ndisp);
}

Member Function Documentation

act()

void MechanicsActionPD::act ( )

overridevirtual

Definition at line 92 of file MechanicsActionPD.C.

{
  if (_current_task == "setup_mesh_complete")
  {
    // get subdomain IDs
    for (auto & name : _subdomain_names)
      _subdomain_ids.insert(_mesh->getSubdomainID(name));
  }
  else if (_current_task == "create_problem_complete")
  {
    // Gather info about all other master actions for adding (aux)variables
    auto actions = _awh.getActions<MechanicsActionPD>();
    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 Peridynamics/Mechanics/Master actions must be "
                   "non-overlapping.");
 
      if (added_size == 0 && actions.size() > 1)
        mooseError(
            "No Peridynamics/Mechanics/Master action can be block unrestricted if more than one "
            "Peridynamics/Mechanics/Master action is specified.");
    }
  }
  else if (_current_task == "add_aux_variable")
  {
    // add the bond_status aux variable to all peridynamic domains
    const std::string var_type = "MooseVariableConstMonomial";
    InputParameters params = _factory.getValidParams(var_type);
    params.set<MooseEnum>("order") = "CONSTANT";
    params.set<MooseEnum>("family") = "MONOMIAL";
 
    if (!_subdomain_id_union.empty())
      for (const SubdomainID & id : _subdomain_id_union)
        params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));
 
    _problem->addAuxVariable(var_type, "bond_status", params);
  }
  else if (_current_task == "add_ic")
  {
    const std::string ic_type = "ConstantIC";
    const std::string ic_name = name() + "bond_status";
 
    InputParameters params = _factory.getValidParams(ic_type);
    params.set<VariableName>("variable") = "bond_status";
    params.set<Real>("value") = 1.0;
 
    // check whether this object is restricted to certain block?
    if (isParamValid("block"))
      params.set<std::vector<SubdomainName>>("block") = _subdomain_names;
 
    _problem->addInitialCondition(ic_type, ic_name, params);
  }
  else if (_current_task == "add_user_object")
  {
    // add ghosting UO
    const std::string uo_type = "GhostElemPD";
    const std::string uo_name = name() + "GhostElemPD";
 
    InputParameters params = _factory.getValidParams(uo_type);
    params.set<bool>("use_displaced_mesh") = (_strain == "FINITE");
 
    _problem->addUserObject(uo_type, uo_name, params);
  }
  else if (_current_task == "add_kernel")
  {
    const std::string kernel_name = getKernelName();
    InputParameters params = getKernelParameters(kernel_name);
 
    for (unsigned int i = 0; i < _ndisp; ++i)
    {
      const std::string kernel_object_name = name() + "Peridynamics_" + Moose::stringify(i);
 
      params.set<unsigned int>("component") = i;
      params.set<NonlinearVariableName>("variable") = _displacements[i];
 
      if (_save_in.size() != 0)
        params.set<std::vector<AuxVariableName>>("save_in") = {_save_in[i]};
      if (_diag_save_in.size() != 0)
        params.set<std::vector<AuxVariableName>>("diag_save_in") = {_diag_save_in[i]};
 
      _problem->addKernel(kernel_name, kernel_object_name, params);
    }
  }
  else
    mooseError("Task error in MechanicsActionPD");
}

getKernelName()

std::string MechanicsActionPD::getKernelName ( )

protectedvirtual

Function to get the kernel name based on the value of member variables: _formulation and _stabilization.

Returns

Kernel name

Definition at line 186 of file MechanicsActionPD.C.

{
  std::string name;
 
  if (_formulation == "BOND")
    name = "MechanicsBPD";
  else if (_formulation == "ORDINARY_STATE")
    name = "MechanicsOSPD";
  else if (_formulation == "NONORDINARY_STATE")
  {
    if (_stabilization == "FORCE")
      name = "ForceStabilizedSmallStrainMechanicsNOSPD";
    else if (_stabilization == "SELF")
    {
      if (_strain == "FINITE")
        name = "FiniteStrainMechanicsNOSPD";
      else
        name = "SmallStrainMechanicsNOSPD";
    }
    else
      paramError("stabilization", "Unknown PD stabilization scheme. Choose from: FORCE SELF");
  }
  else
    paramError(
        "formulation",
        "Unsupported peridynamic formulation. Choose from: BOND ORDINARY_STATE NONORDINARY_STATE");
 
  return name;
}

Referenced by act().

getKernelParameters()

InputParameters MechanicsActionPD::getKernelParameters ( std::string  name )

protectedvirtual

Function to get the input parameters for a given kernel name.

Parameters

name	the name of the kernel

Returns

Parameters for the corresponding kernel

Definition at line 217 of file MechanicsActionPD.C.

{
  InputParameters params = _factory.getValidParams(name);
 
  params.applyParameters(parameters(),
                         {"displacements",
                          "temperature",
                          "out_of_plane_strain",
                          "eigenstrain_names",
                          "use_displaced_mesh",
                          "save_in",
                          "diag_save_in"});
 
  params.set<std::vector<VariableName>>("displacements") = _displacements;
  if (isParamValid("temperature"))
    params.set<std::vector<VariableName>>("temperature") = {getParam<VariableName>("temperature")};
  if (isParamValid("out_of_plane_strain"))
    params.set<std::vector<VariableName>>("out_of_plane_strain") = {
        getParam<VariableName>("out_of_plane_strain")};
 
  // peridynamics modules are formulated based on initial configuration
  params.set<bool>("use_displaced_mesh") = false;
 
  if (_formulation == "NONORDINARY_STATE" && isParamValid("eigenstrain_names"))
  {
    params.set<std::vector<MaterialPropertyName>>("eigenstrain_names") =
        getParam<std::vector<MaterialPropertyName>>("eigenstrain_names");
  }
 
  return params;
}

Referenced by act().

Member Data Documentation

_diag_save_in

std::vector<AuxVariableName> MechanicsActionPD::_diag_save_in

protected

Definition at line 72 of file MechanicsActionPD.h.

Referenced by act(), and MechanicsActionPD().

_displacements

std::vector<VariableName> MechanicsActionPD::_displacements

protected

Displacement variables.

Definition at line 45 of file MechanicsActionPD.h.

Referenced by act(), and getKernelParameters().

_formulation

const MooseEnum MechanicsActionPD::_formulation

protected

Option of which peridynamic model needs to be setup: BOND, ORDINARY_STATE or NONORDINARY_STATE.

Definition at line 51 of file MechanicsActionPD.h.

Referenced by getKernelName(), and getKernelParameters().

_ndisp

const unsigned int MechanicsActionPD::_ndisp

protected

Definition at line 46 of file MechanicsActionPD.h.

Referenced by act(), and MechanicsActionPD().

_save_in

std::vector<AuxVariableName> MechanicsActionPD::_save_in

protected

Residual debugging.

Definition at line 71 of file MechanicsActionPD.h.

Referenced by act(), and MechanicsActionPD().

_stabilization

const MooseEnum MechanicsActionPD::_stabilization

protected

Option of stabilization scheme for correspondence material model (non-ordinary state based): FORCE or SELF.

Definition at line 55 of file MechanicsActionPD.h.

Referenced by getKernelName().

_strain

const MooseEnum MechanicsActionPD::_strain

protected

Option of strain formulation: SMALL or FINITE.

Definition at line 58 of file MechanicsActionPD.h.

Referenced by act(), and getKernelName().

_subdomain_id_union

std::set<SubdomainID> MechanicsActionPD::_subdomain_id_union

protected

set of SubdomainID generated from the combined block restrictions of all TensorMechanics/Master action blocks

Definition at line 68 of file MechanicsActionPD.h.

Referenced by act().

_subdomain_ids

std::set<SubdomainID> MechanicsActionPD::_subdomain_ids

protected

set of subdomain IDs generated from the passed in vector of subdomain names

Definition at line 64 of file MechanicsActionPD.h.

Referenced by act().

_subdomain_names

std::vector<SubdomainName> MechanicsActionPD::_subdomain_names

protected

vector of subdomain names from provided blocks

Definition at line 61 of file MechanicsActionPD.h.

Referenced by act().

---

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

• peridynamics/include/actions/MechanicsActionPD.h
• peridynamics/src/actions/MechanicsActionPD.C