TensorMechanicsMaterial::TensorMechanicsMaterial(const std::string & name, InputParameters parameters) : Material(name, parameters), _grad_disp_x(coupledGradient("disp_x")), _grad_disp_y(coupledGradient("disp_y")), _grad_disp_z(_mesh.dimension() == 3 ? coupledGradient("disp_z") : _grad_zero), _grad_disp_x_old(_fe_problem.isTransient() ? coupledGradientOld("disp_x") : _grad_zero), _grad_disp_y_old(_fe_problem.isTransient() ? coupledGradientOld("disp_y") : _grad_zero), _grad_disp_z_old(_fe_problem.isTransient() && _mesh.dimension() == 3 ? coupledGradientOld("disp_z") : _grad_zero), _stress(declareProperty<RankTwoTensor>("stress")), _total_strain(declareProperty<RankTwoTensor>("total_strain")), _elastic_strain(declareProperty<RankTwoTensor>("elastic_strain")), _elasticity_tensor(declareProperty<ElasticityTensorR4>("elasticity_tensor")), _Jacobian_mult(declareProperty<ElasticityTensorR4>("Jacobian_mult")), // _d_stress_dT(declareProperty<RankTwoTensor>("d_stress_dT")), _euler_angle_1(getParam<Real>("euler_angle_1")), _euler_angle_2(getParam<Real>("euler_angle_2")), _euler_angle_3(getParam<Real>("euler_angle_3")), _Cijkl_vector(getParam<std::vector<Real> >("C_ijkl")), _Cijkl(), _Euler_angles(_euler_angle_1, _euler_angle_2, _euler_angle_3), _has_T(isCoupled("temperature")), _T(_has_T ? &coupledValue("temperature") : NULL), _fill_method((RankFourTensor::FillMethod)(int)getParam<MooseEnum>("fill_method")) { _Cijkl.fillFromInputVector(_Cijkl_vector, _fill_method); const std::vector<FunctionName> & fcn_names( getParam<std::vector<FunctionName> >("initial_stress") ); const unsigned num = fcn_names.size(); if (!(num == 0 || num == 3*3)) mooseError("Either zero or " << 3*3 << " initial stress functions must be provided to TensorMechanicsMaterial. You supplied " << num << "\n"); _initial_stress.resize(num); for (unsigned i = 0 ; i < num ; ++i) _initial_stress[i] = &getFunctionByName(fcn_names[i]); }
TensorMechanicsMaterial::TensorMechanicsMaterial(const std::string & name, InputParameters parameters) : Material(name, parameters), _grad_disp_x(coupledGradient("disp_x")), _grad_disp_y(coupledGradient("disp_y")), _grad_disp_z(_mesh.dimension() == 3 ? coupledGradient("disp_z") : _grad_zero), _grad_disp_x_old(_fe_problem.isTransient() ? coupledGradientOld("disp_x") : _grad_zero), _grad_disp_y_old(_fe_problem.isTransient() ? coupledGradientOld("disp_y") : _grad_zero), _grad_disp_z_old(_fe_problem.isTransient() && _mesh.dimension() == 3 ? coupledGradientOld("disp_z") : _grad_zero), _stress(declareProperty<RankTwoTensor>("stress")), _elastic_strain(declareProperty<RankTwoTensor>("elastic_strain")), _elasticity_tensor(declareProperty<ElasticityTensorR4>("elasticity_tensor")), _Jacobian_mult(declareProperty<ElasticityTensorR4>("Jacobian_mult")), //_d_stress_dT(declareProperty<RankTwoTensor>("d_stress_dT")), _euler_angle_1(getParam<Real>("euler_angle_1")), _euler_angle_2(getParam<Real>("euler_angle_2")), _euler_angle_3(getParam<Real>("euler_angle_3")), _Cijkl_vector(getParam<std::vector<Real> >("C_ijkl")), _all_21(getParam<bool>("all_21")), _Cijkl(), _Euler_angles(_euler_angle_1, _euler_angle_2, _euler_angle_3), _has_T(isCoupled("temperature")), _T(_has_T ? &coupledValue("temperature") : NULL) { // fill in the local tensors from the input vector information _Cijkl.fillFromInputVector(_Cijkl_vector, _all_21); }
Nonlinear3D::Nonlinear3D( SolidModel & solid_model, const std::string & name, InputParameters parameters ) :Element( solid_model, name, parameters ), _grad_disp_x(coupledGradient("disp_x")), _grad_disp_y(coupledGradient("disp_y")), _grad_disp_z(coupledGradient("disp_z")), _grad_disp_x_old(coupledGradientOld("disp_x")), _grad_disp_y_old(coupledGradientOld("disp_y")), _grad_disp_z_old(coupledGradientOld("disp_z")), _decomp_method( RashidApprox ), _incremental_rotation(3,3), _Uhat(3,3) { std::string increment_calculation = solid_model.getParam<std::string>("increment_calculation"); std::transform( increment_calculation.begin(), increment_calculation.end(), increment_calculation.begin(), ::tolower ); if ( increment_calculation == "rashidapprox" ) { _decomp_method = RashidApprox; } else if ( increment_calculation == "eigen" ) { _decomp_method = Eigen; } else { mooseError( "The options for the increment calculation are RashidApprox and Eigen."); } }
NonlinearRZ::NonlinearRZ( SolidModel & solid_model, const std::string & name, const InputParameters & parameters ) :Nonlinear( solid_model, name, parameters ), _grad_disp_r(coupledGradient("disp_r")), _grad_disp_z(coupledGradient("disp_z")), _grad_disp_r_old(coupledGradientOld("disp_r")), _grad_disp_z_old(coupledGradientOld("disp_z")), _disp_r(coupledValue("disp_r")), _disp_r_old(coupledValueOld("disp_r")) { }
Nonlinear3D::Nonlinear3D( SolidModel & solid_model, const std::string & name, const InputParameters & parameters ) :Nonlinear( solid_model, name, parameters ), _grad_disp_x(coupledGradient("disp_x")), _grad_disp_y(coupledGradient("disp_y")), _grad_disp_z(coupledGradient("disp_z")), _grad_disp_x_old(coupledGradientOld("disp_x")), _grad_disp_y_old(coupledGradientOld("disp_y")), _grad_disp_z_old(coupledGradientOld("disp_z")) { }
TensorMechanicsMaterial::TensorMechanicsMaterial(const InputParameters & parameters) : Material(parameters), _grad_disp_x(coupledGradient("disp_x")), _grad_disp_y(coupledGradient("disp_y")), _grad_disp_z(_mesh.dimension() == 3 ? coupledGradient("disp_z") : _grad_zero), _grad_disp_x_old(_fe_problem.isTransient() ? coupledGradientOld("disp_x") : _grad_zero), _grad_disp_y_old(_fe_problem.isTransient() ? coupledGradientOld("disp_y") : _grad_zero), _grad_disp_z_old(_fe_problem.isTransient() && _mesh.dimension() == 3 ? coupledGradientOld("disp_z") : _grad_zero), _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""), _stress(declareProperty<RankTwoTensor>(_base_name + "stress")), _total_strain(declareProperty<RankTwoTensor>(_base_name + "total_strain")), _elastic_strain(declareProperty<RankTwoTensor>(_base_name + "elastic_strain")), _elasticity_tensor_name(_base_name + "elasticity_tensor"), _elasticity_tensor(declareProperty<RankFourTensor>(_elasticity_tensor_name)), _Jacobian_mult(declareProperty<RankFourTensor>(_base_name + "Jacobian_mult")), _Euler_angles(getParam<Real>("euler_angle_1"), getParam<Real>("euler_angle_2"), getParam<Real>("euler_angle_3")), _Cijkl(getParam<std::vector<Real>>("C_ijkl"), (RankFourTensor::FillMethod)(int)getParam<MooseEnum>("fill_method")), _prefactor_function(isParamValid("elasticity_tensor_prefactor") ? &getFunction("elasticity_tensor_prefactor") : NULL) { mooseDeprecated("EigenStrainBaseMaterial is deprecated. Please use the TensorMechanics " "plug-and-play system instead: " "http://mooseframework.org/wiki/PhysicsModules/TensorMechanics/" "PlugAndPlayMechanicsApproach/"); const std::vector<FunctionName> & fcn_names( getParam<std::vector<FunctionName>>("initial_stress")); const unsigned num = fcn_names.size(); if (!(num == 0 || num == 3 * 3)) mooseError( "Either zero or ", 3 * 3, " initial stress functions must be provided to TensorMechanicsMaterial. You supplied ", num, "\n"); _initial_stress.resize(num); for (unsigned i = 0; i < num; ++i) _initial_stress[i] = &getFunctionByName(fcn_names[i]); }
Nonlinear3D::Nonlinear3D(SolidModel & solid_model, const std::string & name, const InputParameters & parameters) : Nonlinear(solid_model, name, parameters), _grad_disp_x(coupledGradient("disp_x")), _grad_disp_y(coupledGradient("disp_y")), _grad_disp_z(coupledGradient("disp_z")), _grad_disp_x_old(coupledGradientOld("disp_x")), _grad_disp_y_old(coupledGradientOld("disp_y")), _grad_disp_z_old(coupledGradientOld("disp_z")), _volumetric_locking_correction(_solid_model.getParam<bool>("volumetric_locking_correction")) { }
INSChorinPredictor::INSChorinPredictor(const InputParameters & parameters) : Kernel(parameters), // Current velocities _u_vel(coupledValue("u")), _v_vel(_mesh.dimension() >= 2 ? coupledValue("v") : _zero), _w_vel(_mesh.dimension() == 3 ? coupledValue("w") : _zero), // Old velocities _u_vel_old(coupledValueOld("u")), _v_vel_old(_mesh.dimension() >= 2 ? coupledValueOld("v") : _zero), _w_vel_old(_mesh.dimension() == 3 ? coupledValueOld("w") : _zero), // Star velocities _u_vel_star(coupledValue("u_star")), _v_vel_star(_mesh.dimension() >= 2 ? coupledValue("v_star") : _zero), _w_vel_star(_mesh.dimension() == 3 ? coupledValue("w_star") : _zero), // Velocity Gradients _grad_u_vel(coupledGradient("u")), _grad_v_vel(_mesh.dimension() >= 2 ? coupledGradient("v") : _grad_zero), _grad_w_vel(_mesh.dimension() == 3 ? coupledGradient("w") : _grad_zero), // Old Velocity Gradients _grad_u_vel_old(coupledGradientOld("u")), _grad_v_vel_old(_mesh.dimension() >= 2 ? coupledGradientOld("v") : _grad_zero), _grad_w_vel_old(_mesh.dimension() == 3 ? coupledGradientOld("w") : _grad_zero), // Star Velocity Gradients _grad_u_vel_star(coupledGradient("u_star")), _grad_v_vel_star(_mesh.dimension() >= 2 ? coupledGradient("v_star") : _grad_zero), _grad_w_vel_star(_mesh.dimension() == 3 ? coupledGradient("w_star") : _grad_zero), // Variable numberings _u_vel_var_number(coupled("u")), _v_vel_var_number(_mesh.dimension() >= 2 ? coupled("v") : libMesh::invalid_uint), _w_vel_var_number(_mesh.dimension() == 3 ? coupled("w") : libMesh::invalid_uint), // Star velocity numberings _u_vel_star_var_number(coupled("u_star")), _v_vel_star_var_number(_mesh.dimension() >= 2 ? coupled("v_star") : libMesh::invalid_uint), _w_vel_star_var_number(_mesh.dimension() == 3 ? coupled("w_star") : libMesh::invalid_uint), // Required parameters _mu(getParam<Real>("mu")), _rho(getParam<Real>("rho")), _component(getParam<unsigned>("component")), _predictor_type(getParam<std::string>("predictor_type")), _predictor_enum("OLD, NEW, STAR, INVALID", _predictor_type) { }
ComputeIncrementalStrainBase::ComputeIncrementalStrainBase(const InputParameters & parameters) : ComputeStrainBase(parameters), _stateful_displacements(_fe_problem.isTransient()), _stateful_deformation_gradient(getParam<bool>("stateful_deformation_gradient") && _fe_problem.isTransient()), _grad_disp_old(3), _strain_rate(declareProperty<RankTwoTensor>(_base_name + "strain_rate")), _strain_increment(declareProperty<RankTwoTensor>(_base_name + "strain_increment")), _rotation_increment(declareProperty<RankTwoTensor>(_base_name + "rotation_increment")), _deformation_gradient(declareProperty<RankTwoTensor>(_base_name + "deformation_gradient")), _deformation_gradient_old(_stateful_deformation_gradient ? &declarePropertyOld<RankTwoTensor>(_base_name + "deformation_gradient") : NULL), _mechanical_strain_old(declarePropertyOld<RankTwoTensor>(_base_name + "mechanical_strain")), _total_strain_old(declarePropertyOld<RankTwoTensor>(_base_name + "total_strain")), _eigenstrains_old(_eigenstrain_names.size()) { for (unsigned int i = 0; i < _eigenstrains_old.size(); ++i) _eigenstrains_old[i] = &getMaterialPropertyOld<RankTwoTensor>(_eigenstrain_names[i]); // fetch coupled variables and gradients (as stateful properties if necessary) for (unsigned int i = 0; i < _ndisp; ++i) { if (_stateful_displacements) _grad_disp_old[i] = &coupledGradientOld("displacements" ,i); else _grad_disp_old[i] = &_grad_zero; } // set unused dimensions to zero for (unsigned i = _ndisp; i < 3; ++i) _grad_disp_old[i] = &_grad_zero; }
NonlinearPlaneStrain::NonlinearPlaneStrain( SolidModel & solid_model, const std::string & name, const InputParameters & parameters ) :Nonlinear( solid_model, name, parameters ), ScalarCoupleable(parameters), _grad_disp_x(coupledGradient("disp_x")), _grad_disp_y(coupledGradient("disp_y")), _have_strain_zz(isCoupled("strain_zz")), _strain_zz(_have_strain_zz?coupledValue("strain_zz"):_zero), _have_scalar_strain_zz(isCoupledScalar("scalar_strain_zz")), _scalar_strain_zz(_have_scalar_strain_zz?coupledScalarValue("scalar_strain_zz"):_zero), _grad_disp_x_old(coupledGradientOld("disp_x")), _grad_disp_y_old(coupledGradientOld("disp_y")), _strain_zz_old(_have_strain_zz?coupledValueOld("strain_zz"):_zero), _scalar_strain_zz_old(_have_scalar_strain_zz?coupledScalarValueOld("scalar_strain_zz"):_zero) { }
TensorMechanicsMaterial::TensorMechanicsMaterial(const std::string & name, InputParameters parameters) : Material(name, parameters), _grad_disp_x(coupledGradient("disp_x")), _grad_disp_y(coupledGradient("disp_y")), _grad_disp_z(_mesh.dimension() == 3 ? coupledGradient("disp_z") : _grad_zero), _grad_disp_x_old(_fe_problem.isTransient() ? coupledGradientOld("disp_x") : _grad_zero), _grad_disp_y_old(_fe_problem.isTransient() ? coupledGradientOld("disp_y") : _grad_zero), _grad_disp_z_old(_fe_problem.isTransient() && _mesh.dimension() == 3 ? coupledGradientOld("disp_z") : _grad_zero), _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : "" ), _stress(declareProperty<RankTwoTensor>(_base_name + "stress")), _total_strain(declareProperty<RankTwoTensor>(_base_name + "total_strain")), _elastic_strain(declareProperty<RankTwoTensor>(_base_name + "elastic_strain")), _elasticity_tensor_name(_base_name + "elasticity_tensor"), _elasticity_tensor(declareProperty<ElasticityTensorR4>(_elasticity_tensor_name)), _Jacobian_mult(declareProperty<ElasticityTensorR4>(_base_name + "Jacobian_mult")), _Euler_angles(getParam<Real>("euler_angle_1"), getParam<Real>("euler_angle_2"), getParam<Real>("euler_angle_3")), _Cijkl(getParam<std::vector<Real> >("C_ijkl"), (RankFourTensor::FillMethod)(int)getParam<MooseEnum>("fill_method")), _prefactor_function(isParamValid("elasticity_tensor_prefactor") ? &getFunction("elasticity_tensor_prefactor") : NULL) { const std::vector<FunctionName> & fcn_names(getParam<std::vector<FunctionName> >("initial_stress")); const unsigned num = fcn_names.size(); if (!(num == 0 || num == 3*3)) mooseError("Either zero or " << 3*3 << " initial stress functions must be provided to TensorMechanicsMaterial. You supplied " << num << "\n"); _initial_stress.resize(num); for (unsigned i = 0 ; i < num ; ++i) _initial_stress[i] = &getFunctionByName(fcn_names[i]); }
ComputeStrainBase::ComputeStrainBase(const InputParameters & parameters) : DerivativeMaterialInterface<Material>(parameters), _ndisp(coupledComponents("displacements")), _disp(3), _grad_disp(3), _grad_disp_old(3), _T(coupledValue("temperature")), _T0(getParam<Real>("temperature_ref")), _thermal_expansion_coeff(getParam<Real>("thermal_expansion_coeff")), _no_thermal_eigenstrains(false), _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : "" ), _mechanical_strain(declareProperty<RankTwoTensor>(_base_name + "mechanical_strain")), _total_strain(declareProperty<RankTwoTensor>(_base_name + "total_strain")), _stateful_displacements(getParam<bool>("stateful_displacements") && _fe_problem.isTransient()), _volumetric_locking_correction(getParam<bool>("volumetric_locking_correction")) { // Checking for consistency between mesh size and length of the provided displacements vector if (_ndisp != _mesh.dimension()) mooseError("The number of variables supplied in 'displacements' must match the mesh dimension."); if (parameters.isParamSetByUser("thermal_expansion_coeff")) _no_thermal_eigenstrains = true; if (_no_thermal_eigenstrains) mooseDeprecated("The calculation of the thermal strains has been moved to the material ComputeThermalExpansionEigenStrains"); // fetch coupled variables and gradients (as stateful properties if necessary) for (unsigned int i = 0; i < _ndisp; ++i) { _disp[i] = &coupledValue("displacements", i); _grad_disp[i] = &coupledGradient("displacements", i); if (_stateful_displacements) _grad_disp_old[i] = &coupledGradientOld("displacements" ,i); else _grad_disp_old[i] = &_grad_zero; } // set unused dimensions to zero for (unsigned i = _ndisp; i < 3; ++i) { _disp[i] = &_zero; _grad_disp[i] = &_grad_zero; _grad_disp_old[i] = &_grad_zero; } }
PorousFlowVolumetricStrain::PorousFlowVolumetricStrain(const InputParameters & parameters) : PorousFlowMaterialVectorBase(parameters), _consistent(getParam<bool>("consistent_with_displaced_mesh")), _ndisp(coupledComponents("displacements")), _disp(3), _disp_var_num(3), _grad_disp(3), _grad_disp_old(3), _vol_strain_rate_qp(declareProperty<Real>("PorousFlow_volumetric_strain_rate_qp")), _dvol_strain_rate_qp_dvar( declareProperty<std::vector<RealGradient>>("dPorousFlow_volumetric_strain_rate_qp_dvar")), _vol_total_strain_qp(declareProperty<Real>("PorousFlow_total_volumetric_strain_qp")), _dvol_total_strain_qp_dvar( declareProperty<std::vector<RealGradient>>("dPorousFlow_total_volumetric_strain_qp_dvar")) { if (_ndisp != _mesh.dimension()) paramError("displacements", "The number of variables supplied must match the mesh dimension."); // fetch coupled variables and gradients (as stateful properties if necessary) for (unsigned int i = 0; i < _ndisp; ++i) { _disp[i] = &coupledValue("displacements", i); _disp_var_num[i] = coupled("displacements", i); _grad_disp[i] = &coupledGradient("displacements", i); _grad_disp_old[i] = &coupledGradientOld("displacements", i); } // set unused dimensions to zero for (unsigned i = _ndisp; i < 3; ++i) { _disp[i] = &_zero; _disp_var_num[i] = 0; while (_dictator.isPorousFlowVariable(_disp_var_num[i])) _disp_var_num[i]++; // increment until disp_var_num[i] is not a porflow var _grad_disp[i] = &_grad_zero; _grad_disp_old[i] = &_grad_zero; } if (_nodal_material == true) mooseError("PorousFlowVolumetricStrain classes are only defined for at_nodes = false"); }
ComputeCosseratIncrementalSmallStrain::ComputeCosseratIncrementalSmallStrain(const InputParameters & parameters) : ComputeIncrementalStrainBase(parameters), _curvature(declareProperty<RankTwoTensor>("curvature")), _nrots(coupledComponents("Cosserat_rotations")), _wc(_nrots), _wc_old(_nrots), _grad_wc(_nrots), _grad_wc_old(_nrots), _curvature_old(declarePropertyOld<RankTwoTensor>("curvature")), _curvature_increment(declareProperty<RankTwoTensor>("curvature_increment")) { if (_nrots != 3) mooseError("ComputeCosseratSmallStrain: This Material is only defined for 3-dimensional simulations so 3 Cosserat rotation variables are needed"); for (unsigned i = 0; i < _nrots; ++i) { _wc[i] = &coupledValue("Cosserat_rotations", i); _wc_old[i] = &coupledValueOld("Cosserat_rotations", i); _grad_wc[i] = &coupledGradient("Cosserat_rotations", i); _grad_wc_old[i] = &coupledGradientOld("Cosserat_rotations", i); } }
ComputeIncrementalStrainBase::ComputeIncrementalStrainBase(const InputParameters & parameters) : ComputeStrainBase(parameters), _grad_disp_old(3), _strain_rate(declareProperty<RankTwoTensor>(_base_name + "strain_rate")), _strain_increment(declareProperty<RankTwoTensor>(_base_name + "strain_increment")), _rotation_increment(declareProperty<RankTwoTensor>(_base_name + "rotation_increment")), _deformation_gradient(declareProperty<RankTwoTensor>(_base_name + "deformation_gradient")), _mechanical_strain_old(declarePropertyOld<RankTwoTensor>(_base_name + "mechanical_strain")), _total_strain_old(declarePropertyOld<RankTwoTensor>(_base_name + "total_strain")), _eigenstrains_old(_eigenstrain_names.size()) { for (unsigned int i = 0; i < _eigenstrains_old.size(); ++i) _eigenstrains_old[i] = &getMaterialPropertyOld<RankTwoTensor>(_eigenstrain_names[i]); // fetch coupled old displacement gradient, setting components for unused dimensions to zero for (unsigned int i = 0; i < 3; ++i) { if (_fe_problem.isTransient() && i < _ndisp) _grad_disp_old[i] = &coupledGradientOld("displacements", i); else _grad_disp_old[i] = &_grad_zero; } }
CoupledConvection::CoupledConvection(const InputParameters & parameters) : Kernel(parameters), _velocity_vector(getParam<bool>("lag_coupling") ? coupledGradientOld("velocity_vector") : coupledGradient("velocity_vector")) {}
AbaqusUmatMaterial::AbaqusUmatMaterial(const std::string & name, InputParameters parameters) : SolidModel( name, parameters ), _plugin(getParam<FileName>("plugin")), _mechanical_constants(getParam<std::vector<Real> >("mechanical_constants")), _thermal_constants(getParam<std::vector<Real> >("thermal_constants")), _num_state_vars(getParam<unsigned int>("num_state_vars")), _grad_disp_x(coupledGradient("disp_x")), _grad_disp_y(coupledGradient("disp_y")), _grad_disp_z(coupledGradient("disp_z")), _grad_disp_x_old(coupledGradientOld("disp_x")), _grad_disp_y_old(coupledGradientOld("disp_y")), _grad_disp_z_old(coupledGradientOld("disp_z")), _state_var(declareProperty<std::vector<Real> >("state_var")), _state_var_old(declarePropertyOld<std::vector<Real> >("state_var")), _Fbar(declareProperty<ColumnMajorMatrix>("Fbar")), _Fbar_old(declarePropertyOld<ColumnMajorMatrix>("Fbar")), _elastic_strain_energy(declareProperty<Real>("elastic_strain_energy")), _plastic_dissipation(declareProperty<Real>("plastic_dissipation")), _creep_dissipation(declareProperty<Real>("creep_dissipation")) { #if defined(METHOD) _plugin += std::string("-") + QUOTE(METHOD) + ".plugin"; #endif //Size and create full (mechanical+thermal) material property array _num_props = _mechanical_constants.size() + _thermal_constants.size(); std::vector<Real> props_array(_num_props); for (unsigned int i=0; i<_mechanical_constants.size(); ++i) props_array[i] = _mechanical_constants[i]; for (unsigned int i=_mechanical_constants.size(); i<_num_props; ++i) props_array[i] = _thermal_constants[i]; //Read mesh dimension and size UMAT arrays if (_mesh.dimension()==3) //3D case { _NTENS=6; //Size of the stress or strain component array (NDI+NSHR) _NSHR=3; //Number of engineering shear stress components _NDI=3; //Number of direct stress components (always 3) } else if (_mesh.dimension()==2) //2D case { _NTENS=4; _NSHR=1; _NDI=3; } _STATEV = new Real[_num_state_vars]; _DDSDDT = new Real[_NTENS]; _DRPLDE = new Real[_NTENS]; _STRAN = new Real[_NTENS]; _DFGRD0 = new Real[9]; _DFGRD1 = new Real[9]; _STRESS = new Real[_NTENS]; _DDSDDE = new Real[_NTENS*_NTENS]; _DSTRAN = new Real[_NTENS]; _PROPS = new Real[_num_props]; for (unsigned int i=0; i<_num_state_vars; ++i) { _STATEV[i] = 0.0; } for (int i=0; i<_NTENS; ++i) { _DDSDDT[i] = 0.0; _DRPLDE[i] = 0.0; _STRAN[i] = 0.0; _STRESS[i] = 0.0; _DSTRAN[i] = 0.0; } for (unsigned int i=0; i<9; ++i) { _DFGRD0[i] = 0.0; _DFGRD1[i] = 0.0; } for (int i=0; i<_NTENS*_NTENS; ++i) { _DDSDDE[i] = 0.0; } //Assign materials properties from vector form into an array for (unsigned int i=0; i<_num_props; ++i) { _PROPS[i] = props_array[i]; } //Size UMAT state variable (NSTATV) and material constant (NPROPS) arrays _NSTATV = _num_state_vars; _NPROPS = _num_props; // Open the library _handle = dlopen(_plugin.c_str(), RTLD_LAZY); if (!_handle) { std::ostringstream error; error << "Cannot open library: " << dlerror() << '\n'; mooseError(error.str()); } // Reset errors dlerror(); // Snag the function pointer from the library { void * pointer = dlsym(_handle, "umat_"); _umat = *reinterpret_cast<umat_t*>( &pointer ); } // Catch errors const char *dlsym_error = dlerror(); if (dlsym_error) { dlclose(_handle); std::ostringstream error; error << "Cannot load symbol 'umat_': " << dlsym_error << '\n'; mooseError(error.str()); } }