FreeSurfaceOps::OpLhsU_dU Struct Reference

[OpRhsU] More...

#include "tutorials/vec-5_free_surface/src/FreeSurfaceOps.hpp"

Inheritance diagram for FreeSurfaceOps::OpLhsU_dU:

Collaboration diagram for FreeSurfaceOps::OpLhsU_dU:

Public Member Functions
	OpLhsU_dU (const std::string field_name, boost::shared_ptr< MatrixDouble > u_ptr, boost::shared_ptr< MatrixDouble > grad_u_ptr, boost::shared_ptr< VectorDouble > h_ptr)
MoFEMErrorCode	iNtegrate (EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)

Private Attributes
boost::shared_ptr< MatrixDouble >	uPtr
boost::shared_ptr< MatrixDouble >	gradUPtr
boost::shared_ptr< VectorDouble >	hPtr

Detailed Description

[OpRhsU]

[OpLhsU_dU]

Lhs for U dU (Jacobian block ∂R_U/∂U)

Parameters

field_name	Name of the field associated with the operator
u_ptr	Pointer to the velocity matrix (U)
grad_u_ptr	Pointer to the velocity gradient matrix (∇U)
h_ptr	Pointer to the free surface height vector (h)

Returns

MoFEMErrorCode

Implements linearization of momentum residual w.r.t. velocity U:

Matches the Jacobian terms required to solve the implicit momentum equation used when solving the coupled NS–CH system (Lovric 3.1a linearization).

Examples

mofem/tutorials/vec-5_free_surface/free_surface.cpp.

Definition at line 604 of file FreeSurfaceOps.hpp.

Constructor & Destructor Documentation

OpLhsU_dU()

FreeSurfaceOps::OpLhsU_dU::OpLhsU_dU ( const std::string  field_name, boost::shared_ptr< MatrixDouble >  u_ptr, boost::shared_ptr< MatrixDouble >  grad_u_ptr, boost::shared_ptr< VectorDouble >  h_ptr  )

inline

Definition at line 606 of file FreeSurfaceOps.hpp.

      : AssemblyDomainEleOp(field_name, field_name,
                            AssemblyDomainEleOp::OPROWCOL),
        uPtr(u_ptr), gradUPtr(grad_u_ptr), hPtr(h_ptr) {
    sYmm = false;
    assembleTranspose = false;
  }

Member Function Documentation

iNtegrate()

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

inline

Definition at line 616 of file FreeSurfaceOps.hpp.

                                                               {
    MoFEMFunctionBegin;
 
    const double vol = getMeasure();
    auto t_u = getFTensor1FromMat<U_FIELD_DIM>(*uPtr);
    auto t_grad_u = getFTensor2FromMat<U_FIELD_DIM, SPACE_DIM>(*gradUPtr);
    auto t_h = getFTensor0FromVec(*hPtr);
    auto t_coords = getFTensor1CoordsAtGaussPts();
 
    auto t_row_base = row_data.getFTensor0N();
    auto t_row_diff_base = row_data.getFTensor1DiffN<SPACE_DIM>();
 
    auto t_w = getFTensor0IntegrationWeight();
 
    auto get_mat = [&](const int rr) {
      return getFTensor2FromArray<SPACE_DIM, SPACE_DIM, SPACE_DIM>(locMat, rr);
    };
 
    auto ts_a = getTSa();
    constexpr auto t_kd = FTensor::Kronecker_Delta_symmetric<double>(); // t_kd(i,j)=1 iff i=j
 
    for (int gg = 0; gg != nbIntegrationPts; gg++) {
 
      const double r = t_coords(0);
      const double alpha = t_w * vol * cylindrical(r);
      const double rho = phase_function(t_h, rho_diff, rho_ave);
      const double mu = phase_function(t_h, mu_diff, mu_ave);
 
      const double beta0 = alpha * rho;
      const double beta1 = beta0 * ts_a;
      auto t_D = get_D(2 * mu); // Fourth-order viscosity tensor
 
      int rr = 0;
      for (; rr != nbRows / U_FIELD_DIM; ++rr) {
 
        auto t_mat = get_mat(rr * U_FIELD_DIM);
        auto t_col_base = col_data.getFTensor0N(gg, 0);
        auto t_col_diff_base = col_data.getFTensor1DiffN<SPACE_DIM>(gg, 0);
        
        // Symmetric on last two indices
        // ie Christof(i,j,k) == Christof(i,k,j)
        FTensor::Christof<double, SPACE_DIM, SPACE_DIM> t_d_stress;
        t_d_stress(l, j, k) = t_D(i, j, k, l) * (alpha * t_row_diff_base(i));
 
        for (int cc = 0; cc != nbCols / U_FIELD_DIM; ++cc) {// Assemble contributions for each col basis function
 
          const double bb = t_row_base * t_col_base;
 
          t_mat(i, j) += (beta1 * bb) * t_kd(i, j); // Derivative of inertia term ρ ∂U/∂t
          t_mat(i, j) += (beta0 * bb) * t_grad_u(i, j); // Derivative of convection term ρ (U·∇)U
          t_mat(i, j) +=
              (beta0 * t_row_base) * t_kd(i, j) * (t_col_diff_base(k) * t_u(k));
          t_mat(i, j) += t_d_stress(i, j, k) * t_col_diff_base(k); // Derivative of viscous term ∇·(2μD(U))
 
          if (coord_type == CYLINDRICAL) {
            t_mat(0, 0) += (bb * (alpha / t_coords(0))) * (2 * mu);
          }
 
          ++t_mat;
          ++t_col_base;
          ++t_col_diff_base;
        }
 
        ++t_row_base;
        ++t_row_diff_base;
      }
 
      for (; rr < nbRowBaseFunctions; ++rr) {
        ++t_row_diff_base;
        ++t_row_base;
      }
 
      ++t_u;
      ++t_grad_u;
      ++t_h;
 
      ++t_coords;
      ++t_w;
    }
 
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

gradUPtr

boost::shared_ptr<MatrixDouble> FreeSurfaceOps::OpLhsU_dU::gradUPtr

private

Definition at line 702 of file FreeSurfaceOps.hpp.

hPtr

boost::shared_ptr<VectorDouble> FreeSurfaceOps::OpLhsU_dU::hPtr

private

Definition at line 703 of file FreeSurfaceOps.hpp.

uPtr

boost::shared_ptr<MatrixDouble> FreeSurfaceOps::OpLhsU_dU::uPtr

private

Definition at line 701 of file FreeSurfaceOps.hpp.

---

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

• tutorials/vec-5_free_surface/src/FreeSurfaceOps.hpp