void
MultiPlasticityDebugger::checkSolution(const RankFourTensor & E_inv)
{
Moose::err << "\n\n+++++++++++++++++++++\nChecking the Solution\n";
Moose::err << "(Ie, checking Ax = b)\n+++++++++++++++++++++\n";
outputAndCheckDebugParameters();
std::vector<bool> act;
act.assign(_num_surfaces, true);
std::vector<bool> deactivated_due_to_ld;
deactivated_due_to_ld.assign(_num_surfaces, false);
RankTwoTensor delta_dp = -E_inv * _fspb_debug_stress;
std::vector<Real> orig_rhs;
calculateRHS(_fspb_debug_stress,
_fspb_debug_intnl,
_fspb_debug_intnl,
_fspb_debug_pm,
delta_dp,
orig_rhs,
act,
true,
deactivated_due_to_ld);
Moose::err << "\nb = ";
for (unsigned i = 0; i < orig_rhs.size(); ++i)
Moose::err << orig_rhs[i] << " ";
Moose::err << "\n\n";
std::vector<std::vector<Real>> jac_coded;
calculateJacobian(_fspb_debug_stress,
_fspb_debug_intnl,
_fspb_debug_pm,
E_inv,
act,
deactivated_due_to_ld,
jac_coded);
Moose::err
<< "Before checking Ax=b is correct, check that the Jacobians given below are equal.\n";
Moose::err
<< "The hand-coded Jacobian is used in calculating the solution 'x', given 'b' above.\n";
Moose::err << "Note that this only includes degrees of freedom that aren't deactivated due to "
"linear dependence.\n";
Moose::err << "Hand-coded Jacobian:\n";
for (unsigned row = 0; row < jac_coded.size(); ++row)
{
for (unsigned col = 0; col < jac_coded.size(); ++col)
Moose::err << jac_coded[row][col] << " ";
Moose::err << "\n";
}
deactivated_due_to_ld.assign(_num_surfaces,
false); // this potentially gets changed by nrStep, below
RankTwoTensor dstress;
std::vector<Real> dpm;
std::vector<Real> dintnl;
nrStep(_fspb_debug_stress,
_fspb_debug_intnl,
_fspb_debug_intnl,
_fspb_debug_pm,
E_inv,
delta_dp,
dstress,
dpm,
dintnl,
act,
deactivated_due_to_ld);
std::vector<bool> active_not_deact(_num_surfaces);
for (unsigned surface = 0; surface < _num_surfaces; ++surface)
active_not_deact[surface] = !deactivated_due_to_ld[surface];
std::vector<Real> x;
x.assign(orig_rhs.size(), 0);
unsigned ind = 0;
for (unsigned i = 0; i < 3; ++i)
for (unsigned j = 0; j <= i; ++j)
x[ind++] = dstress(i, j);
for (unsigned surface = 0; surface < _num_surfaces; ++surface)
if (active_not_deact[surface])
x[ind++] = dpm[surface];
for (unsigned model = 0; model < _num_models; ++model)
if (anyActiveSurfaces(model, active_not_deact))
x[ind++] = dintnl[model];
mooseAssert(ind == orig_rhs.size(),
"Incorrect extracting of changes from NR solution in the "
"finite-difference checking of nrStep");
Moose::err << "\nThis yields x =";
for (unsigned i = 0; i < orig_rhs.size(); ++i)
Moose::err << x[i] << " ";
Moose::err << "\n";
std::vector<std::vector<Real>> jac_fd;
fdJacobian(_fspb_debug_stress,
_fspb_debug_intnl,
_fspb_debug_intnl,
_fspb_debug_pm,
delta_dp,
E_inv,
true,
jac_fd);
Moose::err << "\nThe finite-difference Jacobian is used to multiply by this 'x',\n";
Moose::err << "in order to check that the solution is correct\n";
Moose::err << "Finite-difference Jacobian:\n";
for (unsigned row = 0; row < jac_fd.size(); ++row)
{
for (unsigned col = 0; col < jac_fd.size(); ++col)
Moose::err << jac_fd[row][col] << " ";
Moose::err << "\n";
}
Real L2_numer = 0;
Real L2_denom = 0;
for (unsigned row = 0; row < jac_coded.size(); ++row)
for (unsigned col = 0; col < jac_coded.size(); ++col)
{
L2_numer += Utility::pow<2>(jac_coded[row][col] - jac_fd[row][col]);
L2_denom += Utility::pow<2>(jac_coded[row][col] + jac_fd[row][col]);
}
Moose::err << "Relative L2norm of the hand-coded and finite-difference Jacobian is "
<< std::sqrt(L2_numer / L2_denom) / 0.5 << "\n";
std::vector<Real> fd_times_x;
fd_times_x.assign(orig_rhs.size(), 0);
for (unsigned row = 0; row < orig_rhs.size(); ++row)
for (unsigned col = 0; col < orig_rhs.size(); ++col)
fd_times_x[row] += jac_fd[row][col] * x[col];
Moose::err << "\n(Finite-difference Jacobian)*x =\n";
for (unsigned i = 0; i < orig_rhs.size(); ++i)
Moose::err << fd_times_x[i] << " ";
Moose::err << "\n";
Moose::err << "Recall that b = \n";
for (unsigned i = 0; i < orig_rhs.size(); ++i)
Moose::err << orig_rhs[i] << " ";
Moose::err << "\n";
L2_numer = 0;
L2_denom = 0;
for (unsigned i = 0; i < orig_rhs.size(); ++i)
{
L2_numer += Utility::pow<2>(orig_rhs[i] - fd_times_x[i]);
L2_denom += Utility::pow<2>(orig_rhs[i] + fd_times_x[i]);
}
Moose::err << "\nRelative L2norm of these is " << std::sqrt(L2_numer / L2_denom) / 0.5 << "\n";
}
bool
FiniteStrainPlasticBase::returnMap(const RankTwoTensor & stress_old, const RankTwoTensor & plastic_strain_old, const std::vector<Real> & intnl_old, const RankTwoTensor & delta_d, const RankFourTensor & E_ijkl, RankTwoTensor & stress, RankTwoTensor & plastic_strain, std::vector<Real> & intnl, std::vector<Real> & f, unsigned int & iter)
{
// Assume this strain increment does not induce any plasticity
// This is the elastic-predictor
stress = stress_old + E_ijkl * delta_d; // the trial stress
plastic_strain = plastic_strain_old;
for (unsigned i = 0; i < intnl_old.size() ; ++i)
intnl[i] = intnl_old[i];
iter = 0;
yieldFunction(stress, intnl, f);
Real nr_res2 = 0;
for (unsigned i = 0 ; i < f.size() ; ++i)
nr_res2 += 0.5*std::pow( std::max(f[i], 0.0)/_f_tol[i], 2);
if (nr_res2 < 0.5)
// a purely elastic increment.
// All output variables have been calculated
return true;
// So, from here on we know that the trial stress
// is inadmissible, and we have to return from that
// value to the yield surface. There are three
// types of constraints we have to satisfy, listed
// below, and calculated in calculateConstraints(...)
// Plastic strain constraint, L2 norm must be zero (up to a tolerance)
RankTwoTensor epp;
// Yield function constraint passed to this function as
// std::vector<Real> & f
// Each yield function must be <= 0 (up to tolerance)
// Internal constraint(s), must be zero (up to a tolerance)
std::vector<Real> ic;
// During the Newton-Raphson procedure, we'll be
// changing the following parameters in order to
// (attempt to) satisfy the constraints.
RankTwoTensor dstress; // change in stress
std::vector<Real> dpm; // change in plasticity multipliers ("consistency parameters")
std::vector<Real> dintnl; // change in internal parameters
// The following are used in the Newton-Raphson
// Inverse of E_ijkl (assuming symmetric)
RankFourTensor E_inv = E_ijkl.invSymm();
// convenience variable that holds the change in plastic strain incurred during the return
// delta_dp = plastic_strain - plastic_strain_old
// delta_dp = E^{-1}*(trial_stress - stress), where trial_stress = E*(strain - plastic_strain_old)
RankTwoTensor delta_dp;
// The "consistency parameters" (plastic multipliers)
// Change in plastic strain in this timestep = pm*flowPotential
// Each pm must be non-negative
std::vector<Real> pm;
pm.assign(numberOfYieldFunctions(), 0.0);
// whether line-searching was successful
bool ls_success = true;
// The Newton-Raphson loops
while (nr_res2 > 0.5 && iter < _max_iter && ls_success)
{
iter++;
// calculate dstress, dpm and dintnl for one full Newton-Raphson step
nrStep(stress, intnl_old, intnl, pm, E_inv, delta_dp, dstress, dpm, dintnl);
// perform a line search
// The line-search will exit with updated values
ls_success = lineSearch(nr_res2, stress, intnl_old, intnl, pm, E_inv, delta_dp, dstress, dpm, dintnl, f, epp, ic);
}
if (iter >= _max_iter || !ls_success)
{
stress = stress_old;
for (unsigned i = 0; i < intnl_old.size() ; ++i)
intnl[i] = intnl_old[i];
return false;
}
else
{
plastic_strain += delta_dp;
return true;
}
}
