OpPlasticTools::OpCalculatePlasticFlowLhs_dU< LOGSTRAIN > Struct Template Reference

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

Inheritance diagram for OpPlasticTools::OpCalculatePlasticFlowLhs_dU< LOGSTRAIN >:

Collaboration diagram for OpPlasticTools::OpCalculatePlasticFlowLhs_dU< LOGSTRAIN >:

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

Private Attributes
boost::shared_ptr< CommonData >	commonDataPtr

Detailed Description

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

Definition at line 134 of file PlasticOperators.hpp.

Constructor & Destructor Documentation

OpCalculatePlasticFlowLhs_dU()

template<bool LOGSTRAIN>

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

Definition at line 346 of file PlasticOperators.cpp.

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

Member Function Documentation

iNtegrate()

template<bool LOGSTRAIN>

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

Definition at line 355 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) {
 
    auto get_dt = [&]() {
      double dt;
      CHKERR TSGetTimeStep(getFEMethod()->ts, &dt);
      dt = 1;
      return dt;
    };
    const auto dt = get_dt();
 
    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 get_row_base = [&]() {
      if (commonDataPtr->isDualBase) {
        double *base_ptr = &*commonDataPtr->dualBaseMat.data().begin();
        return Tensor0<PackPtr<double *, 1>>(base_ptr);
      } else {
        return row_data.getFTensor0N();
      }
    };
    auto t_row_base = get_row_base();
 
    auto t_f = getFTensor0FromVec(*(commonDataPtr->plasticSurfacePtr));
    auto t_tau_dot = getFTensor0FromVec(*(commonDataPtr->plasticTauDotPtr));
    auto &diff_dev = commonDataPtr->diffDeviator;
    auto t_flow =
        getFTensor2SymmetricFromMat<3>(*(commonDataPtr->plasticFlowPtr));
    auto t_D = getFTensor4DdgFromMat<3, 3, 0>(*commonDataPtr->mtD);
    auto t_D_Deviator =
        getFTensor4DdgFromMat<3, 3, 0>(*commonDataPtr->mtD_Deviator);
 
    MatrixDouble &dE_dF = *(commonDataPtr->dE_dF_mat);
    auto t_dE_dF = getFTensor4FromMat<3, 3, 3, 3>(dE_dF);
 
    auto t_diff_symmetrize = diff_symmetrize();
 
    for (size_t gg = 0; gg != nb_integration_pts; ++gg) {
 
      double alpha = dt * getMeasure() * t_w;
      auto t_diff_plastic_flow_dstrain = diff_plastic_flow_dstrain(
          t_D_Deviator, diff_plastic_flow_dstress(t_f, t_flow, diff_dev));
      Ddg<double, 3, 3> t_flow_stress_dstrain;
      t_flow_stress_dstrain(i, j, k, l) =
          t_D(i, j, m, n) * t_diff_plastic_flow_dstrain(m, n, k, l);
      Tensor4<double, 3, 3, 3, 3> t_diff_plastic_flow_stress_dgrad;
 
      if (!LOGSTRAIN)
        t_diff_plastic_flow_stress_dgrad(i, j, k, l) =
            t_flow_stress_dstrain(i, j, m, n) * t_diff_symmetrize(m, n, k, l);
      else {
 
        Tensor4<double, 3, 3, 3, 3> t_diff_plastic_flow_stress_dgrads;
        t_diff_plastic_flow_stress_dgrads(i, j, k, l) =
            t_flow_stress_dstrain(i, j, m, n) * t_diff_symmetrize(m, n, k, l);
        t_diff_plastic_flow_stress_dgrad(i, j, k, l) = 0.;
        for (int i = 0; i != 3; ++i)
          for (int j = 0; j != 3; ++j)
            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)
                    t_diff_plastic_flow_stress_dgrad(i, j, k, l) +=
                        t_diff_plastic_flow_stress_dgrads(i, j, m, n) *
                        t_dE_dF(m, n, k, l);
      }
 
      size_t rr = 0;
      for (; rr != nb_row_dofs / 6; ++rr) {
 
        // t3(T d000, T d001, T d002, T d010, T d011, T d012, T d020, T d021,
        //   T d022, T d100, T d101, T d102, T d110, T d111, T d112, T d120,
        //   T d121, T d122, T d200, T d201, T d202, T d210, T d211, T d212,
        //   T d220, T d221, T d222);
 
        Tensor3<PackPtr<double *, 3>, 3, 3, 3> t_mat{
            &locMat(6 * rr + 0, 0), // 000
            &locMat(6 * rr + 0, 1), // 001
            &locMat(6 * rr + 0, 2), // 002
 
            &locMat(6 * rr + 1, 0), // 010
            &locMat(6 * rr + 1, 1), // 011
            &locMat(6 * rr + 1, 2), // 012
 
            &locMat(6 * rr + 2, 0), // 020
            &locMat(6 * rr + 2, 1), // 021
            &locMat(6 * rr + 2, 2), // 022
 
            &locMat(6 * rr + 1, 0), // 100
            &locMat(6 * rr + 1, 1), // 101
            &locMat(6 * rr + 1, 2), // 102
 
            &locMat(6 * rr + 3, 0), // 110
            &locMat(6 * rr + 3, 1), // 111
            &locMat(6 * rr + 3, 2), // 112
 
            &locMat(6 * rr + 4, 0), // 120
            &locMat(6 * rr + 4, 1), // 121
            &locMat(6 * rr + 4, 2), // 122
 
            &locMat(6 * rr + 2, 0), // 200
            &locMat(6 * rr + 2, 1), // 201
            &locMat(6 * rr + 2, 2), // 202
 
            &locMat(6 * rr + 4, 0), // 210
            &locMat(6 * rr + 4, 1), // 211
            &locMat(6 * rr + 4, 2), // 212
 
            &locMat(6 * rr + 5, 0), // 220
            &locMat(6 * rr + 5, 1), // 221
            &locMat(6 * rr + 5, 2)  // 222
        };
 
        const double c0 = alpha * t_row_base * t_tau_dot;
 
        auto t_col_diff_base = col_data.getFTensor1DiffN<3>(gg, 0);
        for (size_t cc = 0; cc != nb_col_dofs / 3; ++cc) {
 
          t_mat(i, j, l) -= c0 * (t_diff_plastic_flow_stress_dgrad(i, j, l, k) *
                                  t_col_diff_base(k));
 
          ++t_mat;
          ++t_col_diff_base;
        }
 
        ++t_row_base;
      }
      for (; rr < nb_row_base_functions; ++rr)
        ++t_row_base;
 
      if (LOGSTRAIN)
        ++t_dE_dF;
 
      ++t_w;
      ++t_f;
      ++t_flow;
      ++t_tau_dot;
    }
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

commonDataPtr

template<bool LOGSTRAIN>

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

private

Definition at line 141 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