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 "TrussMaterial.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "Material.h"
      14             : #include "MooseMesh.h"
      15             : #include "MooseVariable.h"
      16             : #include "NonlinearSystem.h"
      17             : 
      18             : #include "libmesh/quadrature.h"
      19             : 
      20             : InputParameters
      21         324 : TrussMaterial::validParams()
      22             : {
      23         324 :   InputParameters params = Material::validParams();
      24         648 :   params.addParam<std::string>("base_name",
      25             :                                "Optional parameter that allows the user to define "
      26             :                                "multiple mechanics material systems on the same "
      27             :                                "block, i.e. for multiple phases");
      28         648 :   params.addRequiredParam<std::vector<VariableName>>(
      29             :       "displacements",
      30             :       "The displacements appropriate for the simulation geometry and coordinate system");
      31         648 :   params.addCoupledVar("youngs_modulus", "Variable containing Young's modulus");
      32         324 :   return params;
      33           0 : }
      34             : 
      35         244 : TrussMaterial::TrussMaterial(const InputParameters & parameters)
      36             :   : Material(parameters),
      37         488 :     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
      38         244 :     _youngs_modulus(coupledValue("youngs_modulus")),
      39         244 :     _total_stretch(declareProperty<Real>(_base_name + "total_stretch")),
      40         244 :     _elastic_stretch(declareProperty<Real>(_base_name + "elastic_stretch")),
      41         244 :     _axial_stress(declareProperty<Real>(_base_name + "axial_stress")),
      42         488 :     _e_over_l(declareProperty<Real>(_base_name + "e_over_l"))
      43             : {
      44         488 :   const std::vector<VariableName> & nl_vnames(getParam<std::vector<VariableName>>("displacements"));
      45         244 :   _ndisp = nl_vnames.size();
      46             : 
      47             :   // fetch nonlinear variables
      48         686 :   for (unsigned int i = 0; i < _ndisp; ++i)
      49         442 :     _disp_var.push_back(&_fe_problem.getStandardVariable(_tid, nl_vnames[i]));
      50         244 : }
      51             : 
      52             : void
      53         120 : TrussMaterial::initQpStatefulProperties()
      54             : {
      55         120 :   _axial_stress[_qp] = 0.0;
      56         120 :   _total_stretch[_qp] = 0.0;
      57         120 :   _elastic_stretch[_qp] = 0.0;
      58         120 : }
      59             : 
      60             : void
      61       11690 : TrussMaterial::computeProperties()
      62             : {
      63             :   // check for consistency of the number of element nodes
      64             :   mooseAssert(_current_elem->n_nodes() == 2, "Truss element needs to have exactly two nodes.");
      65             : 
      66             :   // fetch the two end nodes for _current_elem
      67             :   std::vector<const Node *> node;
      68       35070 :   for (unsigned int i = 0; i < 2; ++i)
      69       23380 :     node.push_back(_current_elem->node_ptr(i));
      70             : 
      71             :   // calculate original length of a truss element
      72             :   RealGradient dxyz;
      73       36728 :   for (unsigned int i = 0; i < _ndisp; ++i)
      74       25038 :     dxyz(i) = (*node[1])(i) - (*node[0])(i);
      75       11690 :   _origin_length = dxyz.norm();
      76             : 
      77             :   // fetch the solution for the two end nodes
      78       11690 :   NonlinearSystemBase & nonlinear_sys = _fe_problem.getNonlinearSystemBase(/*nl_sys_num=*/0);
      79       11690 :   const NumericVector<Number> & sol = *nonlinear_sys.currentSolution();
      80             : 
      81             :   std::vector<Real> disp0, disp1;
      82       36728 :   for (unsigned int i = 0; i < _ndisp; ++i)
      83             :   {
      84       25038 :     disp0.push_back(sol(node[0]->dof_number(nonlinear_sys.number(), _disp_var[i]->number(), 0)));
      85       25038 :     disp1.push_back(sol(node[1]->dof_number(nonlinear_sys.number(), _disp_var[i]->number(), 0)));
      86             :   }
      87             : 
      88             :   // calculate current length of a truss element
      89       36728 :   for (unsigned int i = 0; i < _ndisp; ++i)
      90       25038 :     dxyz(i) += disp1[i] - disp0[i];
      91       11690 :   _current_length = dxyz.norm();
      92             : 
      93       35070 :   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      94             :   {
      95       23380 :     _e_over_l[_qp] = _youngs_modulus[_qp] / _origin_length;
      96             : 
      97       23380 :     computeQpStrain();
      98       23380 :     computeQpStress();
      99             :   }
     100       11690 : }