EshelbianContact.hpp

Go to the documentation of this file.

/**
 * @file EshelbianContact.hpp
 * @brief
 * @date 2023-05-13
 *
 * @copyright Copyright (c) 2023
 *
 */
 
namespace ContactOps {
 
using EntData = EntitiesFieldData::EntData;
using BoundaryEle = FaceElementForcesAndSourcesCore;
using BoundaryEleOp = BoundaryEle::UserDataOperator;
 
using AssemblyBoundaryEleOp =
    FormsIntegrators<BoundaryEleOp>::Assembly<A>::OpBase;
 
double cn_contact = 1;
double scale = 1;
 
} // namespace ContactOps
 
#include <ContactOps.hpp>
 
namespace EshelbianPlasticity {
 
 
struct ContactTree
    : public PostProcBrokenMeshInMoabBase<FaceElementForcesAndSourcesCore> {
 
  using Base = PostProcBrokenMeshInMoabBase<FaceElementForcesAndSourcesCore>;
  using Base::refElementsMap;
 
  ContactTree(MoFEM::Interface &m_field,
              boost::shared_ptr<moab::Core> core_mesh_ptr, int max_order,
              std::map<int, Range> &&body_map);
  MoFEMErrorCode preProcess();
  MoFEMErrorCode postProcess();
  inline boost::shared_ptr<OrientedBoxTreeTool> &getTreeSurfPtr() {
    return treeSurfPtr;
  }
  inline auto getRootSetSurf() { return rootSetSurf; }
  int getMaxLevel() const { return refElementsMap.at(MBTRI)->defMaxLevel; }
 
  friend struct OpMoveNode;
  friend struct OpTreeSearch;
  friend struct OpConstrainBoundaryRhs;
 
  struct FaceData {
    int gaussPtNb; //< integration points number
    double gap;
 
    // std::vector<int> dofsIds;
    // std::vector<double> dofsCoeffs;
    // std::vector<double> baseFuncs;
 
    // std::array<double, 9> closeH1Coords;
    // std::array<double, 9> farH1Coords;
    // std::array<double, 9> closeL2Coords;
    // std::array<double, 9> farL2Coords;
 
    FaceData() = default;
  };
 
  using MapFaceData = std::map<EntityHandle, std::vector<FaceData>>;
 
  inline auto findFaceFataVecPtr(EntityHandle fe_ent) {
    auto &map_face_data = shadowDataMap;
    auto it = map_face_data.find(fe_ent);
    if (it == map_face_data.end()) {
      return (std::vector<FaceData> *)nullptr;
    }
    return &(it->second);
  }
 
  inline auto getFaceDataPtr(std::vector<FaceData>::iterator &it, int gg,
                             std::vector<FaceData> *vec_ptr) {
    FaceData *face_data_ptr = nullptr;
    if (it != vec_ptr->end()) {
      if (it->gaussPtNb == gg) {
        face_data_ptr = &(*it);
        ++it;
      }
    }
    return face_data_ptr;
  }
 
protected:
  MoFEMErrorCode buildTree(Range &ents);
  boost::shared_ptr<OrientedBoxTreeTool> treeSurfPtr;
  EntityHandle rootSetSurf;
 
  Tag thEleId;
  Tag thCoeffs;
  Tag thIds;
  Tag thBases;
  Tag thBodyId;
  Tag thSmallXH1;
 
  MapFaceData shadowDataMap;
 
  std::map<int, Range> bodyMap;
 
  const int maxOrder;
};
 
 
using MBSurfaceDistanceFunction = boost::function<double(
    double t, double x, double y, double z, double tx, double ty, double tz,
    ContactTree::FaceData *face_data_ptr)>;
 
using MBGradSurfaceDistanceFunction =
    boost::function<FTensor::Tensor1<double, 3>(
        double t, double x, double y, double z, double tx, double ty, double tz,
        ContactTree::FaceData *face_data_ptr)>;
 
using MBHessSurfaceDistanceFunction =
    boost::function<FTensor::Tensor2_symmetric<double, 3>(
        double t, double x, double y, double z, double tx, double ty, double tz,
        ContactTree::FaceData *face_data_ptr)>;
 
inline double
mb_surface_distance_function(double t, double x, double y, double z, double tx,
                             double ty, double tz,
                             ContactTree::FaceData *face_data_ptr) {
  return ContactOps::surface_distance_function(t, x, y, z, tx, ty, tz);
}
 
inline FTensor::Tensor1<double, 3>
mb_grad_surface_distance_function(double t, double x, double y, double z,
                                  double tx, double ty, double tz,
                                  ContactTree::FaceData *face_data_ptr) {
  return ContactOps::grad_surface_distance_function(t, x, y, z, tx, ty, tz);
}
 
inline FTensor::Tensor2_symmetric<double, 3>
mb_hess_surface_distance_function(double t, double x, double y, double z,
                                  double tx, double ty, double tz,
                                  ContactTree::FaceData *face_data_ptr) {
  return ContactOps::hess_surface_distance_function(t, x, y, z, tx, ty, tz);
}
 
struct OpConstrainBoundaryRhs : public ContactOps::AssemblyBoundaryEleOp {
 
  OpConstrainBoundaryRhs(
      const std::string row_field_name,
      boost::shared_ptr<ContactOps::CommonData> common_data_ptr,
      boost::shared_ptr<ContactTree> conact_tree_ptr);
 
  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data);
 
private:
  MBSurfaceDistanceFunction surfaceDistanceFunction =
      mb_surface_distance_function;
  MBGradSurfaceDistanceFunction gradSurfaceDistanceFunction =
      mb_grad_surface_distance_function;
  MBHessSurfaceDistanceFunction hessSurfaceDistanceFunction =
      mb_hess_surface_distance_function;
 
  boost::shared_ptr<ContactOps::CommonData> commonDataPtr;
  boost::shared_ptr<ContactTree> contactTreePtr;
};
 
struct OpConstrainBoundaryLhs_dU : public ContactOps::AssemblyBoundaryEleOp {
 
  OpConstrainBoundaryLhs_dU(
      const std::string row_field_name,
      boost::shared_ptr<ContactOps::CommonData> common_data_ptr,
      boost::shared_ptr<EntitiesFieldData::EntData> col_data_ptr,
      boost::shared_ptr<ContactTree> conact_tree_ptr);
 
  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data);
  MoFEMErrorCode aSsemble(EntitiesFieldData::EntData &row_data);
 
private:
  MBSurfaceDistanceFunction surfaceDistanceFunction =
      mb_surface_distance_function;
  MBGradSurfaceDistanceFunction gradSurfaceDistanceFunction =
      mb_grad_surface_distance_function;
  MBHessSurfaceDistanceFunction hessSurfaceDistanceFunction =
      mb_hess_surface_distance_function;
 
  boost::shared_ptr<ContactOps::CommonData> commonDataPtr;
  boost::shared_ptr<EntitiesFieldData::EntData> colDataPtr;
  boost::shared_ptr<ContactTree> contactTreePtr;
};
 
struct OpConstrainBoundaryLhs_dP
    : public ContactOps::AssemblyBoundaryEleOp {
 
  OpConstrainBoundaryLhs_dP(
      const std::string row_field_name,
      boost::shared_ptr<ContactOps::CommonData> common_data_ptr,
      boost::shared_ptr<ContactTree> conact_tree_ptr);
 
  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
                           EntitiesFieldData::EntData &col_data);
 
private:
  MBSurfaceDistanceFunction surfaceDistanceFunction =
      mb_surface_distance_function;
  MBGradSurfaceDistanceFunction gradSurfaceDistanceFunction =
      mb_grad_surface_distance_function;
  MBHessSurfaceDistanceFunction hessSurfaceDistanceFunction =
      mb_hess_surface_distance_function;
 
  boost::shared_ptr<ContactOps::CommonData> commonDataPtr;
  boost::shared_ptr<ContactTree> contactTreePtr;
};
 
struct OpLoopSideGetDataForSideEle : ForcesAndSourcesCore::UserDataOperator {
 
  using UDO = ForcesAndSourcesCore::UserDataOperator;
 
  OpLoopSideGetDataForSideEle(
      const std::string field_name,
      boost::shared_ptr<EntitiesFieldData::EntData> col_data_ptr);
 
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
 
protected:
  boost::shared_ptr<EntitiesFieldData::EntData> colDataPtr;
};
 
struct OpMoveNode : public FaceElementForcesAndSourcesCore::UserDataOperator {
 
  using UOP = FaceElementForcesAndSourcesCore::UserDataOperator;
 
  OpMoveNode(boost::shared_ptr<ContactTree> contact_tree_ptr,
             boost::shared_ptr<ContactOps::CommonData> common_data_ptr,
             boost::shared_ptr<MatrixDouble> u_h1_ptr,
             boost::shared_ptr<EntitiesFieldData::EntData> col_data_ptr);
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
 
protected:
  boost::shared_ptr<ContactTree> contactTreePtr;
  boost::shared_ptr<MatrixDouble> uH1Ptr;
  boost::shared_ptr<ContactOps::CommonData> commonDataPtr;
  boost::shared_ptr<EntitiesFieldData::EntData> colDataPtr;
};
 
struct OpTreeSearch : public FaceElementForcesAndSourcesCore::UserDataOperator {
 
  using UOP = FaceElementForcesAndSourcesCore::UserDataOperator;
 
  OpTreeSearch(boost::shared_ptr<ContactTree> contact_tree_ptr,
               boost::shared_ptr<ContactOps::CommonData> common_data_ptr,
 
               moab::Interface *post_proc_mesh_ptr,
               std::vector<EntityHandle> *map_gauss_pts_ptr
 
  );
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
 
protected:
  boost::shared_ptr<ContactTree> contactTreePtr;
  boost::shared_ptr<ContactOps::CommonData> commonDataPtr;
  moab::Interface *postProcMeshPtr = nullptr;
  std::vector<EntityHandle> *mapGaussPtsPtr = nullptr;
};
 
} // namespace EshelbianPlasticity