OpPlasticTools::OpCalculatePlasticInternalForceLhs_dEP< LOGSTRAIN > Struct Template Reference

#include <users_modules/multifield_plasticity/src/PlasticOperators.hpp>

Inheritance diagram for OpPlasticTools::OpCalculatePlasticInternalForceLhs_dEP< LOGSTRAIN >:

Collaboration diagram for OpPlasticTools::OpCalculatePlasticInternalForceLhs_dEP< LOGSTRAIN >:

Public Member Functions
	OpCalculatePlasticInternalForceLhs_dEP (const std::string row_field_name, const std::string col_field_name, boost::shared_ptr< CommonData > common_data_ptr, boost::shared_ptr< MatrixDouble > mat_D_ptr)
MoFEMErrorCode	iNtegrate (EntData &row_data, EntData &col_data)

Private Attributes
boost::shared_ptr< CommonData >	commonDataPtr
boost::shared_ptr< MatrixDouble >	matDPtr

Detailed Description

template<bool LOGSTRAIN>
struct OpPlasticTools::OpCalculatePlasticInternalForceLhs_dEP< LOGSTRAIN >

Definition at line 121 of file PlasticOperators.hpp.

Constructor & Destructor Documentation

OpCalculatePlasticInternalForceLhs_dEP()

template<bool LOGSTRAIN>

OpPlasticTools::OpCalculatePlasticInternalForceLhs_dEP< LOGSTRAIN >::OpCalculatePlasticInternalForceLhs_dEP	(	const std::string	row_field_name,
		const std::string	col_field_name,
		boost::shared_ptr< CommonData >	common_data_ptr,
		boost::shared_ptr< MatrixDouble >	mat_D_ptr
	)

Definition at line 228 of file PlasticOperators.cpp.

    : DomainEleOpAssembly(row_field_name, col_field_name,
                          DomainEleOpAssembly::OPROWCOL),
      commonDataPtr(common_data_ptr), matDPtr(mat_D_ptr) {
  sYmm = false;
}

Member Function Documentation

iNtegrate()

template<bool LOGSTRAIN>

MoFEMErrorCode OpPlasticTools::OpCalculatePlasticInternalForceLhs_dEP< LOGSTRAIN >::iNtegrate	(	EntData &	row_data,
		EntData &	col_data
	)

Definition at line 239 of file PlasticOperators.cpp.

                                          {
  MoFEMFunctionBegin;
 
  const size_t nb_row_dofs = row_data.getIndices().size();
  const size_t nb_col_dofs = col_data.getIndices().size();
  if (nb_row_dofs && nb_col_dofs) {
 
    const size_t nb_integration_pts = row_data.getN().size1();
    const size_t nb_row_base_functions = row_data.getN().size2();
    auto t_w = getFTensor0IntegrationWeight();
    auto t_row_diff_base = row_data.getFTensor1DiffN<3>();
    auto t_D = getFTensor4DdgFromMat<3, 3, 0>(*matDPtr);
 
    MatrixDouble &dE_dF = *(commonDataPtr->dE_dF_mat);
    auto t_dE_dF = getFTensor4FromMat<3, 3, 3, 3>(dE_dF);
    Index<'L', 6> L;
    auto t_L = symm_L_tensor();
    auto t_diff_symmetrize = diff_symmetrize();
 
    Tensor3<double, 3, 3, 6> t_DLs;
    Dg<double, 3, 6> t_DL;
    if (!LOGSTRAIN) {
      t_DL(i, j, L) = 0;
      for (int ii = 0; ii != 3; ++ii)
        for (int jj = ii; jj != 3; ++jj)
          for (int kk = 0; kk != 3; ++kk)
            for (int ll = 0; ll != 3; ++ll)
              for (int LL = 0; LL != 6; ++LL)
                t_DL(ii, jj, LL) += t_D(ii, jj, kk, ll) * t_L(kk, ll, LL);
    }
 
    for (size_t gg = 0; gg != nb_integration_pts; ++gg) {
      double alpha = getMeasure() * t_w;
 
      if (LOGSTRAIN) {
        Tensor4<double, 3, 3, 3, 3> D2_symm;
        // D2_symm(i, j, k, l) = 0.;
 
        // FIXME: that transpose is not necessary
        // for (int i = 0; i != 3; ++i)
        //   for (int jj = 0; jj != 3; ++jj)
        //     for (int k = 0; k != 3; ++k)
        //       for (int l = 0; l != 3; ++l)
        //         for (int m = 0; m != 3; ++m)
        //           for (int n = 0; n != 3; ++n)
        //             D2_symm(k, l, m, n) +=
        //                 t_D(i, jj, m, n) * t_dE_dF(i, jj, k, l);
        D2_symm(k, l, m, n) = t_D(m, n, i, j) * t_dE_dF(i, j, k, l);
 
        t_DLs(i, j, L) = 0;
        for (int ii = 0; ii != 3; ++ii)
          for (int jj = 0; jj != 3; ++jj)
            for (int kk = 0; kk != 3; ++kk)
              for (int ll = 0; ll != 3; ++ll)
                for (int LL = 0; LL != 6; ++LL)
                  t_DLs(ii, jj, LL) +=
                      D2_symm(ii, jj, kk, ll) * t_L(kk, ll, LL);
      }
 
      size_t rr = 0;
      for (; rr != nb_row_dofs / 3; ++rr) {
 
        Tensor2<PackPtr<double *, 6>, 3, 6> t_mat{
            &locMat(3 * rr + 0, 0), &locMat(3 * rr + 0, 1),
            &locMat(3 * rr + 0, 2), &locMat(3 * rr + 0, 3),
            &locMat(3 * rr + 0, 4), &locMat(3 * rr + 0, 5),
            &locMat(3 * rr + 1, 0), &locMat(3 * rr + 1, 1),
            &locMat(3 * rr + 1, 2), &locMat(3 * rr + 1, 3),
            &locMat(3 * rr + 1, 4), &locMat(3 * rr + 1, 5),
            &locMat(3 * rr + 2, 0), &locMat(3 * rr + 2, 1),
            &locMat(3 * rr + 2, 2), &locMat(3 * rr + 2, 3),
            &locMat(3 * rr + 2, 4), &locMat(3 * rr + 2, 5)};
 
        auto t_col_base = col_data.getFTensor0N(gg, 0);
        Tensor2<double, 3, 6> t_tmp;
 
        if (LOGSTRAIN) {
          t_tmp(i, L) = (t_DLs(i, j, L) * (alpha * t_row_diff_base(j)));
 
        } else
          t_tmp(i, L) = (t_DL(i, j, L) * (alpha * t_row_diff_base(j)));
 
        for (size_t cc = 0; cc != nb_col_dofs / 6; ++cc) {
 
          t_mat(i, L) -= (t_col_base * t_tmp(i, L));
 
          ++t_mat;
          ++t_col_base;
        }
 
        ++t_row_diff_base;
      }
 
      if (LOGSTRAIN)
        ++t_dE_dF;
 
      for (; rr < nb_row_base_functions; ++rr)
        ++t_row_diff_base;
      ++t_w;
    }
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

commonDataPtr

template<bool LOGSTRAIN>

boost::shared_ptr<CommonData> OpPlasticTools::OpCalculatePlasticInternalForceLhs_dEP< LOGSTRAIN >::commonDataPtr

private

Definition at line 129 of file PlasticOperators.hpp.

matDPtr

template<bool LOGSTRAIN>

boost::shared_ptr<MatrixDouble> OpPlasticTools::OpCalculatePlasticInternalForceLhs_dEP< LOGSTRAIN >::matDPtr

private

Definition at line 130 of file PlasticOperators.hpp.

---

The documentation for this struct was generated from the following files:

• users_modules/multifield_plasticity/src/PlasticOperators.hpp
• users_modules/multifield_plasticity/src/impl/PlasticOperators.cpp