Rhs for mapping symmetric tensor fields with least squares. More...

#include "users_modules/multifield-thermoplasticity-private/src/EdgeFlippingOps.hpp"

Inheritance diagram for EdgeFlippingOps::OpRhsSymTensorLeastSquaresProj< A, I, DIM >:

Collaboration diagram for EdgeFlippingOps::OpRhsSymTensorLeastSquaresProj< A, I, DIM >:

Public Member Functions
	OpRhsSymTensorLeastSquaresProj (const std::string field_name, boost::shared_ptr< MatrixDouble > old_sol_ptr, boost::shared_ptr< MatrixDouble > dot_new_sol_ptr, boost::shared_ptr< MatrixDouble > new_sol_ptr, boost::shared_ptr< MatrixDouble > grad_new_sol_ptr, MoFEM::Interface &m_field, ScalarFun scalar_function=[](double, double, double) constexpr { return 1;})

MoFEMErrorCode	iNtegrate (EntitiesFieldData::EntData &data)

Private Attributes
ScalarFun	scalarFunction

boost::shared_ptr< MatrixDouble >	dotNewSolPtr

boost::shared_ptr< MatrixDouble >	newSolPtr

boost::shared_ptr< MatrixDouble >	gradNewSolPtr

boost::shared_ptr< MatrixDouble >	oldSolPtr

MoFEM::Interface &	mField

Detailed Description

template<AssemblyType A, IntegrationType I, int DIM>
struct EdgeFlippingOps::OpRhsSymTensorLeastSquaresProj< A, I, DIM >

Rhs for mapping symmetric tensor fields with least squares.

Examples: SolutionMapping.hpp.

Definition at line 270 of file EdgeFlippingOps.hpp.

Constructor & Destructor Documentation

◆ OpRhsSymTensorLeastSquaresProj()

template<AssemblyType A, IntegrationType I, int DIM>

EdgeFlippingOps::OpRhsSymTensorLeastSquaresProj< A, I, DIM >::OpRhsSymTensorLeastSquaresProj	(	const std::string	field_name,
		boost::shared_ptr< MatrixDouble >	old_sol_ptr,
		boost::shared_ptr< MatrixDouble >	dot_new_sol_ptr,
		boost::shared_ptr< MatrixDouble >	new_sol_ptr,
		boost::shared_ptr< MatrixDouble >	grad_new_sol_ptr,
		MoFEM::Interface &	m_field,
		ScalarFun	scalar_function = `[](double, double, double) constexpr { return 1; }`
	)

inline

Definition at line 272 of file EdgeFlippingOps.hpp.

                                                       { return 1; })
      : AssemblyDomainEleOp(field_name, field_name, AssemblyDomainEleOp::OPROW),
        oldSolPtr(old_sol_ptr), dotNewSolPtr(dot_new_sol_ptr),
        newSolPtr(new_sol_ptr), gradNewSolPtr(grad_new_sol_ptr),
        mField(m_field), scalarFunction(scalar_function) {}

Member Function Documentation

◆ iNtegrate()

template<AssemblyType A, IntegrationType I, int DIM>

MoFEMErrorCode EdgeFlippingOps::OpRhsSymTensorLeastSquaresProj< A, I, DIM >::iNtegrate ( EntitiesFieldData::EntData & data )

inline

Examples: EdgeFlippingOps.hpp.

Definition at line 285 of file EdgeFlippingOps.hpp.

                                                           {
    MoFEMFunctionBegin;
 
    FTENSOR_INDEX(DIM, i);
    FTENSOR_INDEX(DIM, j);
    constexpr auto size_symm = (DIM * (DIM + 1)) / 2;
    FTENSOR_INDEX(size_symm, L);
 
    const double vol = getMeasure();
    auto t_w = getFTensor0IntegrationWeight();
    auto t_coords = getFTensor1CoordsAtGaussPts();
    auto t_base = data.getFTensor0N();
    auto t_diff_base = data.getFTensor1DiffN<DIM>();
 
#ifndef NDEBUG
    if (data.getDiffN().size1() != data.getN().size1())
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "wrong size 1");
    if (data.getDiffN().size2() != data.getN().size2() * SPACE_DIM) {
      MOFEM_LOG("SELF", Sev::error)
          << "Side " << rowSide << " " << CN::EntityTypeName(rowType);
      MOFEM_LOG("SELF", Sev::error) << data.getN();
      MOFEM_LOG("SELF", Sev::error) << data.getDiffN();
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "wrong size 2");
    }
#endif
 
    auto t_L = PlasticOps::symm_L_tensor(FTensor::Number<DIM>());
    auto &nf = AssemblyDomainEleOp::locF;
 
    auto t_old_sol = getFTensor2SymmetricFromMat<DIM>(*oldSolPtr);
    auto t_new_sol = getFTensor2SymmetricFromMat<DIM>(*newSolPtr);
 
    for (int gg = 0; gg != nbIntegrationPts; ++gg) {
 
      const double alpha =
          t_w * vol * scalarFunction(t_coords(0), t_coords(1), t_coords(2));
 
      FTensor::Tensor1<double, size_symm> t_old_sol_L;
      t_old_sol_L(L) = alpha * t_old_sol(i, j) * t_L(i, j, L);
 
      auto t_nf = getFTensor1FromArray<size_symm, size_symm>(nf);
      int bb = 0;
      for (; bb != AssemblyDomainEleOp::nbRows / size_symm; ++bb) {
        t_nf(L) += t_base * (t_old_sol_L(L));
        ++t_base;
        ++t_diff_base;
        ++t_nf;
      }
 
      for (; bb < nbRowBaseFunctions; ++bb) {
        ++t_base;
        ++t_diff_base;
      }
 
      ++t_old_sol;
      ++t_new_sol;
 
      ++t_coords;
      ++t_w;
    }
 
    MoFEMFunctionReturn(0);
  }