float GetCurrAcc(float V0, float V1, float dist, float a0, float a1)
{
float t10,t11,t0,t1;
t10 = t_xx (V0, V1, a0, a1, dist, 1.0f);
t11 = t_xx (V0, V1, a0, a1, dist, -1.0f);
t1 = t_1 (t10, t11);
t0 = t_0 (V0, V1, a0, a1, t1);
return getA (t0, a1, a0);
}
void
TvergaardHutchinsonModel<EvalT, Traits>::computeState(
typename Traits::EvalData workset,
DepFieldMap dep_fields,
FieldMap eval_fields)
{
// extract dependent MDFields
auto jump = *dep_fields["Vector Jump"];
auto basis = *dep_fields["Current Basis"];
// extract evaluated MDFields
auto traction = *eval_fields["Cohesive_Traction"];
auto traction_normal = *eval_fields["Normal_Traction"];
auto traction_shear = *eval_fields["Shear_Traction"];
auto jump_normal = *eval_fields["Normal_Jump"];
auto jump_shear = *eval_fields["Shear_Jump"];
for (int cell(0); cell < workset.numCells; ++cell) {
for (int pt(0); pt < num_pts_; ++pt) {
// current basis vector
minitensor::Vector<ScalarT> g_0(
minitensor::Source::ARRAY, 3, basis, cell, pt, 0, 0);
minitensor::Vector<ScalarT> g_1(
minitensor::Source::ARRAY, 3, basis, cell, pt, 1, 0);
minitensor::Vector<ScalarT> n(
minitensor::Source::ARRAY, 3, basis, cell, pt, 2, 0);
// construct orthogonal unit basis
minitensor::Vector<ScalarT> t_0(0.0, 0.0, 0.0), t_1(0.0, 0.0, 0.0);
t_0 = g_0 / norm(g_0);
t_1 = cross(n, t_0);
// construct transformation matrix Q (2nd order tensor)
minitensor::Tensor<ScalarT> Q(3, minitensor::Filler::ZEROS);
// manually fill Q = [t_0; t_1; n];
Q(0, 0) = t_0(0);
Q(1, 0) = t_0(1);
Q(2, 0) = t_0(2);
Q(0, 1) = t_1(0);
Q(1, 1) = t_1(1);
Q(2, 1) = t_1(2);
Q(0, 2) = n(0);
Q(1, 2) = n(1);
Q(2, 2) = n(2);
// global and local jump
minitensor::Vector<ScalarT> jump_global(
minitensor::Source::ARRAY, 3, jump, cell, pt, 0);
minitensor::Vector<ScalarT> jump_local(3);
jump_local = minitensor::dot(minitensor::transpose(Q), jump_global);
// define shear and normal components of jump
// needed for interpenetration
// Note: need to protect sqrt around zero when using Sacado
ScalarT JumpNormal, JumpShear, IntermediateValue;
JumpNormal = jump_local(2);
IntermediateValue =
jump_local(0) * jump_local(0) + jump_local(1) * jump_local(1);
if (IntermediateValue > 0.0)
JumpShear = sqrt(IntermediateValue);
else
JumpShear = 0.0;
// matrix beta that controls relative effect of shear and normal opening
minitensor::Tensor<ScalarT> beta(3, minitensor::Filler::ZEROS);
beta(0, 0) = beta_0;
beta(1, 1) = beta_1;
beta(2, 2) = beta_2;
// compute scalar effective jump
ScalarT jump_eff;
IntermediateValue =
minitensor::dot(jump_local, minitensor::dot(beta, jump_local));
if (IntermediateValue > 0.0)
jump_eff = sqrt(IntermediateValue);
else
jump_eff = 0.0;
// traction-separation law from Tvergaard-Hutchinson 1992
ScalarT sigma_eff;
// Sacado::ScalarValue<ScalarT>::eval
if (jump_eff <= delta_1)
sigma_eff = sigma_c * jump_eff / delta_1;
else if (jump_eff > delta_1 && jump_eff <= delta_2)
sigma_eff = sigma_c;
else if (jump_eff > delta_2 && jump_eff <= delta_c)
sigma_eff = sigma_c * (delta_c - jump_eff) / (delta_c - delta_2);
else
sigma_eff = 0.0;
// construct traction vector
minitensor::Vector<ScalarT> traction_local(3);
traction_local.clear();
if (jump_eff != 0)
traction_local =
minitensor::dot(beta, jump_local) * sigma_eff / jump_eff;
// norm of the local shear components of the traction
ScalarT TractionShear;
IntermediateValue = traction_local(0) * traction_local(0) +
traction_local(1) * traction_local(1);
if (IntermediateValue > 0.0)
TractionShear = sqrt(IntermediateValue);
else
TractionShear = 0.0;
// global traction vector
minitensor::Vector<ScalarT> traction_global(3);
traction_global = minitensor::dot(Q, traction_local);
traction(cell, pt, 0) = traction_global(0);
traction(cell, pt, 1) = traction_global(1);
traction(cell, pt, 2) = traction_global(2);
// update state variables
traction_normal(cell, pt) = traction_local(2);
traction_shear(cell, pt) = TractionShear;
jump_normal(cell, pt) = JumpNormal;
jump_shear(cell, pt) = JumpShear;
}
}
}
