void
TensorMechanicsPlasticModel::dyieldFunction_dintnlV(const RankTwoTensor & stress,
Real intnl,
std::vector<Real> & df_dintnl) const
{
return df_dintnl.assign(1, dyieldFunction_dintnl(stress, intnl));
}
void
MultiPlasticityLinearSystem::calculateJacobian(const RankTwoTensor & stress, const std::vector<Real> & intnl, const std::vector<Real> & pm, const RankFourTensor & E_inv, const std::vector<bool> & active, const std::vector<bool> & deactivated_due_to_ld, std::vector<std::vector<Real> > & jac)
{
// see comments at the start of .h file
mooseAssert(intnl.size() == _num_models, "Size of intnl is " << intnl.size() << " which is incorrect in calculateJacobian");
mooseAssert(pm.size() == _num_surfaces, "Size of pm is " << pm.size() << " which is incorrect in calculateJacobian");
mooseAssert(active.size() == _num_surfaces, "Size of active is " << active.size() << " which is incorrect in calculateJacobian");
mooseAssert(deactivated_due_to_ld.size() == _num_surfaces, "Size of deactivated_due_to_ld is " << deactivated_due_to_ld.size() << " which is incorrect in calculateJacobian");
unsigned ind = 0;
unsigned active_surface_ind = 0;
std::vector<bool> active_surface(_num_surfaces); // active and not deactivated_due_to_ld
for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface)
active_surface[surface] = (active[surface] && !deactivated_due_to_ld[surface]);
unsigned num_active_surface = 0;
for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface)
if (active_surface[surface])
num_active_surface++;
std::vector<bool> active_model(_num_models); // whether a model has surfaces that are active and not deactivated_due_to_ld
for (unsigned model = 0 ; model < _num_models ; ++model)
active_model[model] = anyActiveSurfaces(model, active_surface);
unsigned num_active_model = 0;
for (unsigned model = 0 ; model < _num_models ; ++model)
if (active_model[model])
num_active_model++;
ind = 0;
std::vector<unsigned int> active_model_index(_num_models);
for (unsigned model = 0 ; model < _num_models ; ++model)
if (active_model[model])
active_model_index[model] = ind++;
else
active_model_index[model] = _num_models+1; // just a dummy, that will probably cause a crash if something goes wrong
std::vector<RankTwoTensor> df_dstress;
dyieldFunction_dstress(stress, intnl, active_surface, df_dstress);
std::vector<Real> df_dintnl;
dyieldFunction_dintnl(stress, intnl, active_surface, df_dintnl);
std::vector<RankTwoTensor> r;
flowPotential(stress, intnl, active, r);
std::vector<RankFourTensor> dr_dstress;
dflowPotential_dstress(stress, intnl, active, dr_dstress);
std::vector<RankTwoTensor> dr_dintnl;
dflowPotential_dintnl(stress, intnl, active, dr_dintnl);
std::vector<Real> h;
hardPotential(stress, intnl, active, h);
std::vector<RankTwoTensor> dh_dstress;
dhardPotential_dstress(stress, intnl, active, dh_dstress);
std::vector<Real> dh_dintnl;
dhardPotential_dintnl(stress, intnl, active, dh_dintnl);
// d(epp)/dstress = sum_{active alpha} pm[alpha]*dr_dstress
RankFourTensor depp_dstress;
ind = 0;
for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface)
if (active[surface]) // includes deactivated_due_to_ld
depp_dstress += pm[surface]*dr_dstress[ind++];
depp_dstress += E_inv;
// d(epp)/dpm_{active_surface_index} = r_{active_surface_index}
std::vector<RankTwoTensor> depp_dpm;
depp_dpm.resize(num_active_surface);
ind = 0;
active_surface_ind = 0;
for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface)
{
if (active[surface])
{
if (active_surface[surface]) // do not include the deactived_due_to_ld, since their pm are not dofs in the NR
depp_dpm[active_surface_ind++] = r[ind];
ind++;
}
}
// d(epp)/dintnl_{active_model_index} = sum(pm[asdf]*dr_dintnl[fdsa])
std::vector<RankTwoTensor> depp_dintnl;
depp_dintnl.assign(num_active_model, RankTwoTensor());
ind = 0;
for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface)
{
if (active[surface])
{
unsigned int model_num = modelNumber(surface);
if (active_model[model_num]) // only include models with surfaces which are still active after deactivated_due_to_ld
depp_dintnl[active_model_index[model_num]] += pm[surface]*dr_dintnl[ind];
ind++;
}
}
// df_dstress has been calculated above
// df_dpm is always zero
// df_dintnl has been calculated above, but only the active_surface+active_model stuff needs to be included in Jacobian: see below
std::vector<RankTwoTensor> dic_dstress;
dic_dstress.assign(num_active_model, RankTwoTensor());
ind = 0;
for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface)
{
if (active[surface])
{
unsigned int model_num = modelNumber(surface);
if (active_model[model_num]) // only include ic for models with active_surface (ie, if model only contains deactivated_due_to_ld don't include it)
dic_dstress[active_model_index[model_num]] += pm[surface]*dh_dstress[ind];
ind++;
}
}
std::vector<std::vector<Real> > dic_dpm;
dic_dpm.resize(num_active_model);
ind = 0;
active_surface_ind = 0;
for (unsigned model = 0 ; model < num_active_model ; ++model)
dic_dpm[model].assign(num_active_surface, 0);
for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface)
{
if (active[surface])
{
if (active_surface[surface]) // only take derivs wrt active-but-not-deactivated_due_to_ld pm
{
unsigned int model_num = modelNumber(surface);
// if (active_model[model_num]) // do not need this check as if the surface has active_surface, the model must be deemed active!
dic_dpm[active_model_index[model_num]][active_surface_ind] = h[ind];
active_surface_ind++;
}
ind++;
}
}
std::vector<std::vector<Real> > dic_dintnl;
dic_dintnl.resize(num_active_model);
for (unsigned model = 0 ; model < num_active_model ; ++model)
{
dic_dintnl[model].assign(num_active_model, 0);
dic_dintnl[model][model] = 1; // deriv wrt internal parameter
}
ind = 0;
for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface)
{
if (active[surface])
{
unsigned int model_num = modelNumber(surface);
if (active_model[model_num]) // only the models that contain surfaces that are still active after deactivation_due_to_ld
dic_dintnl[active_model_index[model_num]][active_model_index[model_num]] += pm[surface]*dh_dintnl[ind];
ind++;
}
}
unsigned int dim = 3;
unsigned int system_size = 6 + num_active_surface + num_active_model; // "6" comes from symmeterizing epp
jac.resize(system_size);
for (unsigned i = 0 ; i < system_size ; ++i)
jac[i].assign(system_size, 0);
unsigned int row_num = 0;
unsigned int col_num = 0;
for (unsigned i = 0 ; i < dim ; ++i)
for (unsigned j = 0 ; j <= i ; ++j)
{
for (unsigned k = 0 ; k < dim ; ++k)
for (unsigned l = 0 ; l <= k ; ++l)
jac[col_num][row_num++] = depp_dstress(i, j, k, l) + (k != l ? depp_dstress(i, j, l, k) : 0); // extra part is needed because i assume dstress(i, j) = dstress(j, i)
for (unsigned surface = 0 ; surface < num_active_surface ; ++surface)
jac[col_num][row_num++] = depp_dpm[surface](i, j);
for (unsigned a = 0 ; a < num_active_model ; ++a)
jac[col_num][row_num++] = depp_dintnl[a](i, j);
row_num = 0;
col_num++;
}
ind = 0;
for (unsigned surface = 0 ; surface < _num_surfaces ; ++surface)
if (active_surface[surface])
{
for (unsigned k = 0 ; k < dim ; ++k)
for (unsigned l = 0 ; l <= k ; ++l)
jac[col_num][row_num++] = df_dstress[ind](k, l) + (k != l ? df_dstress[ind](l, k) : 0); // extra part is needed because i assume dstress(i, j) = dstress(j, i)
for (unsigned beta = 0 ; beta < num_active_surface ; ++beta)
jac[col_num][row_num++] = 0; // df_dpm
for (unsigned model = 0 ; model < _num_models ; ++model)
if (active_model[model]) // only use df_dintnl for models in active_model
{
if (modelNumber(surface) == model)
jac[col_num][row_num++] = df_dintnl[ind];
else
jac[col_num][row_num++] = 0;
}
ind++;
row_num = 0;
col_num++;
}
for (unsigned a = 0 ; a < num_active_model ; ++a)
{
for (unsigned k = 0 ; k < dim ; ++k)
for (unsigned l = 0 ; l <= k ; ++l)
jac[col_num][row_num++] = dic_dstress[a](k, l) + (k != l ? dic_dstress[a](l, k) : 0); // extra part is needed because i assume dstress(i, j) = dstress(j, i)
for (unsigned alpha = 0 ; alpha < num_active_surface ; ++alpha)
jac[col_num][row_num++] = dic_dpm[a][alpha];
for (unsigned b = 0 ; b < num_active_model ; ++b)
jac[col_num][row_num++] = dic_dintnl[a][b];
row_num = 0;
col_num++;
}
mooseAssert(col_num == system_size, "Incorrect filling of cols in Jacobian");
}
void
MultiPlasticityDebugger::checkDerivatives()
{
Moose::err
<< "\n\n++++++++++++++++++++++++\nChecking the derivatives\n++++++++++++++++++++++++\n";
outputAndCheckDebugParameters();
std::vector<bool> act;
act.assign(_num_surfaces, true);
Moose::err << "\ndyieldFunction_dstress. Relative L2 norms.\n";
std::vector<RankTwoTensor> df_dstress;
std::vector<RankTwoTensor> fddf_dstress;
dyieldFunction_dstress(_fspb_debug_stress, _fspb_debug_intnl, act, df_dstress);
fddyieldFunction_dstress(_fspb_debug_stress, _fspb_debug_intnl, fddf_dstress);
for (unsigned surface = 0; surface < _num_surfaces; ++surface)
{
Moose::err << "surface = " << surface << " Relative L2norm = "
<< 2 * (df_dstress[surface] - fddf_dstress[surface]).L2norm() /
(df_dstress[surface] + fddf_dstress[surface]).L2norm()
<< "\n";
Moose::err << "Coded:\n";
df_dstress[surface].print();
Moose::err << "Finite difference:\n";
fddf_dstress[surface].print();
}
Moose::err << "\ndyieldFunction_dintnl.\n";
std::vector<Real> df_dintnl;
dyieldFunction_dintnl(_fspb_debug_stress, _fspb_debug_intnl, act, df_dintnl);
Moose::err << "Coded:\n";
for (unsigned surface = 0; surface < _num_surfaces; ++surface)
Moose::err << df_dintnl[surface] << " ";
Moose::err << "\n";
std::vector<Real> fddf_dintnl;
fddyieldFunction_dintnl(_fspb_debug_stress, _fspb_debug_intnl, fddf_dintnl);
Moose::err << "Finite difference:\n";
for (unsigned surface = 0; surface < _num_surfaces; ++surface)
Moose::err << fddf_dintnl[surface] << " ";
Moose::err << "\n";
Moose::err << "\ndflowPotential_dstress. Relative L2 norms.\n";
std::vector<RankFourTensor> dr_dstress;
std::vector<RankFourTensor> fddr_dstress;
dflowPotential_dstress(_fspb_debug_stress, _fspb_debug_intnl, act, dr_dstress);
fddflowPotential_dstress(_fspb_debug_stress, _fspb_debug_intnl, fddr_dstress);
for (unsigned surface = 0; surface < _num_surfaces; ++surface)
{
Moose::err << "surface = " << surface << " Relative L2norm = "
<< 2 * (dr_dstress[surface] - fddr_dstress[surface]).L2norm() /
(dr_dstress[surface] + fddr_dstress[surface]).L2norm()
<< "\n";
Moose::err << "Coded:\n";
dr_dstress[surface].print();
Moose::err << "Finite difference:\n";
fddr_dstress[surface].print();
}
Moose::err << "\ndflowPotential_dintnl. Relative L2 norms.\n";
std::vector<RankTwoTensor> dr_dintnl;
std::vector<RankTwoTensor> fddr_dintnl;
dflowPotential_dintnl(_fspb_debug_stress, _fspb_debug_intnl, act, dr_dintnl);
fddflowPotential_dintnl(_fspb_debug_stress, _fspb_debug_intnl, fddr_dintnl);
for (unsigned surface = 0; surface < _num_surfaces; ++surface)
{
Moose::err << "surface = " << surface << " Relative L2norm = "
<< 2 * (dr_dintnl[surface] - fddr_dintnl[surface]).L2norm() /
(dr_dintnl[surface] + fddr_dintnl[surface]).L2norm()
<< "\n";
Moose::err << "Coded:\n";
dr_dintnl[surface].print();
Moose::err << "Finite difference:\n";
fddr_dintnl[surface].print();
}
}
void
FiniteStrainPlasticBase::calculateJacobian(const RankTwoTensor & stress, const std::vector<Real> & intnl, const std::vector<Real> & pm, const RankFourTensor & E_inv, std::vector<std::vector<Real> > & jac)
{
// construct quantities used in the Newton-Raphson linear system
// These should have been defined by the derived classes, if
// they are different from the default functions given elsewhere
// in this class
std::vector<RankTwoTensor> df_dstress;
dyieldFunction_dstress(stress, intnl, df_dstress);
std::vector<std::vector<Real> > df_dintnl;
dyieldFunction_dintnl(stress, intnl, df_dintnl);
std::vector<RankTwoTensor> r;
flowPotential(stress, intnl, r);
std::vector<RankFourTensor> dr_dstress;
dflowPotential_dstress(stress, intnl, dr_dstress);
std::vector<std::vector<RankTwoTensor> > dr_dintnl;
dflowPotential_dintnl(stress, intnl, dr_dintnl);
std::vector<std::vector<Real> > h;
hardPotential(stress, intnl, h);
std::vector<std::vector<RankTwoTensor> > dh_dstress;
dhardPotential_dstress(stress, intnl, dh_dstress);
std::vector<std::vector<std::vector<Real> > > dh_dintnl;
dhardPotential_dintnl(stress, intnl, dh_dintnl);
// construct matrix entries
// In the following
// epp = pm*r - E_inv*(trial_stress - stress) = pm*r - delta_dp
// f = yield function
// ic = intnl - intnl_old + pm*h
RankFourTensor depp_dstress;
for (unsigned alpha = 0 ; alpha < numberOfYieldFunctions() ; ++alpha)
depp_dstress += pm[alpha]*dr_dstress[alpha];
depp_dstress += E_inv;
std::vector<RankTwoTensor> depp_dpm;
depp_dpm.resize(numberOfYieldFunctions());
for (unsigned alpha = 0; alpha < numberOfYieldFunctions() ; ++alpha)
depp_dpm[alpha] = r[alpha];
std::vector<RankTwoTensor> depp_dintnl;
depp_dintnl.assign(numberOfInternalParameters(), RankTwoTensor());
for (unsigned a = 0; a < numberOfInternalParameters() ; ++a)
for (unsigned alpha = 0 ; alpha < numberOfYieldFunctions() ; ++alpha)
depp_dintnl[a] += pm[alpha]*dr_dintnl[alpha][a];
// df_dstress has been calculated above
// df_dpm is always zero
// df_dintnl has been calculated above
std::vector<RankTwoTensor> dic_dstress;
dic_dstress.assign(numberOfInternalParameters(), RankTwoTensor());
for (unsigned a = 0 ; a < numberOfInternalParameters() ; ++a)
for (unsigned alpha = 0 ; alpha < numberOfYieldFunctions() ; ++alpha)
dic_dstress[a] += pm[alpha]*dh_dstress[a][alpha];
std::vector<std::vector<Real> > dic_dpm;
dic_dpm.resize(numberOfInternalParameters());
for (unsigned a = 0 ; a < numberOfInternalParameters() ; ++a)
{
dic_dpm[a].resize(numberOfYieldFunctions());
for (unsigned alpha = 0 ; alpha < numberOfYieldFunctions() ; ++alpha)
dic_dpm[a][alpha] = h[a][alpha];
}
std::vector<std::vector<Real> > dic_dintnl;
dic_dintnl.resize(numberOfInternalParameters());
for (unsigned a = 0 ; a < numberOfInternalParameters() ; ++a)
{
dic_dintnl[a].assign(numberOfInternalParameters(), 0);
for (unsigned b = 0 ; b < numberOfInternalParameters() ; ++b)
for (unsigned alpha = 0 ; alpha < numberOfYieldFunctions() ; ++alpha)
dic_dintnl[a][b] += pm[alpha]*dh_dintnl[a][alpha][b];
dic_dintnl[a][a] += 1;
}
/**
* now construct the Jacobian
* It is:
* ( depp_dstress depp_dpm depp_dintnl )
* ( df_dstress 0 df_dintnl )
* ( dic_dstress dic_dpm dic_dintnl )
* For the "epp" terms, only the i>=j components are kept in the RHS, so only these terms are kept here too
*/
unsigned int dim = 3;
unsigned int system_size = 6 + numberOfYieldFunctions() + numberOfInternalParameters(); // "6" comes from symmeterizing epp
jac.resize(system_size);
for (unsigned i = 0 ; i < system_size ; ++i)
jac[i].resize(system_size);
unsigned int row_num = 0;
unsigned int col_num = 0;
for (unsigned i = 0 ; i < dim ; ++i)
for (unsigned j = 0 ; j <= i ; ++j)
{
for (unsigned k = 0 ; k < dim ; ++k)
for (unsigned l = 0 ; l <= k ; ++l)
jac[col_num][row_num++] = depp_dstress(i, j, k, l) + (k != l ? depp_dstress(i, j, l, k) : 0); // extra part is needed because i assume dstress(i, j) = dstress(j, i)
for (unsigned alpha = 0 ; alpha < numberOfYieldFunctions() ; ++alpha)
jac[col_num][row_num++] = depp_dpm[alpha](i, j);
for (unsigned a = 0 ; a < numberOfInternalParameters() ; ++a)
jac[col_num][row_num++] = depp_dintnl[a](i, j);
row_num = 0;
col_num++;
}
for (unsigned alpha = 0 ; alpha < numberOfYieldFunctions() ; ++alpha)
{
for (unsigned k = 0 ; k < dim ; ++k)
for (unsigned l = 0 ; l <= k ; ++l)
jac[col_num][row_num++] = df_dstress[alpha](k, l) + (k != l ? df_dstress[alpha](l, k) : 0); // extra part is needed because i assume dstress(i, j) = dstress(j, i)
for (unsigned beta = 0 ; beta < numberOfYieldFunctions() ; ++beta)
jac[col_num][row_num++] = 0;
for (unsigned a = 0 ; a < numberOfInternalParameters() ; ++a)
jac[col_num][row_num++] = df_dintnl[alpha][a];
row_num = 0;
col_num++;
}
for (unsigned a = 0 ; a < numberOfInternalParameters() ; ++a)
{
for (unsigned k = 0 ; k < dim ; ++k)
for (unsigned l = 0 ; l <= k ; ++l)
jac[col_num][row_num++] = dic_dstress[a](k, l) + (k != l ? dic_dstress[a](l, k) : 0); // extra part is needed because i assume dstress(i, j) = dstress(j, i)
for (unsigned alpha = 0 ; alpha < numberOfYieldFunctions() ; ++alpha)
jac[col_num][row_num++] = dic_dpm[a][alpha];
for (unsigned b = 0 ; b < numberOfInternalParameters() ; ++b)
jac[col_num][row_num++] = dic_dintnl[a][b];
row_num = 0;
col_num++;
}
}
