#include <tutorials/adv-0/src/PlasticOpsLargeStrains.hpp>

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

[legend]

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

[legend]

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

MatrixDouble	resDiff

Detailed Description

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

Definition at line 8 of file PlasticOpsLargeStrains.hpp.

Constructor & Destructor Documentation

◆ OpCalculatePlasticInternalForceLhs_LogStrain_dEPImpl()

template<int DIM, typename AssemblyDomainEleOp >

PlasticOps::OpCalculatePlasticInternalForceLhs_LogStrain_dEPImpl< DIM, GAUSS, AssemblyDomainEleOp >::OpCalculatePlasticInternalForceLhs_LogStrain_dEPImpl	(	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 30 of file PlasticOpsLargeStrains.hpp.

     : AssemblyDomainEleOp(row_field_name, col_field_name,
                           AssemblyDomainEleOp::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::OpCalculatePlasticInternalForceLhs_LogStrain_dEPImpl< DIM, GAUSS, AssemblyDomainEleOp >::iNtegrate	(	EntitiesFieldData::EntData &	row_data,
		EntitiesFieldData::EntData &	col_data
	)

Definition at line 45 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;
   FTensor::Index<'m', DIM> m;
   FTensor::Index<'n', DIM> n;
  
   constexpr auto size_symm = (DIM * (DIM + 1)) / 2;
   FTensor::Index<'L', size_symm> L;
  
   auto &locMat = AssemblyDomainEleOp::locMat;
  
   const size_t nb_integration_pts = row_data.getN().size1();
   const size_t nb_row_base_functions = row_data.getN().size2();
  
   if (AssemblyDomainEleOp::rowType == MBVERTEX &&
       AssemblyDomainEleOp::rowSide == 0) {
     resDiff.resize(DIM * DIM * size_symm, nb_integration_pts, false);
     auto t_res_diff = getFTensor3FromMat<DIM, DIM, size_symm>(resDiff);
     auto t_D = getFTensor4DdgFromMat<DIM, DIM, 0>(*mDPtr);
     auto t_logC_dC =
         getFTensor4DdgFromMat<DIM, DIM>(commonHenckyDataPtr->matLogCdC);
     auto t_grad =
         getFTensor2FromMat<DIM, DIM>(*(commonHenckyDataPtr->matGradPtr));
     auto t_L = symm_L_tensor(FTensor::Number<DIM>());
     constexpr auto t_kd = FTensor::Kronecker_Delta<int>();
     for (size_t gg = 0; gg != nb_integration_pts; ++gg) {
       FTensor::Tensor2<double, DIM, DIM> t_F;
       t_F(i, j) = t_grad(i, j) + t_kd(i, j);
       FTensor::Tensor4<double, DIM, DIM, DIM, DIM> t_DLogC_dC;
       t_DLogC_dC(i, j, k, l) = t_D(m, n, k, l) * t_logC_dC(m, n, i, j);
       FTensor::Tensor4<double, DIM, DIM, DIM, DIM> t_FDLogC_dC;
       t_FDLogC_dC(i, j, k, l) = t_F(i, m) * t_DLogC_dC(m, j, k, l);
       FTensor::Tensor3<double, DIM, DIM, size_symm> t_DL;
       t_res_diff(i, j, L) = t_FDLogC_dC(i, j, k, l) * t_L(k, l, L);
       ++t_logC_dC;
       ++t_grad;
       ++t_res_diff;
     }
   }
  
   auto t_w = AssemblyDomainEleOp::getFTensor0IntegrationWeight();
   auto t_row_diff_base = row_data.getFTensor1DiffN<DIM>();
   auto t_res_diff = getFTensor3FromMat<DIM, DIM, size_symm>(resDiff);
  
   for (size_t gg = 0; gg != nb_integration_pts; ++gg) {
     double alpha = AssemblyDomainEleOp::getMeasure() * t_w;
  
     size_t rr = 0;
     for (; rr != AssemblyDomainEleOp::nbRows / DIM; ++rr) {
  
       auto t_mat =
           get_mat_vector_dtensor_sym(rr, locMat, FTensor::Number<DIM>());
  
       FTensor::Tensor2<double, DIM, size_symm> t_tmp;
       t_tmp(i, L) = (t_res_diff(i, j, L) * (alpha * t_row_diff_base(j)));
  
       auto t_col_base = col_data.getFTensor0N(gg, 0);
       for (size_t cc = 0; cc != AssemblyDomainEleOp::nbCols / size_symm; ++cc) {
  
         t_mat(i, L) -= (t_col_base * t_tmp(i, L));
  
         ++t_mat;
         ++t_col_base;
       }
  
       ++t_row_diff_base;
     }
  
     for (; rr < nb_row_base_functions; ++rr)
       ++t_row_diff_base;
  
     ++t_w;
     ++t_res_diff;
   }
  
   MoFEMFunctionReturn(0);
 }