SimpleContactProblem::ConvectSlaveIntegrationPts Struct Reference

Class used to convect integration points on slave and master, and to calculate directional direvatives of change integration position point as variation os spatial positions on contact surfaces. More...

#include <users_modules/mortar_contact/src/SimpleContact.hpp>

Inheritance diagram for SimpleContactProblem::ConvectSlaveIntegrationPts:

Collaboration diagram for SimpleContactProblem::ConvectSlaveIntegrationPts:

Public Member Functions
	ConvectSlaveIntegrationPts (SimpleContactElement *const fe_ptr, string spat_pos, string mat_pos)
template<bool CONVECT_MASTER>
MoFEMErrorCode	convectSlaveIntegrationPts ()
boost::shared_ptr< MatrixDouble >	getDiffKsiSpatialMaster ()
boost::shared_ptr< MatrixDouble >	getDiffKsiSpatialSlave ()

Private Attributes
SimpleContactElement *const	fePtr
const string	sparialPositionsField
const string	materialPositionsField
VectorDouble	spatialCoords
VectorDouble	materialCoords
MatrixDouble	slaveSpatialCoords
MatrixDouble	slaveMaterialCoords
MatrixDouble	masterSpatialCoords
MatrixDouble	masterMaterialCoords
MatrixDouble	slaveN
MatrixDouble	masterN
MatrixDouble	diffKsiMaster
MatrixDouble	diffKsiSlave

Detailed Description

Class used to convect integration points on slave and master, and to calculate directional direvatives of change integration position point as variation os spatial positions on contact surfaces.

Definition at line 137 of file SimpleContact.hpp.

Constructor & Destructor Documentation

ConvectSlaveIntegrationPts()

SimpleContactProblem::ConvectSlaveIntegrationPts::ConvectSlaveIntegrationPts ( SimpleContactElement *const  fe_ptr, string  spat_pos, string  mat_pos  )

inline

Definition at line 140 of file SimpleContact.hpp.

        : fePtr(fe_ptr), sparialPositionsField(spat_pos),
          materialPositionsField(mat_pos) {}

Member Function Documentation

convectSlaveIntegrationPts()

template<bool CONVECT_MASTER>

MoFEMErrorCode SimpleContactProblem::ConvectSlaveIntegrationPts::convectSlaveIntegrationPts

(

)

Definition at line 56 of file SimpleContact.cpp.

                                                                           {
  MoFEMFunctionBegin;
 
  auto get_material_dofs_from_coords = [&]() {
    MoFEMFunctionBegin;
    materialCoords.resize(18, false);
    int num_nodes;
    const EntityHandle *conn;
    CHKERR fePtr->mField.get_moab().get_connectivity(fePtr->getFEEntityHandle(),
                                                     conn, num_nodes, true);
    CHKERR fePtr->mField.get_moab().get_coords(conn, 6,
                                               &*materialCoords.data().begin());
    CHKERR fePtr->getNodeData(materialPositionsField, materialCoords, false);
    MoFEMFunctionReturn(0);
  };
 
  auto get_dofs_data_for_slave_and_master = [&] {
    slaveSpatialCoords.resize(3, 3, false);
    slaveMaterialCoords.resize(3, 3, false);
    masterSpatialCoords.resize(3, 3, false);
    masterMaterialCoords.resize(3, 3, false);
    for (size_t n = 0; n != 3; ++n) {
      for (size_t d = 0; d != 3; ++d) {
        masterSpatialCoords(n, d) = spatialCoords(3 * n + d);
        slaveSpatialCoords(n, d) = spatialCoords(3 * (n + 3) + d);
        masterMaterialCoords(n, d) = materialCoords(3 * n + d);
        slaveMaterialCoords(n, d) = materialCoords(3 * (n + 3) + d);
      }
    }
  };
 
  auto calculate_shape_base_functions = [&](const int nb_gauss_pts) {
    MoFEMFunctionBegin;
    if (nb_gauss_pts != fePtr->gaussPtsMaster.size2())
      SETERRQ2(
          PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
          "Inconsistent size of slave and master integration points (%d != %d)",
          nb_gauss_pts, fePtr->gaussPtsMaster.size2());
    slaveN.resize(nb_gauss_pts, 3, false);
    masterN.resize(nb_gauss_pts, 3, false);
    CHKERR Tools::shapeFunMBTRI(&slaveN(0, 0), &fePtr->gaussPtsSlave(0, 0),
                                &fePtr->gaussPtsSlave(1, 0), nb_gauss_pts);
    CHKERR Tools::shapeFunMBTRI(&masterN(0, 0), &fePtr->gaussPtsMaster(0, 0),
                                &fePtr->gaussPtsMaster(1, 0), nb_gauss_pts);
    MoFEMFunctionReturn(0);
  };
 
  auto get_diff_ksi_master = [&]() -> MatrixDouble & {
    if (CONVECT_MASTER)
      return diffKsiMaster;
    else
      return diffKsiSlave;
  };
 
  auto get_diff_ksi_slave = [&]() -> MatrixDouble & {
    if (CONVECT_MASTER)
      return diffKsiSlave;
    else
      return diffKsiMaster;
  };
 
  auto get_slave_material_coords = [&]() -> MatrixDouble & {
    if (CONVECT_MASTER)
      return slaveMaterialCoords;
    else
      return masterMaterialCoords;
  };
 
  auto get_master_gauss_pts = [&]() -> MatrixDouble & {
    if (CONVECT_MASTER)
      return fePtr->gaussPtsMaster;
    else
      return fePtr->gaussPtsSlave;
  };
 
  auto get_slave_spatial_coords = [&]() -> MatrixDouble & {
    if (CONVECT_MASTER)
      return slaveSpatialCoords;
    else
      return masterSpatialCoords;
  };
 
  auto get_master_spatial_coords = [&]() -> MatrixDouble & {
    if (CONVECT_MASTER)
      return masterSpatialCoords;
    else
      return slaveSpatialCoords;
  };
 
  auto get_slave_n = [&]() -> MatrixDouble & {
    if (CONVECT_MASTER)
      return slaveN;
    else
      return masterN;
  };
 
  auto get_master_n = [&]() -> MatrixDouble & {
    if (CONVECT_MASTER)
      return masterN;
    else
      return slaveN;
  };
 
  auto convect_points = [get_diff_ksi_master, get_diff_ksi_slave,
                         get_slave_material_coords, get_master_gauss_pts,
                         get_slave_spatial_coords, get_master_spatial_coords,
                         get_slave_n, get_master_n](const int nb_gauss_pts) {
    MatrixDouble3by3 A(2, 2);
    MatrixDouble3by3 invA(2, 2);
    VectorDouble3 F(2);
    MatrixDouble3by3 inv_matA(2, 2);
    VectorDouble3 copy_F(2);
    FTensor::Tensor1<FTensor::PackPtr<double *, 0>, 2> t_copy_F(&copy_F[0],
                                                                &copy_F[1]);
    FTensor::Tensor2<double *, 2, 2> t_inv_matA(
        &inv_matA(0, 0), &inv_matA(0, 1), &inv_matA(1, 0), &inv_matA(1, 1));
 
    auto get_t_coords = [](auto &m) {
      return FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3>{
          &m(0, 0), &m(0, 1), &m(0, 2)};
    };
 
    auto get_t_xi = [](auto &m) {
      return FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 2>{&m(0, 0),
                                                                &m(1, 0)};
    };
 
    auto get_t_diff = []() {
      return FTensor::Tensor1<FTensor::PackPtr<double const *, 2>, 2>{
          &Tools::diffShapeFunMBTRI[0], &Tools::diffShapeFunMBTRI[1]};
    };
 
    auto get_t_tau = []() {
      FTensor::Tensor2<double, 3, 2> t_tau;
      return t_tau;
    };
 
    auto get_t_x = []() {
      FTensor::Tensor1<double, 3> t_x;
      return t_x;
    };
 
    auto get_t_F = [&]() {
      return FTensor::Tensor1<FTensor::PackPtr<double *, 0>, 2>{&F[0], &F[1]};
    };
 
    auto get_t_A = [&](auto &m) {
      return FTensor::Tensor2<FTensor::PackPtr<double *, 0>, 2, 2>{
          &m(0, 0), &m(0, 1), &m(1, 0), &m(1, 1)};
    };
 
    auto get_diff_ksi = [](auto &m, const int gg) {
      return FTensor::Tensor2<FTensor::PackPtr<double *, 1>, 2, 3>(
          &m(0, gg), &m(1, gg), &m(2, gg), &m(3, gg), &m(4, gg), &m(5, gg));
    };
 
    FTensor::Index<'i', 3> i;
    FTensor::Index<'I', 2> I;
    FTensor::Index<'J', 2> J;
    FTensor::Index<'K', 2> K;
    FTensor::Index<'L', 2> L;
 
    get_diff_ksi_master().resize(6, 3 * nb_gauss_pts, false);
    get_diff_ksi_slave().resize(6, 3 * nb_gauss_pts, false);
 
    auto t_xi_master = get_t_xi(get_master_gauss_pts());
    for (int gg = 0; gg != nb_gauss_pts; ++gg) {
 
      auto t_tau = get_t_tau();
      auto t_x_slave = get_t_x();
      auto t_x_master = get_t_x();
      auto t_mat = get_t_A(A);
      auto t_f = get_t_F();
 
      auto newton_solver = [&]() {
        auto get_values = [&]() {
          t_tau(i, I) = 0;
          t_x_slave(i) = 0;
          t_x_master(i) = 0;
 
          auto t_slave_material_coords =
              get_t_coords(get_slave_material_coords());
          auto t_slave_spatial_coords =
              get_t_coords(get_slave_spatial_coords());
          auto t_master_spatial_coords =
              get_t_coords(get_master_spatial_coords());
          double *slave_base = &get_slave_n()(gg, 0);
          double *master_base = &get_master_n()(gg, 0);
          auto t_diff = get_t_diff();
          for (size_t n = 0; n != 3; ++n) {
 
            t_tau(i, J) += t_diff(J) * t_slave_material_coords(i);
            t_x_slave(i) += (*slave_base) * t_slave_spatial_coords(i);
            t_x_master(i) += (*master_base) * t_master_spatial_coords(i);
 
            ++t_diff;
            ++t_slave_material_coords;
            ++t_slave_spatial_coords;
            ++t_master_spatial_coords;
            ++slave_base;
            ++master_base;
          }
        };
 
        auto assemble = [&]() {
          t_mat(I, J) = 0;
          auto t_master_spatial_coords =
              get_t_coords(get_master_spatial_coords());
          auto t_diff = get_t_diff();
          for (size_t n = 0; n != 3; ++n) {
            t_mat(I, J) += t_diff(J) * t_tau(i, I) * t_master_spatial_coords(i);
            ++t_diff;
            ++t_master_spatial_coords;
          };
          t_f(I) = t_tau(i, I) * (t_x_slave(i) - t_x_master(i));
        };
 
        auto update = [&]() {
          t_xi_master(I) += t_f(I);
          get_master_n()(gg, 0) =
              Tools::shapeFunMBTRI0(t_xi_master(0), t_xi_master(1));
          get_master_n()(gg, 1) =
              Tools::shapeFunMBTRI1(t_xi_master(0), t_xi_master(1));
          get_master_n()(gg, 2) =
              Tools::shapeFunMBTRI2(t_xi_master(0), t_xi_master(1));
        };
 
        auto invert_2_by_2 = [&](MatrixDouble3by3 &inv_mat_A,
                                 MatrixDouble3by3 &mat_A) {
          double det_A;
          CHKERR determinantTensor2by2(mat_A, det_A);
          CHKERR invertTensor2by2(mat_A, det_A, inv_mat_A);
        };
 
        auto linear_solver = [&]() {
          invert_2_by_2(inv_matA, A);
          t_copy_F(J) = t_f(J);
          t_f(I) = t_inv_matA(I, J) * t_copy_F(J);
        };
 
        auto invert_A = [&]() { invert_2_by_2(invA, A); };
 
        auto nonlinear_solve = [&]() {
          constexpr double tol = 1e-12;
          constexpr int max_it = 10;
          int it = 0;
          double eps;
 
          do {
 
            get_values();
            assemble();
            linear_solver();
            update();
 
            eps = norm_2(F);
 
          } while (eps > tol && (it++) < max_it);
        };
 
        nonlinear_solve();
        get_values();
        assemble();
        invert_A();
 
        auto get_diff_slave = [&]() {
          auto t_inv_A = get_t_A(invA);
          auto t_diff_xi_slave = get_diff_ksi(get_diff_ksi_slave(), 3 * gg);
          double *slave_base = &get_slave_n()(gg, 0);
          for (size_t n = 0; n != 3; ++n) {
            t_diff_xi_slave(I, i) = t_inv_A(I, J) * t_tau(i, J) * (*slave_base);
            ++t_diff_xi_slave;
            ++slave_base;
          }
        };
 
        auto get_diff_master = [&]() {
          auto t_inv_A = get_t_A(invA);
          auto t_diff_xi_master = get_diff_ksi(get_diff_ksi_master(), 3 * gg);
          auto t_diff = get_t_diff();
          double *master_base = &get_master_n()(gg, 0);
          FTensor::Tensor4<double, 2, 2, 2, 2> t_diff_A;
          t_diff_A(I, J, K, L) = -t_inv_A(I, K) * t_inv_A(L, J);
          for (size_t n = 0; n != 3; ++n) {
            t_diff_xi_master(I, i) =
                (t_diff_A(I, J, K, L) * (t_f(J) * t_diff(L))) * t_tau(i, K) -
                t_inv_A(I, J) * t_tau(i, J) * (*master_base);
            ++t_diff_xi_master;
            ++master_base;
            ++t_diff;
          }
        };
 
        get_diff_master();
        get_diff_slave();
      };
 
      newton_solver();
 
      ++t_xi_master;
    }
  };
 
  const int nb_gauss_pts = fePtr->gaussPtsSlave.size2();
  CHKERR fePtr->getNodeData(sparialPositionsField, spatialCoords);
  CHKERR get_material_dofs_from_coords();
  get_dofs_data_for_slave_and_master();
  CHKERR calculate_shape_base_functions(nb_gauss_pts);
  convect_points(nb_gauss_pts);
 
  MoFEMFunctionReturn(0);
}

getDiffKsiSpatialMaster()

boost::shared_ptr<MatrixDouble> SimpleContactProblem::ConvectSlaveIntegrationPts::getDiffKsiSpatialMaster ( )

inline

Definition at line 147 of file SimpleContact.hpp.

                                                                   {
      return boost::shared_ptr<MatrixDouble>(shared_from_this(),
                                             &diffKsiMaster);
    }

getDiffKsiSpatialSlave()

boost::shared_ptr<MatrixDouble> SimpleContactProblem::ConvectSlaveIntegrationPts::getDiffKsiSpatialSlave ( )

inline

Definition at line 152 of file SimpleContact.hpp.

                                                                  {
      return boost::shared_ptr<MatrixDouble>(shared_from_this(), &diffKsiSlave);
    }

Member Data Documentation

diffKsiMaster

MatrixDouble SimpleContactProblem::ConvectSlaveIntegrationPts::diffKsiMaster

private

Definition at line 171 of file SimpleContact.hpp.

diffKsiSlave

MatrixDouble SimpleContactProblem::ConvectSlaveIntegrationPts::diffKsiSlave

private

Definition at line 172 of file SimpleContact.hpp.

fePtr

SimpleContactElement* const SimpleContactProblem::ConvectSlaveIntegrationPts::fePtr

private

Definition at line 157 of file SimpleContact.hpp.

masterMaterialCoords

MatrixDouble SimpleContactProblem::ConvectSlaveIntegrationPts::masterMaterialCoords

private

Definition at line 167 of file SimpleContact.hpp.

masterN

MatrixDouble SimpleContactProblem::ConvectSlaveIntegrationPts::masterN

private

Definition at line 169 of file SimpleContact.hpp.

masterSpatialCoords

MatrixDouble SimpleContactProblem::ConvectSlaveIntegrationPts::masterSpatialCoords

private

Definition at line 166 of file SimpleContact.hpp.

materialCoords

VectorDouble SimpleContactProblem::ConvectSlaveIntegrationPts::materialCoords

private

Definition at line 163 of file SimpleContact.hpp.

materialPositionsField

const string SimpleContactProblem::ConvectSlaveIntegrationPts::materialPositionsField

private

Definition at line 160 of file SimpleContact.hpp.

slaveMaterialCoords

MatrixDouble SimpleContactProblem::ConvectSlaveIntegrationPts::slaveMaterialCoords

private

Definition at line 165 of file SimpleContact.hpp.

slaveN

MatrixDouble SimpleContactProblem::ConvectSlaveIntegrationPts::slaveN

private

Definition at line 168 of file SimpleContact.hpp.

slaveSpatialCoords

MatrixDouble SimpleContactProblem::ConvectSlaveIntegrationPts::slaveSpatialCoords

private

Definition at line 164 of file SimpleContact.hpp.

sparialPositionsField

const string SimpleContactProblem::ConvectSlaveIntegrationPts::sparialPositionsField

private

Definition at line 159 of file SimpleContact.hpp.

spatialCoords

VectorDouble SimpleContactProblem::ConvectSlaveIntegrationPts::spatialCoords

private

Definition at line 162 of file SimpleContact.hpp.

---

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

• users_modules/mortar_contact/src/SimpleContact.hpp
• users_modules/mortar_contact/src/impl/SimpleContact.cpp