12      const std::string row_field_name, 
const std::string col_field_name,
 
   13      boost::shared_ptr<CommonData> common_data_ptr,
 
   14      boost::shared_ptr<HenckyOps::CommonData> common_hencky_data_ptr,
 
   15      boost::shared_ptr<MatrixDouble> m_D_ptr);
 
   16  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
 
   17                           EntitiesFieldData::EntData &col_data);
 
   22  boost::shared_ptr<MatrixDouble> 
mDPtr;
 
 
   30    OpCalculatePlasticInternalForceLhs_LogStrain_dEPImpl(
 
   31        const std::string row_field_name, 
const std::string col_field_name,
 
   32        boost::shared_ptr<CommonData> common_data_ptr,
 
   33        boost::shared_ptr<HenckyOps::CommonData> common_hencky_data_ptr,
 
   34        boost::shared_ptr<MatrixDouble> m_D_ptr)
 
   37      commonDataPtr(common_data_ptr),
 
   38      commonHenckyDataPtr(common_hencky_data_ptr), mDPtr(m_D_ptr) {
 
   39  AssemblyDomainEleOp::sYmm = 
false;
 
 
   46                                    EntitiesFieldData::EntData &col_data) {
 
   56  constexpr auto size_symm = (DIM * (DIM + 1)) / 2;
 
   59  auto &locMat = AssemblyDomainEleOp::locMat;
 
   61  const size_t nb_integration_pts = row_data.getN().size1();
 
   62  const size_t nb_row_base_functions = row_data.getN().size2();
 
   64  if (AssemblyDomainEleOp::rowType == MBVERTEX &&
 
   65      AssemblyDomainEleOp::rowSide == 0) {
 
   66    resDiff.resize(DIM * DIM * 
size_symm, nb_integration_pts, 
false);
 
   67    auto t_res_diff = getFTensor3FromMat<DIM, DIM, size_symm>(resDiff);
 
   68    auto t_D = getFTensor4DdgFromMat<DIM, DIM, 0>(*mDPtr);
 
   70        getFTensor4DdgFromMat<DIM, DIM>(commonHenckyDataPtr->matLogCdC);
 
   72        getFTensor2FromMat<DIM, DIM>(*(commonHenckyDataPtr->matGradPtr));
 
   75    for (
size_t gg = 0; gg != nb_integration_pts; ++gg) {
 
   79      t_DLogC_dC(
i, 
j, 
k, 
l) = t_D(
m, 
n, 
k, 
l) * t_logC_dC(
m, 
n, 
i, 
j);
 
   81      t_FDLogC_dC(
i, 
j, 
k, 
l) = t_F(
i, 
m) * t_DLogC_dC(
m, 
j, 
k, 
l);
 
   83      t_res_diff(
i, 
j, L) = t_FDLogC_dC(
i, 
j, 
k, 
l) * t_L(
k, 
l, L);
 
   90  auto t_w = AssemblyDomainEleOp::getFTensor0IntegrationWeight();
 
   91  auto t_row_diff_base = row_data.getFTensor1DiffN<DIM>();
 
   92  auto t_res_diff = getFTensor3FromMat<DIM, DIM, size_symm>(resDiff);
 
   94  for (
size_t gg = 0; gg != nb_integration_pts; ++gg) {
 
   95    double alpha = AssemblyDomainEleOp::getMeasure() * t_w;
 
   98    for (; rr != AssemblyDomainEleOp::nbRows / DIM; ++rr) {
 
  104      t_tmp(
i, L) = (t_res_diff(
i, 
j, L) * (alpha * t_row_diff_base(
j)));
 
  106      auto t_col_base = col_data.getFTensor0N(gg, 0);
 
  107      for (
size_t cc = 0; cc != AssemblyDomainEleOp::nbCols / 
size_symm; ++cc) {
 
  109        t_mat(
i, L) -= (t_col_base * t_tmp(
i, L));
 
  118    for (; rr < nb_row_base_functions; ++rr)
 
 
  133      const std::string row_field_name, 
const std::string col_field_name,
 
  134      boost::shared_ptr<CommonData> common_data_ptr,
 
  135      boost::shared_ptr<HenckyOps::CommonData> common_hencky_data_ptr,
 
  136      boost::shared_ptr<MatrixDouble> m_D_ptr);
 
  137  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
 
  138                           EntitiesFieldData::EntData &col_data);
 
  143  boost::shared_ptr<MatrixDouble> 
mDPtr;
 
 
  150        const std::string row_field_name, 
const std::string col_field_name,
 
  151        boost::shared_ptr<CommonData> common_data_ptr,
 
  152        boost::shared_ptr<HenckyOps::CommonData> common_hencky_data_ptr,
 
  153        boost::shared_ptr<MatrixDouble> m_D_ptr)
 
  156      commonDataPtr(common_data_ptr),
 
  157      commonHenckyDataPtr(common_hencky_data_ptr), mDPtr(m_D_ptr) {
 
  158  AssemblyDomainEleOp::sYmm = 
false;
 
 
  164    iNtegrate(EntitiesFieldData::EntData &row_data,
 
  165              EntitiesFieldData::EntData &col_data) {
 
  174  constexpr auto size_symm = (DIM * (DIM + 1)) / 2;
 
  177  auto &locMat = AssemblyDomainEleOp::locMat;
 
  179  const auto nb_integration_pts = AssemblyDomainEleOp::getGaussPts().size2();
 
  180  const auto nb_row_base_functions = row_data.getN().size2();
 
  182  if (AssemblyDomainEleOp::colType == MBVERTEX &&
 
  183      AssemblyDomainEleOp::colSide == 0) {
 
  185    resDiff.resize(
size_symm * DIM * DIM, nb_integration_pts, 
false);
 
  186    auto t_res_diff = getFTensor3FromMat<size_symm, DIM, DIM>(resDiff);
 
  188    auto t_res_flow_dstrain =
 
  189        getFTensor4DdgFromMat<DIM, DIM>(commonDataPtr->resFlowDstrain);
 
  190    auto t_grad = getFTensor2FromMat<DIM, DIM>(*(commonDataPtr->mGradPtr));
 
  192        getFTensor4DdgFromMat<DIM, DIM>(commonHenckyDataPtr->matLogCdC);
 
  195      ++t_res_flow_dstrain;
 
  206    for (
size_t gg = 0; gg != nb_integration_pts; ++gg) {
 
  211      t_diff_ls_dlogC_dC(
i, 
j, 
k, 
l) =
 
  212          (t_res_flow_dstrain(
i, 
j, 
m, 
n)) * (t_logC_dC(
m, 
n, 
k, 
l) / 2);
 
  218      t_res_diff(L, 
i, 
j) =
 
  219          (t_L(
m, 
n, L) * t_diff_ls_dlogC_dC(
m, 
n, 
k, 
l)) * t_dC_dF(
k, 
l, 
i, 
j);
 
  224  auto t_res_diff = getFTensor3FromMat<size_symm, DIM, DIM>(resDiff);
 
  226  auto t_w = AssemblyDomainEleOp::getFTensor0IntegrationWeight();
 
  227  auto t_row_base = row_data.getFTensor0N();
 
  228  for (
size_t gg = 0; gg != nb_integration_pts; ++gg) {
 
  229    double alpha = AssemblyDomainEleOp::getMeasure() * t_w;
 
  233    for (; rr != AssemblyDomainEleOp::nbRows / 
size_symm; ++rr) {
 
  234      const auto row_base = alpha * t_row_base;
 
  237      auto t_col_diff_base = col_data.getFTensor1DiffN<DIM>(gg, 0);
 
  238      for (
auto cc = 0; cc != AssemblyDomainEleOp::nbCols / DIM; ++cc) {
 
  239        t_mat(L, 
l) += row_base * (t_res_diff(L, 
l, 
k) * t_col_diff_base(
k));
 
  246    for (; rr < nb_row_base_functions; ++rr)
 
 
  259      const std::string row_field_name, 
const std::string col_field_name,
 
  260      boost::shared_ptr<CommonData> common_data_ptr,
 
  261      boost::shared_ptr<HenckyOps::CommonData> common_hencky_data_ptr,
 
  262      boost::shared_ptr<MatrixDouble> m_D_ptr);
 
  263  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
 
  264                           EntitiesFieldData::EntData &col_data);
 
  269  boost::shared_ptr<MatrixDouble> 
mDPtr;
 
 
  276        const std::string row_field_name, 
const std::string col_field_name,
 
  277        boost::shared_ptr<CommonData> common_data_ptr,
 
  278        boost::shared_ptr<HenckyOps::CommonData> common_hencky_data_ptr,
 
  279        boost::shared_ptr<MatrixDouble> m_D_ptr)
 
  282      commonDataPtr(common_data_ptr),
 
  283      commonHenckyDataPtr(common_hencky_data_ptr), mDPtr(m_D_ptr) {
 
  284  AssemblyDomainEleOp::sYmm = 
false;
 
 
  290    iNtegrate(EntitiesFieldData::EntData &row_data,
 
  291              EntitiesFieldData::EntData &col_data) {
 
  301  AssemblyDomainEleOp::locMat.resize(AssemblyDomainEleOp::nbRows, AssemblyDomainEleOp::nbCols,
 
  303  AssemblyDomainEleOp::locMat.clear();
 
  305  const auto nb_integration_pts = AssemblyDomainEleOp::getGaussPts().size2();
 
  306  const auto nb_row_base_functions = row_data.getN().size2();
 
  308  if (AssemblyDomainEleOp::colType == MBVERTEX &&
 
  309      AssemblyDomainEleOp::colSide == 0) {
 
  311    resDiff.resize(DIM * DIM, nb_integration_pts, 
false);
 
  312    auto t_res_diff = getFTensor2FromMat<DIM, DIM>(resDiff);
 
  313    auto t_grad = getFTensor2FromMat<DIM, DIM>(*(commonDataPtr->mGradPtr));
 
  315        getFTensor4DdgFromMat<DIM, DIM>(commonHenckyDataPtr->matLogCdC);
 
  317        getFTensor2SymmetricFromMat<DIM>(commonDataPtr->resCdStrain);
 
  328    for (
size_t gg = 0; gg != nb_integration_pts; ++gg) {
 
  333      t_diff_ls_dlog_c(
k, 
l) =
 
  334          (t_c_dstrain(
i, 
j)) * (t_logC_dC(
i, 
j, 
k, 
l) / 2);
 
  339      t_res_diff(
i, 
j) = (t_diff_ls_dlog_c(
k, 
l) * t_dC_dF(
k, 
l, 
i, 
j));
 
  344  auto t_res_diff = getFTensor2FromMat<DIM, DIM>(resDiff);
 
  346  auto t_w = AssemblyDomainEleOp::getFTensor0IntegrationWeight();
 
  347  auto t_row_base = row_data.getFTensor0N();
 
  348  for (
auto gg = 0; gg != nb_integration_pts; ++gg) {
 
  349    double alpha = AssemblyDomainEleOp::getMeasure() * t_w;
 
  353        getFTensor1FromPtr<DIM>(AssemblyDomainEleOp::locMat.data().data());
 
  355    for (; rr != AssemblyDomainEleOp::nbRows; ++rr) {
 
  356      const auto row_base = alpha * t_row_base;
 
  357      auto t_col_diff_base = col_data.getFTensor1DiffN<DIM>(gg, 0);
 
  358      for (
size_t cc = 0; cc != AssemblyDomainEleOp::nbCols / DIM; cc++) {
 
  359        t_mat(
i) += row_base * (t_res_diff(
i, 
j) * t_col_diff_base(
j));
 
  365    for (; rr != nb_row_base_functions; ++rr)
 
 
boost::shared_ptr< HenckyOps::CommonData > commonHenckyDataPtr
boost::shared_ptr< HenckyOps::CommonData > commonHenckyDataPtr
boost::shared_ptr< HenckyOps::CommonData > commonHenckyDataPtr