diff --git a/doc/content/bib/blackbear.bib b/doc/content/bib/blackbear.bib index fdecc69e..0ae72feb 100644 --- a/doc/content/bib/blackbear.bib +++ b/doc/content/bib/blackbear.bib @@ -75,3 +75,21 @@ @Article{wald_2017 Title = {Development and multiaxial distribution of expansions in reinforced concrete elements affected by alkali--silica reaction}, Volume = {18}, Year = {2017}} + +@article{bondlsip_adina_1985, + Author = {Mehlhorn, G. and Kollegger, J. and Keuser, M. and Kolmar, W.}, + Journal = {Computers and Structures}, + Number = {}, + Pages = {69--80}, + Title = {Nonlinear Contact Problems - A Finite Element Approach Implemented in ADINA}, + Volume = {21}, + Year = {1985}} + +@article{hameed_2013, + Author = {Hameed, R. and Turatsinze, A. and Duprat, F. and Sellier A. }, + Journal = {KSCE:Journal of Civil Engineering}, + Month = jan, + Pages = {1700--1701}, + Title = {Bond stress-slip Behavior of Reinforcing Bars Embedded in Hybrid Fiber-reinforced Concrete}, + Volume = {17}, + Year = {2013}} diff --git a/doc/content/source/constraints/RebarBondSlipConstraint.md b/doc/content/source/constraints/RebarBondSlipConstraint.md new file mode 100644 index 00000000..8a301384 --- /dev/null +++ b/doc/content/source/constraints/RebarBondSlipConstraint.md @@ -0,0 +1,24 @@ +# RebarBondSlipConstraint + +!syntax description /Constraints/RebarBondSlipConstraint + +`RebarBondSlipConstraint` implements a node-to-element constraint designed to apply the bond-slip relations between concrete and reinforcement bars. It uses a simplistic bond-slip model that assigns bond stress based on the slip values calculated as the relative displacement between concrete and rebar: +\begin{equation} + \begin{aligned} + \sigma_s = & \sigma_{max} \left[ 0.5 \left(\frac{\Delta}{\Delta_1}\right) \, - \, 4.5 \, \left(\frac{\Delta}{\Delta_1}\right)^2 \, + \, 1.4 \, \left(\frac{\Delta}{\Delta_1}\right)^3 \right] \; \mathrm{for} \, \Delta < \Delta_1 \, \, \\ + = & 1.9 \, \sigma_{max} \; \mathrm{for} \, \Delta >= \Delta_1 + \end{aligned} +\end{equation} +Here, $\sigma_s$ is the bondstress, $\sigma_{max}$ is the maximum bondstress related to the compressive strength of the concrete, $\Delta$ is the slip calculated as the relative displacement between the concrete and rebar in the axial direction of the rebar, and $\Delta_1$ is the slip magnitude at which the maximum bondstress is reached. This model is similar to what was implemented in [!cite](bondlsip_adina_1985). + +## Example Input File Syntax + +!listing rebar_bondslip/RCBeam_constraint.i block=Constraints + +!syntax parameters /Constraints/RebarBondSlipConstraint + +!syntax inputs /Constraints/RebarBondSlipConstraint + +!syntax children /Constraints/RebarBondSlipConstraint + +!bibtex bibliography diff --git a/include/constraints/RebarBondSlipConstraint.h b/include/constraints/RebarBondSlipConstraint.h new file mode 100644 index 00000000..06a2c0d9 --- /dev/null +++ b/include/constraints/RebarBondSlipConstraint.h @@ -0,0 +1,137 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/master/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +#pragma once + +// MOOSE includes +#include "EqualValueEmbeddedConstraint.h" + +// Forward Declarations +class RebarBondSlipConstraint; + +template <> +InputParameters validParams(); +/** + * A RebarBondSlipConstraint enforces the constraint between concrete and + * reinforcing bars establishing a slip vs. bondstress relationship + */ +class RebarBondSlipConstraint : public EqualValueEmbeddedConstraint +{ +public: + static InputParameters validParams(); + + RebarBondSlipConstraint(const InputParameters & parameters); + virtual void initialSetup() override; + virtual void timestepSetup() override; + bool shouldApply() override; + void reinitConstraint(); + + /** + * Determine whether the coupled variable is one of the displacement variables, + * and find its component + * @param var_num The number of the variable to be checked + * @param component The component index computed in this routine + * @return bool indicating whether the coupled variable is one of the displacement variables + */ + bool getCoupledVarComponent(unsigned int var_num, unsigned int & component); + +protected: + /// method to calculate the tangential and the normal direction for the rebars + virtual void computeTangent(); + + virtual Real computeQpResidual(Moose::ConstraintType type) override; + virtual Real computeQpJacobian(Moose::ConstraintJacobianType type) override; + virtual Real computeQpOffDiagJacobian(Moose::ConstraintJacobianType type, + unsigned int jvar) override; + + /** + * Struct designed to hold info about the bond-slip history + * slip_min miminum slip value at the current step + * slip_max maximum slip value at the current step + * slip_min_old minimum slip value from the history + * slip_max_old maximum slip value from the history + * bondstress_min miminum bondstress value at the current step + * bondstress_max maximum bondstress value at the current step + * bondstress_min_old minimum bondstress value from the history + * bondstress_max_old maximum bondstress value from the history + */ + struct bondSlipData + { + Real slip_min; + Real slip_max; + Real slip_min_old; + Real slip_max_old; + Real bondstress_min; + Real bondstress_max; + Real bondstress_min_old; + Real bondstress_max_old; + + /// initializing the bond-slip data + bondSlipData() + : slip_min(0.0), + slip_max(0.0), + slip_min_old(0.0), + slip_max_old(0.0), + bondstress_min(0.0), + bondstress_max(0.0), + bondstress_min_old(0.0), + bondstress_max_old(0.0) + { + } + }; + + /// storing the bond-slip history values for each of the nodes + std::map _bondslip; + + /// the direction in which the constraint works + const unsigned _component; + + /// problem dimesion + const unsigned int _mesh_dimension; + + /// displacement variables + std::vector _var_nums; + std::vector _vars; + + /// maximum bond stress + const Real _max_bondstress; + + /// residual bond stress due to friction after joint failure + const Real _frictional_bondstress; + + /// ultimate slip value attainable before failure + const Real _ultimate_slip; + + /// radius of the reinforcing bars + const Real _bar_radius; + + /// slip values at the transition points of the bond-slip curve + std::vector _transitional_slip; + + /// constraint force needed to enforce the constraint + RealVectorValue _constraint_residual; + + /// constraint force needed to enforce the constraint + RealVectorValue _constraint_jacobian_axial; + + /// penalty force for the current constraint + RealVectorValue _pen_force; + + /// tangent direction for the rebars + RealVectorValue _secondary_tangent; + + /// current element volume/length for the rabar + Real _current_elem_volume; + + /// bond stress value + Real _bond_stress; + + /// redivative of the bond stress function w.r.t slip + Real _bond_stress_deriv; +}; diff --git a/src/constraints/RebarBondSlipConstraint.C b/src/constraints/RebarBondSlipConstraint.C new file mode 100644 index 00000000..42f7269a --- /dev/null +++ b/src/constraints/RebarBondSlipConstraint.C @@ -0,0 +1,349 @@ +//* This file is part of the MOOSE framework +//* https://www.mooseframework.org +//* +//* All rights reserved, see COPYRIGHT for full restrictions +//* https://github.com/idaholab/moose/blob/primary/COPYRIGHT +//* +//* Licensed under LGPL 2.1, please see LICENSE for details +//* https://www.gnu.org/licenses/lgpl-2.1.html + +// MOOSE includes +#include "RebarBondSlipConstraint.h" +#include "Assembly.h" +#include "SystemBase.h" +#include "FEProblem.h" +#include "MathUtils.h" + +#include "libmesh/string_to_enum.h" + +registerMooseObject("BlackBearApp", RebarBondSlipConstraint); + +defineLegacyParams(RebarBondSlipConstraint); + +InputParameters +RebarBondSlipConstraint::validParams() +{ + InputParameters params = EqualValueEmbeddedConstraint::validParams(); + params.addClassDescription( + "This is a constraint enforcing the bod-slip behavior between concrete and rebar"); + params.addRequiredParam("component", + "An integer corresponding to the direction " + "the variable this kernel acts in. (0 for x, " + "1 for y, 2 for z)"); + params.addCoupledVar( + "displacements", + "The displacements appropriate for the simulation geometry and coordinate system"); + params.addParam("max_bondstress", 0.0, "Maximum bond stress"); + params.addParam("frictional_bondstress", 0.0, "Bond stress due to friction"); + + params.addParam>( + "transitional_slip_values", + "Singificant slip values at which the bondstress curve changes pattern/slope or " + "trnsitions to a different function"); + params.addParam( + "ultimate_slip", 0.05, "Ultimate value of slip at which the concrete and rebar debonds"); + params.addParam("rebar_radius", 1.0, "Radius of the rebar"); + return params; +} + +RebarBondSlipConstraint::RebarBondSlipConstraint(const InputParameters & parameters) + : EqualValueEmbeddedConstraint(parameters), + _component(getParam("component")), + _mesh_dimension(_mesh.dimension()), + _var_nums(_mesh_dimension, libMesh::invalid_uint), + _vars(_mesh_dimension, nullptr), + _max_bondstress(getParam("max_bondstress")), + _frictional_bondstress(getParam("frictional_bondstress")), + _ultimate_slip(getParam("ultimate_slip")), + _bar_radius(getParam("rebar_radius")), + _transitional_slip(getParam>("transitional_slip_values")) +{ + if (_mesh_dimension != coupledComponents("displacements")) + mooseError("In RebarBondSlipConstraint, number of displacements must equal the mesh dimension"); + + for (unsigned int i = 0; i < _mesh_dimension; ++i) + { + _var_nums[i] = coupled("displacements", i); + _vars[i] = getVar("displacements", i); + } +} + +void +RebarBondSlipConstraint::initialSetup() +{ + for (auto it = _secondary_to_primary_map.begin(); it != _secondary_to_primary_map.end(); ++it) + if (_bondslip.find(it->first) == _bondslip.end()) + _bondslip.insert(std::pair(it->first, + bondSlipData())); // initialize +} + +void +RebarBondSlipConstraint::timestepSetup() +{ + for (auto iter = _secondary_to_primary_map.begin(); iter != _secondary_to_primary_map.end(); + ++iter) + { + dof_id_type node_id = iter->first; + auto it = _bondslip.find(node_id); + mooseAssert(it != _bondslip.end(), "Node not found in bond-slip map"); + + _bondslip[node_id].slip_min_old = _bondslip[node_id].slip_min; + _bondslip[node_id].slip_max_old = _bondslip[node_id].slip_max; + _bondslip[node_id].bondstress_min_old = _bondslip[node_id].bondstress_min; + _bondslip[node_id].bondstress_max_old = _bondslip[node_id].bondstress_max; + } +} + +bool +RebarBondSlipConstraint::shouldApply() +{ + auto it = _secondary_to_primary_map.find(_current_node->id()); + + if (it != _secondary_to_primary_map.end()) + { + const Elem * primary_elem = _mesh.elemPtr(it->second); + std::vector points = {*_current_node}; + + // reinit variables on the primary element at the secondary point + _fe_problem.setNeighborSubdomainID(primary_elem, 0); + _fe_problem.reinitNeighborPhys(primary_elem, points, 0); + + reinitConstraint(); + + return true; + } + return false; +} + +void +RebarBondSlipConstraint::computeTangent() +{ + _secondary_tangent = 0.0; + // get normals + // get connected elements of the current node + const std::map> & node_to_elem_map = _mesh.nodeToElemMap(); + auto node_to_elem_pair = node_to_elem_map.find(_current_node->id()); + mooseAssert(node_to_elem_pair != node_to_elem_map.end(), "Missing entry in node to elem map"); + const std::vector & elems = node_to_elem_pair->second; + + for (auto & elem : elems) + { + Elem * elem_ptr = _mesh.elemPtr(elem); + _assembly.reinit(elem_ptr, 0); + _current_elem_volume += _assembly.elemVolume(); + // calculate phi and dphi for this element + FEType fe_type(Utility::string_to_enum("first"), + Utility::string_to_enum("lagrange")); + std::unique_ptr fe(FEBase::build(1, fe_type)); + fe->attach_quadrature_rule(const_cast(_assembly.qRule())); + const std::vector * tangents = &fe->get_dxyzdxi(); + unsigned side = 0; + fe->reinit(elem_ptr, side); + for (unsigned i = 0; i < tangents->size(); i++) + _secondary_tangent += (*tangents)[i]; + } + + _secondary_tangent /= _secondary_tangent.norm(); + _current_elem_volume /= elems.size(); +} + +void +RebarBondSlipConstraint::reinitConstraint() +{ + computeTangent(); + + // Build up residual vector + RealVectorValue relative_disp; + for (unsigned int i = 0; i < _mesh_dimension; ++i) + relative_disp(i) = ((_vars[i]->dofValues())[0] - (_vars[i]->slnNeighbor())[0]); + + Real slip = relative_disp * _secondary_tangent; + RealVectorValue slip_axial = slip * _secondary_tangent; + RealVectorValue slip_normal = relative_disp - slip_axial; + Real slip_ratio = std::abs(slip) / _transitional_slip[0]; + + const Node * node = _current_node; + auto it = _bondslip.find(node->id()); + mooseAssert(it != _bondslip.end(), "Node not found in bond-slip map"); + bondSlipData bond_slip = it->second; + + bond_slip.slip_min = std::min(bond_slip.slip_min_old, slip); + bond_slip.slip_max = std::max(bond_slip.slip_max_old, slip); + + Real slope = 5.0 * _max_bondstress / _transitional_slip[0]; + Real plastic_slip_max = bond_slip.slip_max - bond_slip.bondstress_max / slope; + Real plastic_slip_min = bond_slip.slip_min - bond_slip.bondstress_min / slope; + + _bond_stress_deriv = 0.0; + + if (slip >= bond_slip.slip_max || slip <= bond_slip.slip_min) + { + if (std::abs(slip) < _transitional_slip[0]) + { + _bond_stress = _max_bondstress * MathUtils::sign(slip) * + (5.0 * slip_ratio - 4.5 * slip_ratio * slip_ratio + + 1.4 * slip_ratio * slip_ratio * slip_ratio); + _bond_stress_deriv = + _max_bondstress * MathUtils::sign(slip) * + (5.0 / _transitional_slip[0] - 4.5 * 2.0 * slip_ratio / _transitional_slip[0] + + 1.4 * 3.0 * slip_ratio * slip_ratio / _transitional_slip[0]); + } + else if (slip >= _transitional_slip[0] && slip < _ultimate_slip) + _bond_stress = 1.9 * _max_bondstress; + else if (slip <= -_transitional_slip[0] && slip > -_ultimate_slip) + _bond_stress = -1.9 * _max_bondstress; + else + _bond_stress = _frictional_bondstress * MathUtils::sign(slip); + } + else if (slip > plastic_slip_max && slip < bond_slip.slip_max) + { + _bond_stress = (slip - plastic_slip_max) * bond_slip.bondstress_max / + (bond_slip.slip_max - plastic_slip_max); + + _bond_stress_deriv = bond_slip.bondstress_max / (bond_slip.slip_max - plastic_slip_max); + } + else if (slip < plastic_slip_min && slip > bond_slip.slip_min) + { + _bond_stress = (slip - plastic_slip_min) * bond_slip.bondstress_min / + (bond_slip.slip_min - plastic_slip_min); + _bond_stress_deriv = bond_slip.bondstress_min / (bond_slip.slip_min - plastic_slip_min); + } + else + _bond_stress = _frictional_bondstress; + + Real bond_force = 2.0 * libMesh::pi * _bar_radius * _current_elem_volume * _bond_stress; + Real bond_force_deriv = + 2.0 * libMesh::pi * _bar_radius * _current_elem_volume * _bond_stress_deriv; + + RealVectorValue constraint_force_axial = bond_force * _secondary_tangent; + RealVectorValue constraint_force_normal = _penalty * slip_normal; + + _constraint_residual = constraint_force_axial + constraint_force_normal; + _constraint_jacobian_axial = bond_force_deriv * _secondary_tangent; + + bond_slip.bondstress_min = std::min(bond_slip.bondstress_min_old, _bond_stress); + bond_slip.bondstress_max = std::max(bond_slip.bondstress_max_old, _bond_stress); + + if (_fe_problem.converged()) + { + _bondslip[node->id()].slip_min = bond_slip.slip_min; + _bondslip[node->id()].slip_max = bond_slip.slip_max; + _bondslip[node->id()].bondstress_min = bond_slip.bondstress_min; + _bondslip[node->id()].bondstress_max = bond_slip.bondstress_max; + } +} + +Real +RebarBondSlipConstraint::computeQpResidual(Moose::ConstraintType type) +{ + Real resid = _constraint_residual(_component); + + switch (type) + { + case Moose::Secondary: + return resid * _test_secondary[_i][_qp]; + + case Moose::Primary: + return -resid * _test_primary[_i][_qp]; + } + + return 0.0; +} + +Real +RebarBondSlipConstraint::computeQpJacobian(Moose::ConstraintJacobianType type) +{ + Real jac_axial = _constraint_jacobian_axial(_component); + + switch (type) + { + case Moose::SecondarySecondary: + return _phi_secondary[_j][_qp] * jac_axial * _secondary_tangent(_component) * + _test_secondary[_i][_qp] + + _phi_secondary[_j][_qp] * _penalty * _test_secondary[_i][_qp] * + (1.0 - _secondary_tangent(_component) * _secondary_tangent(_component)); + + case Moose::SecondaryPrimary: + return -_phi_primary[_j][_qp] * jac_axial * _secondary_tangent(_component) * + _test_secondary[_i][_qp] - + _phi_primary[_j][_qp] * _penalty * _test_secondary[_i][_qp] * + (1.0 - _secondary_tangent(_component) * _secondary_tangent(_component)); + + case Moose::PrimarySecondary: + return -_test_primary[_i][_qp] * jac_axial * _secondary_tangent(_component) * + _phi_secondary[_j][_qp] - + _test_primary[_i][_qp] * _penalty * _phi_secondary[_j][_qp] * + (1.0 - _secondary_tangent(_component) * _secondary_tangent(_component)); + + case Moose::PrimaryPrimary: + return _test_primary[_i][_qp] * jac_axial * _secondary_tangent(_component) * + _phi_primary[_j][_qp] + + _test_primary[_i][_qp] * _penalty * _phi_primary[_j][_qp] * + (1.0 - _secondary_tangent(_component) * _secondary_tangent(_component)); + + default: + mooseError("Unsupported type"); + break; + } + return 0.0; +} + +Real +RebarBondSlipConstraint::computeQpOffDiagJacobian(Moose::ConstraintJacobianType type, + unsigned int jvar) +{ + Real jac_axial = _constraint_jacobian_axial(_component); + + unsigned int coupled_component; + Real tangent_component_in_coupled_var_dir = 1.0; + if (getCoupledVarComponent(jvar, coupled_component)) + tangent_component_in_coupled_var_dir = _secondary_tangent(coupled_component); + + switch (type) + { + case Moose::SecondarySecondary: + return _phi_secondary[_j][_qp] * jac_axial * tangent_component_in_coupled_var_dir * + _test_secondary[_i][_qp] - + _phi_secondary[_j][_qp] * _penalty * _test_secondary[_i][_qp] * + _secondary_tangent(_component) * tangent_component_in_coupled_var_dir; + + case Moose::SecondaryPrimary: + return -_phi_primary[_j][_qp] * jac_axial * tangent_component_in_coupled_var_dir * + _test_secondary[_i][_qp] + + _phi_primary[_j][_qp] * _penalty * _test_secondary[_i][_qp] * + _secondary_tangent(_component) * tangent_component_in_coupled_var_dir; + + case Moose::PrimarySecondary: + return -_test_primary[_i][_qp] * jac_axial * tangent_component_in_coupled_var_dir * + _phi_secondary[_j][_qp] + + _test_primary[_i][_qp] * _penalty * _phi_secondary[_j][_qp] * + _secondary_tangent(_component) * tangent_component_in_coupled_var_dir; + + case Moose::PrimaryPrimary: + return _test_primary[_i][_qp] * jac_axial * tangent_component_in_coupled_var_dir * + _phi_primary[_j][_qp] - + _test_primary[_i][_qp] * _penalty * _phi_primary[_j][_qp] * + _secondary_tangent(_component) * tangent_component_in_coupled_var_dir; + + default: + mooseError("Unsupported type"); + break; + } + return 0.0; +} + +bool +RebarBondSlipConstraint::getCoupledVarComponent(unsigned int var_num, unsigned int & component) +{ + component = std::numeric_limits::max(); + bool coupled_var_is_disp_var = false; + for (unsigned int i = 0; i < LIBMESH_DIM; ++i) + if (var_num == _var_nums[i]) + { + coupled_var_is_disp_var = true; + component = i; + break; + } + + return coupled_var_is_disp_var; +} diff --git a/test/tests/rebar_bondslip/RCBeam_constraint.i b/test/tests/rebar_bondslip/RCBeam_constraint.i new file mode 100644 index 00000000..f5e6a6c4 --- /dev/null +++ b/test/tests/rebar_bondslip/RCBeam_constraint.i @@ -0,0 +1,245 @@ +[Mesh] + file = gold/RCBeam_test_mesh.e +[] + +[GlobalParams] + displacements = 'disp_x disp_y' +[] + +[Modules/TensorMechanics/Master] + [./Concrete_block] + block = 1 + strain = finite + incremental = true + generate_output = 'stress_xx stress_xy stress_yy strain_xx strain_xy strain_yy + vonmises_stress elastic_strain_xx elastic_strain_xy elastic_strain_yy' + save_in = 'resid_x resid_y' + [../] +[] + +[Modules/TensorMechanics/LineElementMaster] + [./Reinforcement_block] + block = '2' + truss = true + area = area + displacements = 'disp_x disp_y' + save_in = 'resid_x resid_y' + [../] +[] + +[Variables] + [./disp_x] + [../] + [./disp_y] + [../] +[] + +[AuxVariables] + [./resid_x] + [../] + [./resid_y] + [../] + [./area] + order = CONSTANT + family = MONOMIAL + [../] + [./axial_stress] + order = CONSTANT + family = MONOMIAL + [../] +[] + +[AuxKernels] + [./area] + type = ConstantAux + block = '2' + variable = area + value = 2.00e-4 # 509 mm2 + execute_on = 'initial timestep_begin' + [../] + [./axial_stress] + type = MaterialRealAux + block = '2' + variable = axial_stress + property = axial_stress + [../] +[] + +[Constraints] + [rebar_x] + type = RebarBondSlipConstraint + secondary = 2 + primary = 1 + penalty = 1e12 + variable = 'disp_x' + primary_variable = 'disp_x' + component = 0 + max_bondstress = 100 + transitional_slip_values = 0.001 + ultimate_slip = 0.1 + rebar_radius = 7.98e-3 + [] + [rebar_y] + type = RebarBondSlipConstraint + secondary = 2 + primary = 1 + penalty = 1e12 + variable = 'disp_y' + primary_variable = 'disp_y' + component = 1 + max_bondstress = 100 + transitional_slip_values = 0.001 + ultimate_slip = 0.1 + rebar_radius = 7.98e-3 + [] +[] + +[BCs] + [./loading] + type = DirichletBC + variable = disp_x + boundary = '102' + value = 0.001 + preset = true + [../] + [./left_support_x] + type = DirichletBC + variable = disp_x + boundary = '100' + value = 0 + [../] + [./left_support_y] + type = DirichletBC + variable = disp_y + boundary = '100' + value = 0 + [../] +[] + +[Postprocessors] + [./deformation_x] + type = AverageNodalVariableValue + variable = disp_x + boundary = '101' + [../] + [./deformation_y] + type = AverageNodalVariableValue + variable = disp_y + boundary = '101' + [../] + [./react_x] + type = AverageNodalVariableValue + variable = resid_x + boundary = '100' + [../] + [./react_y] + type = AverageNodalVariableValue + variable = resid_y + boundary = '100' + [../] + [./react_x2] + type = AverageNodalVariableValue + variable = resid_x + boundary = '101' + [../] + [./react_y2] + type = AverageNodalVariableValue + variable = resid_y + boundary = '100' + [../] + [./node1_fx] + type = NodalVariableValue + variable = resid_x + nodeid = 138 + [../] + [./node1_fy] + type = NodalVariableValue + variable = resid_y + nodeid = 138 + [../] + [./node1_dx] + type = NodalVariableValue + variable = disp_x + nodeid = 138 + [../] + [./node1_dy] + type = NodalVariableValue + variable = disp_y + nodeid = 138 + [../] + [./node1_fx2] + type = AverageNodalVariableValue + variable = resid_x + boundary = '102' + [../] + + [./stress_xx] + type = ElementAverageValue + variable = stress_xx + block = '1' + [../] + [./strain_xx] + type = ElementAverageValue + variable = strain_xx + block = '1' + [../] + [./axial_stress] + type = ElementAverageValue + variable = axial_stress + block = '2' + [../] +[] + +[Materials] + [Cijkl_concrete] + type = ComputeIsotropicElasticityTensor + youngs_modulus = 500e6 + poissons_ratio = 0.2 + block = 1 + [] + [./isotropic_plasticity] + type = IsotropicPlasticityStressUpdate + yield_stress = 285788383.2488647 # = sqrt(3)*165e6 = sqrt(3) * yield in shear + hardening_constant = 0.0 + block = '1' + [../] + [./radial_return_stress] + type = ComputeMultipleInelasticStress + tangent_operator = elastic + inelastic_models = 'isotropic_plasticity' + block = '1' + [../] + [truss] + type = LinearElasticTruss + block = '2' + youngs_modulus = 2e11 + [] +[] + +[Preconditioning] + [./SMP] + type = SMP + full = true + [../] +[] + +[Executioner] + type = Transient + solve_type = 'PJFNK' + line_search = none + petsc_options_iname = '-pc_type' + petsc_options_value = 'lu' + petsc_options = '-snes_converged_reason' + nl_max_its = 10 + nl_abs_tol = 1e-8 + nl_rel_tol = 1e-8 + dtmin = 0.00001 + num_steps = 1 + dt = 1.0 +[] + + +[Outputs] + exodus = true + csv = true +[] diff --git a/test/tests/rebar_bondslip/gold/RCBeam_constraint_out.csv b/test/tests/rebar_bondslip/gold/RCBeam_constraint_out.csv new file mode 100644 index 00000000..58f1ac6b --- /dev/null +++ b/test/tests/rebar_bondslip/gold/RCBeam_constraint_out.csv @@ -0,0 +1,3 @@ +time,axial_stress,deformation_x,deformation_y,node1_dx,node1_dy,node1_fx,node1_fx2,node1_fy,react_x,react_x2,react_y,react_y2,strain_xx,stress_xx +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 +1,47450.38093279,0.00080004745038093,-4.9527997390471e-10,4.6524399000211e-08,-5.7441994171806e-11,0.43338321376041,13028.059546252,4.2789048601961e-09,-10422.804881813,10422.804881553,4.242795205144e-07,4.242795205144e-07,0.0009994988237708,521173.25776804 diff --git a/test/tests/rebar_bondslip/gold/RCBeam_constraint_out.e b/test/tests/rebar_bondslip/gold/RCBeam_constraint_out.e new file mode 100644 index 00000000..2e7848b0 Binary files /dev/null and b/test/tests/rebar_bondslip/gold/RCBeam_constraint_out.e differ diff --git a/test/tests/rebar_bondslip/gold/RCBeam_test_mesh.e b/test/tests/rebar_bondslip/gold/RCBeam_test_mesh.e new file mode 100644 index 00000000..dcfb3119 Binary files /dev/null and b/test/tests/rebar_bondslip/gold/RCBeam_test_mesh.e differ diff --git a/test/tests/rebar_bondslip/tests b/test/tests/rebar_bondslip/tests new file mode 100644 index 00000000..69848093 --- /dev/null +++ b/test/tests/rebar_bondslip/tests @@ -0,0 +1,18 @@ +[Tests] + issues = '#99' + requirement = 'Blackbear shall have a model to capture the bond-slip relation between concrete and rebars' + design = 'constraints/RebarBondSlipConstraint.md' + + [./bondslip] + type = 'Exodiff' + input = 'RCBeam_constraint.i' + exodiff = 'RCBeam_constraint_out.e' + abs_zero = 1e-5 + [../] + [./bondslip_csv] + type = 'CSVDiff' + input = 'RCBeam_constraint.i' + csvdiff = 'RCBeam_constraint_out.csv' + abs_zero = 1e-5 + [../] +[]