HenckyOps::OpCalculateEigenValsImpl< DIM, GAUSS, DomainEleOp > Struct Template Reference

#include "tutorials/vec-2_nonlinear_elasticity/src/HenckyOps.hpp"

Inheritance diagram for HenckyOps::OpCalculateEigenValsImpl< DIM, GAUSS, DomainEleOp >:

Collaboration diagram for HenckyOps::OpCalculateEigenValsImpl< DIM, GAUSS, DomainEleOp >:

Public Member Functions
	OpCalculateEigenValsImpl (const std::string field_name, boost::shared_ptr< CommonData > common_data)
MoFEMErrorCode	doWork (int side, EntityType type, EntData &data)

Private Attributes
boost::shared_ptr< CommonData >	commonDataPtr

Detailed Description

template<int DIM, typename DomainEleOp>
struct HenckyOps::OpCalculateEigenValsImpl< DIM, GAUSS, DomainEleOp >

Definition at line 86 of file HenckyOps.hpp.

Constructor & Destructor Documentation

OpCalculateEigenValsImpl()

template<int DIM, typename DomainEleOp >

HenckyOps::OpCalculateEigenValsImpl< DIM, GAUSS, DomainEleOp >::OpCalculateEigenValsImpl ( const std::string  field_name, boost::shared_ptr< CommonData >  common_data  )

inline

Definition at line 88 of file HenckyOps.hpp.

      : DomainEleOp(field_name, DomainEleOp::OPROW),
        commonDataPtr(common_data) {
    std::fill(&DomainEleOp::doEntities[MBEDGE],
              &DomainEleOp::doEntities[MBMAXTYPE], false);
  }

Member Function Documentation

doWork()

template<int DIM, typename DomainEleOp >

MoFEMErrorCode HenckyOps::OpCalculateEigenValsImpl< DIM, GAUSS, DomainEleOp >::doWork ( int  side, EntityType  type, EntData &  data  )

inline

Definition at line 96 of file HenckyOps.hpp.

                                                                  {
    MoFEMFunctionBegin;
 
    FTensor::Index<'i', DIM> i;
    FTensor::Index<'j', DIM> j;
    FTensor::Index<'k', DIM> k;
 
    [[maybe_unused]] constexpr auto t_kd = FTensor::Kronecker_Delta<int>();
    // const size_t nb_gauss_pts = matGradPtr->size2();
    const size_t nb_gauss_pts = DomainEleOp::getGaussPts().size2();
 
    auto t_grad = getFTensor2FromMat<DIM, DIM>(*(commonDataPtr->matGradPtr));
 
    commonDataPtr->matEigVal.resize(nb_gauss_pts, DIM, false);
    commonDataPtr->matEigVec.resize(nb_gauss_pts, DIM * DIM, false);
    auto t_eig_val = getFTensor1FromMat<DIM>(commonDataPtr->matEigVal);
    auto t_eig_vec = getFTensor2FromMat<DIM, DIM>(commonDataPtr->matEigVec);
 
    for (size_t gg = 0; gg != nb_gauss_pts; ++gg) {
 
      FTensor::Tensor2<double, DIM, DIM> F;
      FTensor::Tensor2_symmetric<double, DIM> C;
      FTensor::Tensor1<double, DIM> eig;
      FTensor::Tensor2<double, DIM, DIM> eigen_vec;
 
      F(i, j) = t_grad(i, j) + t_kd(i, j);
      C(i, j) = F(k, i) ^ F(k, j);
 
      for (int ii = 0; ii != DIM; ii++)
        for (int jj = 0; jj != DIM; jj++)
          eigen_vec(ii, jj) = C(ii, jj);
 
      CHKERR computeEigenValuesSymmetric(eigen_vec, eig);
      for (auto ii = 0; ii != DIM; ++ii)
        eig(ii) = std::max(eps, eig(ii));
 
      // rare case when two eigen values are equal
      auto nb_uniq =
          getUniqNb<DIM>(getVectorAdaptor(&eig(0), DIM), FTensor::Number<DIM>{});
      if constexpr (DIM == 3) {
        if (nb_uniq == 2) {
          CHKERR sortEigenVals<DIM>(
              getVectorAdaptor(&eig(0), DIM),
              getMatrixAdaptor(&eigen_vec(0, 0), DIM, DIM),
              FTensor::Number<DIM>{});
        }
      }
 
      t_eig_val(i) = eig(i);
      t_eig_vec(i, j) = eigen_vec(i, j);
 
#ifndef NDEBUG
      auto nb_uniq_test = getUniqNb<DIM>(getVectorAdaptor(&t_eig_val(0), DIM),
                                         FTensor::Number<DIM>{});
      if (nb_uniq_test != nb_uniq) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Inconsistent number of unique eigen values %ld != %ld",
                nb_uniq, nb_uniq_test);
      }
#endif
 
      ++t_grad;
      ++t_eig_val;
      ++t_eig_vec;
    }
 
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

commonDataPtr

template<int DIM, typename DomainEleOp >

boost::shared_ptr<CommonData> HenckyOps::OpCalculateEigenValsImpl< DIM, GAUSS, DomainEleOp >::commonDataPtr

private

Definition at line 166 of file HenckyOps.hpp.

---

The documentation for this struct was generated from the following file:

• tutorials/vec-2_nonlinear_elasticity/src/HenckyOps.hpp