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());
}
}
