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