#include "tutorials/adv-0/src/PlasticOpsLargeStrains.hpp"

Inheritance diagram for PlasticOps::OpCalculateConstraintsLhs_LogStrain_dUImpl< DIM, GAUSS, AssemblyDomainEleOp >:

Collaboration diagram for PlasticOps::OpCalculateConstraintsLhs_LogStrain_dUImpl< DIM, GAUSS, AssemblyDomainEleOp >:

Public Member Functions
	OpCalculateConstraintsLhs_LogStrain_dUImpl (const std::string row_field_name, const std::string col_field_name, boost::shared_ptr< CommonData > common_data_ptr, boost::shared_ptr< HenckyOps::CommonData > common_hencky_data_ptr, boost::shared_ptr< MatrixDouble > m_D_ptr)

MoFEMErrorCode	iNtegrate (EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)

Private Attributes
boost::shared_ptr< CommonData >	commonDataPtr

boost::shared_ptr< HenckyOps::CommonData >	commonHenckyDataPtr

boost::shared_ptr< MatrixDouble >	mDPtr

MatrixDouble	resDiff

Detailed Description

template<int DIM, typename AssemblyDomainEleOp>
struct PlasticOps::OpCalculateConstraintsLhs_LogStrain_dUImpl< DIM, GAUSS, AssemblyDomainEleOp >

Definition at line 256 of file PlasticOpsLargeStrains.hpp.

Constructor & Destructor Documentation

◆ OpCalculateConstraintsLhs_LogStrain_dUImpl()

template<int DIM, typename AssemblyDomainEleOp >

PlasticOps::OpCalculateConstraintsLhs_LogStrain_dUImpl< DIM, GAUSS, AssemblyDomainEleOp >::OpCalculateConstraintsLhs_LogStrain_dUImpl	(	const std::string	row_field_name,
		const std::string	col_field_name,
		boost::shared_ptr< CommonData >	common_data_ptr,
		boost::shared_ptr< HenckyOps::CommonData >	common_hencky_data_ptr,
		boost::shared_ptr< MatrixDouble >	m_D_ptr
	)

Definition at line 274 of file PlasticOpsLargeStrains.hpp.

    : AssemblyDomainEleOp(row_field_name, col_field_name,
                          DomainEleOp::OPROWCOL),
      commonDataPtr(common_data_ptr),
      commonHenckyDataPtr(common_hencky_data_ptr), mDPtr(m_D_ptr) {
  AssemblyDomainEleOp::sYmm = false;
}

Member Function Documentation

◆ iNtegrate()

template<int DIM, typename AssemblyDomainEleOp >

MoFEMErrorCode PlasticOps::OpCalculateConstraintsLhs_LogStrain_dUImpl< DIM, GAUSS, AssemblyDomainEleOp >::iNtegrate	(	EntitiesFieldData::EntData &	row_data,
		EntitiesFieldData::EntData &	col_data
	)

Definition at line 289 of file PlasticOpsLargeStrains.hpp.

                                                  {
  MoFEMFunctionBegin;
 
  FTensor::Index<'i', DIM> i;
  FTensor::Index<'j', DIM> j;
  FTensor::Index<'k', DIM> k;
  FTensor::Index<'l', DIM> l;
 
  constexpr auto t_kd = FTensor::Kronecker_Delta<int>();
 
  AssemblyDomainEleOp::locMat.resize(AssemblyDomainEleOp::nbRows, AssemblyDomainEleOp::nbCols,
                false);
  AssemblyDomainEleOp::locMat.clear();
 
  const auto nb_integration_pts = AssemblyDomainEleOp::getGaussPts().size2();
  const auto nb_row_base_functions = row_data.getN().size2();
 
  if (AssemblyDomainEleOp::colType == MBVERTEX &&
      AssemblyDomainEleOp::colSide == 0) {
 
    resDiff.resize(DIM * DIM, nb_integration_pts, false);
    auto t_res_diff = getFTensor2FromMat<DIM, DIM>(resDiff);
    auto t_grad = getFTensor2FromMat<DIM, DIM>(*(commonDataPtr->mGradPtr));
    auto t_logC_dC =
        getFTensor4DdgFromMat<DIM, DIM>(commonHenckyDataPtr->matLogCdC);
    auto t_c_dstrain =
        getFTensor2SymmetricFromMat<DIM>(commonDataPtr->resCdStrain);
 
    auto next = [&]() {
      ++t_grad;
      ++t_logC_dC;
      ++t_c_dstrain;
      ++t_res_diff;
    };
 
    auto t_diff_grad_symmetrise = diff_symmetrize(FTensor::Number<DIM>());
 
    for (size_t gg = 0; gg != nb_integration_pts; ++gg) {
      FTensor::Tensor2_symmetric<double, DIM> t_diff_ls_dlog_c;
      FTensor::Tensor2<double, DIM, DIM> t_F;
      FTensor::Tensor4<double, DIM, DIM, DIM, DIM> t_dC_dF;
 
      t_diff_ls_dlog_c(k, l) =
          (t_c_dstrain(i, j)) * (t_logC_dC(i, j, k, l) / 2);
      t_F(i, j) = t_grad(i, j) + t_kd(i, j);
      t_dC_dF(i, j, k, l) = (t_kd(i, l) * t_F(k, j)) + (t_kd(j, l) * t_F(k, i));
 
      FTensor::Tensor2<double, DIM, DIM> t_res_mat;
      t_res_diff(i, j) = (t_diff_ls_dlog_c(k, l) * t_dC_dF(k, l, i, j));
      next();
    }
  }
 
  auto t_res_diff = getFTensor2FromMat<DIM, DIM>(resDiff);
 
  auto t_w = AssemblyDomainEleOp::getFTensor0IntegrationWeight();
  auto t_row_base = row_data.getFTensor0N();
  for (auto gg = 0; gg != nb_integration_pts; ++gg) {
    double alpha = AssemblyDomainEleOp::getMeasure() * t_w;
    ++t_w;
 
    auto t_mat =
        getFTensor1FromPtr<DIM>(AssemblyDomainEleOp::locMat.data().data());
    size_t rr = 0;
    for (; rr != AssemblyDomainEleOp::nbRows; ++rr) {
      const auto row_base = alpha * t_row_base;
      auto t_col_diff_base = col_data.getFTensor1DiffN<DIM>(gg, 0);
      for (size_t cc = 0; cc != AssemblyDomainEleOp::nbCols / DIM; cc++) {
        t_mat(i) += row_base * (t_res_diff(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;
 
    ++t_res_diff;
  }
 
  MoFEMFunctionReturn(0);
}