Line data    Source code

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