OpPlasticTools::OpCalculateConstraintLhs_dU< LOGSTRAIN > Struct Template Reference

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

Inheritance diagram for OpPlasticTools::OpCalculateConstraintLhs_dU< LOGSTRAIN >:

Collaboration diagram for OpPlasticTools::OpCalculateConstraintLhs_dU< LOGSTRAIN >:

Public Member Functions
	OpCalculateConstraintLhs_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::OpCalculateConstraintLhs_dU< LOGSTRAIN >

Definition at line 175 of file PlasticOperators.hpp.

Constructor & Destructor Documentation

OpCalculateConstraintLhs_dU()

template<bool LOGSTRAIN>

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

Definition at line 820 of file PlasticOperators.cpp.

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

Member Function Documentation

iNtegrate()

template<bool LOGSTRAIN>

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

Definition at line 829 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 = getFTensor0FromVec(*(commonDataPtr->plasticTauPtr));
    auto t_tau_dot = getFTensor0FromVec(*(commonDataPtr->plasticTauDotPtr));
    auto t_flow =
        getFTensor2SymmetricFromMat<3>(*(commonDataPtr->plasticFlowPtr));
    auto t_stress =
        getFTensor2SymmetricFromMat<3>(*(commonDataPtr->mStressPtr));
    auto t_D = getFTensor4DdgFromMat<3, 3, 0>(*commonDataPtr->mtD);
    auto t_D_Deviator =
        getFTensor4DdgFromMat<3, 3, 0>(*commonDataPtr->mtD_Deviator);
    auto t_diff_symmetrize = diff_symmetrize();
 
    MatrixDouble &dE_dF = *(commonDataPtr->dE_dF_mat);
    auto t_dE_dF = getFTensor4FromMat<3, 3, 3, 3>(dE_dF);
 
    for (size_t gg = 0; gg != nb_integration_pts; ++gg) {
      double alpha = dt * getMeasure() * t_w * (*cache).scale_constraint;
 
      auto t_diff_constrain_dstrain = diff_constrain_dstrain(
          t_D_Deviator,
          diff_constrain_dstress(
              diff_constrain_df(t_tau_dot, t_f, hardening(t_tau)), t_flow));
 
      Tensor2<double, 3, 3> t_diff_constrain_dgrad;
      if (!LOGSTRAIN) {
 
        t_diff_constrain_dgrad(k, l) =
            t_diff_constrain_dstrain(i, j) * t_diff_symmetrize(i, j, k, l);
      } else {
 
        Tensor2<double, 3, 3> t_diff_constrain_dgrads;
        t_diff_constrain_dgrad(k, l) =
            t_diff_constrain_dstrain(i, j) * t_dE_dF(i, j, k, l);
      }
 
      Tensor1<PackPtr<double *, 3>, 3> t_mat{&locMat(0, 0), &locMat(0, 1),
                                             &locMat(0, 2)};
 
      size_t rr = 0;
      for (; rr != nb_row_dofs; ++rr) {
 
        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) += alpha * t_row_base * t_diff_constrain_dgrad(i, j) *
                      t_col_diff_base(j);
 
          ++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_f;
      ++t_tau;
      ++t_tau_dot;
      ++t_flow;
      ++t_stress;
      ++t_w;
    }
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

commonDataPtr

template<bool LOGSTRAIN>

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

private

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