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         276 : TrussMaterial::validParams()
      22             : {
      23         276 :   InputParameters params = Material::validParams();
      24         552 :   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         552 :   params.addRequiredParam<std::vector<VariableName>>(
      29             :       "displacements",
      30             :       "The displacements appropriate for the simulation geometry and coordinate system");
      31         552 :   params.addCoupledVar("youngs_modulus", "Variable containing Young's modulus");
      32         276 :   return params;
      33           0 : }
      34             : 
      35         208 : TrussMaterial::TrussMaterial(const InputParameters & parameters)
      36             :   : Material(parameters),
      37         416 :     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
      38         208 :     _youngs_modulus(coupledValue("youngs_modulus")),
      39         208 :     _total_stretch(declareProperty<Real>(_base_name + "total_stretch")),
      40         208 :     _elastic_stretch(declareProperty<Real>(_base_name + "elastic_stretch")),
      41         208 :     _axial_stress(declareProperty<Real>(_base_name + "axial_stress")),
      42         416 :     _e_over_l(declareProperty<Real>(_base_name + "e_over_l"))
      43             : {
      44         416 :   const std::vector<VariableName> & nl_vnames(getParam<std::vector<VariableName>>("displacements"));
      45         208 :   _ndisp = nl_vnames.size();
      46             : 
      47             :   // fetch nonlinear variables
      48         584 :   for (unsigned int i = 0; i < _ndisp; ++i)
      49         376 :     _disp_var.push_back(&_fe_problem.getStandardVariable(_tid, nl_vnames[i]));
      50         208 : }
      51             : 
      52             : void
      53          96 : TrussMaterial::initQpStatefulProperties()
      54             : {
      55          96 :   _axial_stress[_qp] = 0.0;
      56          96 :   _total_stretch[_qp] = 0.0;
      57          96 :   _elastic_stretch[_qp] = 0.0;
      58          96 : }
      59             : 
      60             : void
      61        7984 : 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       23952 :   for (unsigned int i = 0; i < 2; ++i)
      69       15968 :     node.push_back(_current_elem->node_ptr(i));
      70             : 
      71             :   // calculate original length of a truss element
      72             :   RealGradient dxyz;
      73       24952 :   for (unsigned int i = 0; i < _ndisp; ++i)
      74       16968 :     dxyz(i) = (*node[1])(i) - (*node[0])(i);
      75        7984 :   _origin_length = dxyz.norm();
      76             : 
      77             :   // fetch the solution for the two end nodes
      78        7984 :   NonlinearSystemBase & nonlinear_sys = _fe_problem.getNonlinearSystemBase(/*nl_sys_num=*/0);
      79        7984 :   const NumericVector<Number> & sol = *nonlinear_sys.currentSolution();
      80             : 
      81             :   std::vector<Real> disp0, disp1;
      82       24952 :   for (unsigned int i = 0; i < _ndisp; ++i)
      83             :   {
      84       16968 :     disp0.push_back(sol(node[0]->dof_number(nonlinear_sys.number(), _disp_var[i]->number(), 0)));
      85       16968 :     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       24952 :   for (unsigned int i = 0; i < _ndisp; ++i)
      90       16968 :     dxyz(i) += disp1[i] - disp0[i];
      91        7984 :   _current_length = dxyz.norm();
      92             : 
      93       23952 :   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      94             :   {
      95       15968 :     _e_over_l[_qp] = _youngs_modulus[_qp] / _origin_length;
      96             : 
      97       15968 :     computeQpStrain();
      98       15968 :     computeQpStress();
      99             :   }
     100        7984 : }