Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "GlobalStrainAction.h"
      11             : 
      12             : #include "Conversion.h"
      13             : #include "FEProblem.h"
      14             : #include "MooseMesh.h"
      15             : #include "NonlinearSystemBase.h"
      16             : 
      17             : #include "libmesh/string_to_enum.h"
      18             : 
      19             : registerMooseAction("SolidMechanicsApp", GlobalStrainAction, "add_user_object");
      20             : 
      21             : registerMooseAction("SolidMechanicsApp", GlobalStrainAction, "add_scalar_kernel");
      22             : 
      23             : registerMooseAction("SolidMechanicsApp", GlobalStrainAction, "add_material");
      24             : 
      25             : registerMooseAction("SolidMechanicsApp", GlobalStrainAction, "add_aux_variable");
      26             : 
      27             : registerMooseAction("SolidMechanicsApp", GlobalStrainAction, "add_aux_kernel");
      28             : 
      29             : InputParameters
      30           7 : GlobalStrainAction::validParams()
      31             : {
      32           7 :   InputParameters params = Action::validParams();
      33           7 :   params.addClassDescription("Set up the GlobalStrainAction environment");
      34          14 :   params.addRequiredParam<VariableName>("scalar_global_strain",
      35             :                                         "Scalar variable for global strain");
      36          14 :   params.addParam<std::vector<VariableName>>("displacements", {}, "The displacement variables");
      37          14 :   params.addParam<std::vector<AuxVariableName>>(
      38             :       "auxiliary_displacements",
      39             :       "The auxliary displacement variables to be calculated from scalar variables");
      40          14 :   params.addParam<std::vector<AuxVariableName>>(
      41             :       "global_displacements",
      42             :       "The global displacement variables to be calculated from scalar variables");
      43          14 :   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          14 :   params.addParam<std::string>("base_name", "Material property base name");
      47          14 :   params.addParam<std::vector<SubdomainName>>(
      48             :       "block", {}, "The block id where this variable lives");
      49             : 
      50           7 :   return params;
      51           0 : }
      52             : 
      53           7 : GlobalStrainAction::GlobalStrainAction(const InputParameters & params)
      54             :   : Action(params),
      55           7 :     _disp(getParam<std::vector<VariableName>>("displacements")),
      56          14 :     _aux_disp(getParam<std::vector<AuxVariableName>>("auxiliary_displacements")),
      57          14 :     _global_disp(getParam<std::vector<AuxVariableName>>("global_displacements")),
      58          21 :     _block_names(getParam<std::vector<SubdomainName>>("block")),
      59           7 :     _block_ids()
      60             : {
      61           7 :   if (_aux_disp.size() != _disp.size())
      62           0 :     mooseError("Number of auxiliary displacement variables should be equal to the number of "
      63             :                "nonlinear displacement variables, i.e., ",
      64           0 :                _disp.size());
      65           7 : }
      66             : 
      67             : void
      68          35 : GlobalStrainAction::act()
      69             : {
      70             :   // get subdomain IDs
      71          70 :   for (auto & name : _block_names)
      72          35 :     _block_ids.insert(_problem->mesh().getSubdomainID(name));
      73             : 
      74             :   // user object name
      75          35 :   const std::string uo_name = _name + "_GlobalStrainUserObject";
      76             : 
      77             :   //
      78             :   // Add user object
      79             :   //
      80          35 :   if (_current_task == "add_user_object")
      81             :   {
      82           7 :     std::string uo_type = "GlobalStrainUserObject";
      83           7 :     InputParameters params = _factory.getValidParams(uo_type);
      84           7 :     params.applyParameters(parameters());
      85           7 :     params.set<bool>("use_displaced_mesh") = false;
      86          35 :     params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR, EXEC_NONLINEAR};
      87             : 
      88           7 :     _problem->addUserObject(uo_type, uo_name, params);
      89           7 :   }
      90             : 
      91             :   //
      92             :   // Add scalar kernel
      93             :   //
      94          28 :   else if (_current_task == "add_scalar_kernel")
      95             :   {
      96           7 :     std::string sk_type = "GlobalStrain";
      97           7 :     InputParameters params = _factory.getValidParams(sk_type);
      98           7 :     params.applyParameters(parameters());
      99           7 :     params.set<bool>("use_displaced_mesh") = false;
     100          28 :     params.set<NonlinearVariableName>("variable") = getParam<VariableName>("scalar_global_strain");
     101          14 :     params.set<UserObjectName>("global_strain_uo") = uo_name;
     102             : 
     103           7 :     _problem->addScalarKernel(sk_type, _name + "_GlobalStrain", params);
     104           7 :   }
     105             : 
     106             :   //
     107             :   // Add ComputeGlobalStrain material
     108             :   //
     109          21 :   else if (_current_task == "add_material")
     110             :   {
     111           7 :     std::string mat_type = "ComputeGlobalStrain";
     112           7 :     InputParameters params = _factory.getValidParams(mat_type);
     113           7 :     params.applyParameters(parameters(), {"scalar_global_strain"});
     114           7 :     params.set<bool>("use_displaced_mesh") = false;
     115          14 :     params.set<std::vector<VariableName>>("scalar_global_strain") = {
     116          28 :         getParam<VariableName>("scalar_global_strain")};
     117          14 :     params.set<UserObjectName>("global_strain_uo") = uo_name;
     118             : 
     119           7 :     _problem->addMaterial(mat_type, _name + "_global_strain", params);
     120           7 :   }
     121             : 
     122             :   //
     123             :   // Add auxiliary displacement variables
     124             :   //
     125          14 :   else if (_current_task == "add_aux_variable")
     126             :   {
     127           7 :     auto params = _factory.getValidParams("MooseVariable");
     128             :     // determine necessary order
     129           7 :     const bool second = _problem->mesh().hasSecondOrderElements();
     130             : 
     131          21 :     params.set<MooseEnum>("order") = second ? "SECOND" : "FIRST";
     132          14 :     params.set<MooseEnum>("family") = "LAGRANGE";
     133             : 
     134          28 :     for (unsigned int i = 0; i < _aux_disp.size(); ++i)
     135             :     {
     136          21 :       std::string aux_var_name = _aux_disp[i];
     137             : 
     138          42 :       _problem->addAuxVariable("MooseVariable", aux_var_name, params);
     139             :     }
     140             : 
     141          28 :     for (unsigned int i = 0; i < _global_disp.size(); ++i)
     142             :     {
     143          21 :       std::string aux_var_name = _global_disp[i];
     144             : 
     145          42 :       _problem->addAuxVariable("MooseVariable", aux_var_name, params);
     146             :     }
     147           7 :   }
     148             : 
     149             :   //
     150             :   // Add aux kernels for computing global displacements
     151             :   //
     152           7 :   else if (_current_task == "add_aux_kernel")
     153             :   {
     154          28 :     for (unsigned int i = 0; i < _aux_disp.size(); ++i)
     155             :     {
     156          21 :       std::string aux_var_name = _aux_disp[i];
     157             : 
     158          21 :       std::string aux_type = "GlobalDisplacementAux";
     159          21 :       InputParameters params = _factory.getValidParams(aux_type);
     160          21 :       params.applyParameters(parameters(), {"scalar_global_strain"});
     161          42 :       params.set<AuxVariableName>("variable") = aux_var_name;
     162          21 :       params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
     163          21 :       params.set<bool>("use_displaced_mesh") = false;
     164          21 :       params.set<bool>("output_global_displacement") = false;
     165          42 :       params.set<std::vector<VariableName>>("scalar_global_strain") = {
     166          84 :           getParam<VariableName>("scalar_global_strain")};
     167          42 :       params.set<UserObjectName>("global_strain_uo") = uo_name;
     168          21 :       params.set<unsigned int>("component") = i;
     169             : 
     170          21 :       _problem->addAuxKernel(aux_type, aux_var_name + '_' + name(), params);
     171          21 :     }
     172             : 
     173          28 :     for (unsigned int i = 0; i < _global_disp.size(); ++i)
     174             :     {
     175          21 :       std::string aux_var_name = _global_disp[i];
     176             : 
     177          21 :       std::string aux_type = "GlobalDisplacementAux";
     178          21 :       InputParameters params = _factory.getValidParams(aux_type);
     179          21 :       params.applyParameters(parameters(), {"scalar_global_strain"});
     180          42 :       params.set<AuxVariableName>("variable") = aux_var_name;
     181          21 :       params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
     182          21 :       params.set<bool>("use_displaced_mesh") = false;
     183          21 :       params.set<bool>("output_global_displacement") = true;
     184          42 :       params.set<std::vector<VariableName>>("scalar_global_strain") = {
     185          84 :           getParam<VariableName>("scalar_global_strain")};
     186          42 :       params.set<UserObjectName>("global_strain_uo") = uo_name;
     187          21 :       params.set<unsigned int>("component") = i;
     188             : 
     189          21 :       _problem->addAuxKernel(aux_type, aux_var_name + '_' + name(), params);
     190          21 :     }
     191             :   }
     192         140 : }