Action class to setup peridynamic generalized plane strain models. More...

#include <GeneralizedPlaneStrainActionPD.h>

Inheritance diagram for GeneralizedPlaneStrainActionPD:

Public Member Functions
	GeneralizedPlaneStrainActionPD (const InputParameters &params)

virtual void	act () override

Protected Attributes
const MooseEnum	_formulation
	Option to choose which peridynamic model to use for generalized plane strain formulation: ordinary state based or non-ordinary state based. More...

VariableName	_scalar_out_of_plane_strain
	Scalar variable for out-of-plane strain variable. More...


std::vector< VariableName >	_displacements
	Displacement variables. More...

const unsigned int	_ndisp

Detailed Description

Action class to setup peridynamic generalized plane strain models.

Definition at line 23 of file GeneralizedPlaneStrainActionPD.h.

Constructor & Destructor Documentation

◆ GeneralizedPlaneStrainActionPD()

GeneralizedPlaneStrainActionPD::GeneralizedPlaneStrainActionPD ( const InputParameters & params )

Definition at line 61 of file GeneralizedPlaneStrainActionPD.C.

   : Action(params),
     _displacements(getParam<std::vector<VariableName>>("displacements")),
     _ndisp(_displacements.size()),
     _formulation(getParam<MooseEnum>("formulation")),
     _scalar_out_of_plane_strain(getParam<VariableName>("scalar_out_of_plane_strain"))
 {
   // Generalized plane strain only applies to two dimensional modeling and simulation
   if (_ndisp != 2)
     mooseError("GeneralizedPlaneStrainPD only works for two dimensional case!");
  
   // Consistency check
   if (_formulation == "NONORDINARY_STATE" && isParamValid("out_of_plane_stress_variable"))
     mooseWarning("Variable out_of_plane_stress_variable will not be used in NONORDINARY_STATE "
                  "formulation option!");
   if (_formulation == "ORDINARY_STATE" && !isParamValid("out_of_plane_stress_variable"))
     mooseError("Variable out_of_plane_stress_variable must be provided for ORDINARY_STATE "
                "formulation option!");
 }

Member Function Documentation

◆ act()

void GeneralizedPlaneStrainActionPD::act ( )

overridevirtual

Definition at line 82 of file GeneralizedPlaneStrainActionPD.C.

 {
   if (_current_task == "add_kernel")
   {
     std::string k_type;
     if (_formulation == "ORDINARY_STATE")
       k_type = "GeneralizedPlaneStrainOffDiagOSPD"; // Based on ordinary state-based model
     else if (_formulation == "NONORDINARY_STATE")
       k_type = "GeneralizedPlaneStrainOffDiagNOSPD"; // Based on bond-associated non-ordinary
                                                      // state-based model
     else
       paramError(
           "formulation",
           "Unsupported peridynamic formulation. Choose from: ORDINARY_STATE or NONORDINARY_STATE");
  
     InputParameters params = _factory.getValidParams(k_type);
  
     params.applyParameters(parameters(),
                            {"displacements", "temperature", "scalar_out_of_plane_strain"});
  
     params.set<std::vector<VariableName>>("displacements") = _displacements;
     params.set<std::vector<VariableName>>("scalar_out_of_plane_strain") = {
         _scalar_out_of_plane_strain};
  
     // Coupling between scalar out-of-plane strain and in-plane displacements
     for (unsigned int i = 0; i < _ndisp; ++i)
     {
       std::string k_name = name() + "_GeneralizedPlaneStrainPDOffDiag_disp_" + Moose::stringify(i);
       params.set<NonlinearVariableName>("variable") = _displacements[i];
  
       _problem->addKernel(k_type, k_name, params);
     }
  
     // Coupling between scalar out-of-plane strain and temperature (only when temperature is a
     // nonlinear variable)
     if (isParamValid("temperature"))
     {
       VariableName temp = getParam<VariableName>("temperature");
       if (_problem->getNonlinearSystemBase().hasVariable(temp))
       {
         params.set<std::vector<VariableName>>("temperature") = {temp};
  
         std::string k_name = name() + "_GeneralizedPlaneStrainPDOffDiag_temp";
         params.set<NonlinearVariableName>("variable") = temp;
  
         if (_formulation == "NONORDINARY_STATE")
           params.set<std::vector<MaterialPropertyName>>("eigenstrain_names") =
               getParam<std::vector<MaterialPropertyName>>("eigenstrain_names");
  
         _problem->addKernel(k_type, k_name, params);
       }
     }
   }
   else if (_current_task == "add_user_object")
   {
     std::string uo_type;
     if (_formulation == "ORDINARY_STATE")
       uo_type = "GeneralizedPlaneStrainUserObjectOSPD";
     else if (_formulation == "NONORDINARY_STATE")
       uo_type = "GeneralizedPlaneStrainUserObjectNOSPD";
     else
       paramError(
           "formulation",
           "Unsupported peridynamic formulation. Choose from: ORDINARY_STATE or NONORDINARY_STATE");
  
     InputParameters params = _factory.getValidParams(uo_type);
  
     std::string uo_name = name() + "_GeneralizedPlaneStrainPDUserObject";
  
     params.applyParameters(parameters(), {"out_of_plane_stress_variable"});
  
     if (_formulation == "ORDINARY_STATE")
       params.set<std::vector<VariableName>>("out_of_plane_stress_variable") = {
           getParam<VariableName>("out_of_plane_stress_variable")};
  
     _problem->addUserObject(uo_type, uo_name, params);
   }
   else if (_current_task == "add_scalar_kernel")
   {
     std::string sk_type("GeneralizedPlaneStrainPD");
     InputParameters params = _factory.getValidParams(sk_type);
  
     std::string sk_name = name() + "_GeneralizedPlaneStrainPD";
  
     params.set<NonlinearVariableName>("variable") = _scalar_out_of_plane_strain;
  
     // set the UserObjectName using added UserObject
     params.set<UserObjectName>("generalized_plane_strain_uo") =
         name() + "_GeneralizedPlaneStrainPDUserObject";
  
     _problem->addScalarKernel(sk_type, sk_name, params);
   }
   else
     mooseError("Task error in GeneralizedPlaneStrainActionPD");
 }