OpPlasticTools::OpCalculateConstraintLhs_dTAU Struct Reference

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

Inheritance diagram for OpPlasticTools::OpCalculateConstraintLhs_dTAU:

Collaboration diagram for OpPlasticTools::OpCalculateConstraintLhs_dTAU:

Public Member Functions
	OpCalculateConstraintLhs_dTAU (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

Definition at line 195 of file PlasticOperators.hpp.

Constructor & Destructor Documentation

OpCalculateConstraintLhs_dTAU()

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

Definition at line 1026 of file PlasticOperators.cpp.

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

Member Function Documentation

iNtegrate()

MoFEMErrorCode OpPlasticTools::OpCalculateConstraintLhs_dTAU::iNtegrate	(	EntData &	row_data,
		EntData &	col_data
	)

Definition at line 1035 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 t_f = getFTensor0FromVec(*(commonDataPtr->plasticSurfacePtr));
    auto t_tau = getFTensor0FromVec(*(commonDataPtr->plasticTauPtr));
    auto t_tau_dot = getFTensor0FromVec(*(commonDataPtr->plasticTauDotPtr));
 
    auto t_omega = getFTensor1FromMat<3>(*commonDataPtr->guidingVelocityPtr);
    bool is_rotating = commonDataPtr->guidingVelocityPtr->size2() > 1;
 
    auto &cn = (*cache).cn_pl;
 
    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();
 
    for (size_t gg = 0; gg != nb_integration_pts; ++gg) {
      const double alpha = dt * getMeasure() * t_w * (*cache).scale_constraint;
      const double t_a = getTSa();
      const double c0 =
          alpha * /* t_a * */
          diff_constrain_dtau_dot(t_tau_dot, t_f, hardening(t_tau));
      const double c1 =
          alpha * diff_constrain_dsigma_y(t_tau_dot, t_f, hardening(t_tau)) *
          hardening_dtau(t_tau);
 
      auto mat_ptr = locMat.data().begin();
 
      size_t rr = 0;
      for (; rr != nb_row_dofs; ++rr) {
 
        auto t_col_base = col_data.getFTensor0N(gg, 0);
        auto t_col_diff_base = col_data.getFTensor1DiffN<3>(gg, 0);
        for (size_t cc = 0; cc != nb_col_dofs; ++cc) {
          if (!is_rotating) {
            *mat_ptr += (c0 * t_a + c1) * t_row_base * t_col_base;
 
          } else {
            const double c0_p =
                c0 * (t_col_base * t_a + (t_col_diff_base(i) * t_omega(i)));
            *mat_ptr += (c0_p + c1 * t_col_base) * t_row_base;
          }
 
          ++mat_ptr;
          ++t_col_base;
          ++t_col_diff_base;
        }
        ++t_row_base;
      }
      for (; rr < nb_row_base_functions; ++rr)
        ++t_row_base;
 
      if (is_rotating)
        ++t_omega;
 
      ++t_w;
      ++t_f;
      ++t_tau;
      ++t_tau_dot;
    }
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

commonDataPtr

boost::shared_ptr<CommonData> OpPlasticTools::OpCalculateConstraintLhs_dTAU::commonDataPtr

private

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