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 SideEle = FaceElementForcesAndSourcesCoreOnSide;
 
using AssemblyBoundaryEleOp =
    FormsIntegrators<BoundaryEleOp>::Assembly<A>::OpBase;
 
double cn_contact = 1;
double alpha_contact_const = 1;
double alpha_contact_quadratic = 1;
double scale = 1;
 
double airplane_ray_distance = 1; // thi is point from which plane send ray.
                                  // This is multiple of elem radius.
 
} // 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;
 
  struct FaceData {
    int gaussPtNb; //< integration points number
    std::array<double, 3> slavePoint;
    std::array<double, 3> masterPoint;
    std::array<double, 3> rayPoint;
    std::array<double, 3> unitRay;
    double eleRadius;
 
    // std::vector<int> dofsSlaveIds;
    // std::vector<double> dofsSlaveCoeff;
    // std::vector<double> baseSlaveFuncs;
 
    std::array<double, 9> masterPointNodes;
    std::array<double, 9> masterTractionNodes;
    std::array<double, 9> slavePointNodes;
    std::array<double, 9> slaveTractionNodes;
 
    FaceData() = default;
  };
 
  using MapFaceData = std::map<EntityHandle, std::vector<FaceData>>;
 
  inline auto findFaceDataVecPtr(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 thCoeff;
  // Tag thIds;
  // Tag thBases;
  Tag thBodyId;
  Tag thSmallX;
  Tag thLargeX;
  Tag thTraction;
 
  MapFaceData shadowDataMap;
 
  std::map<int, Range> bodyMap;
 
  const int maxOrder;
};
 
struct OpConstrainBoundaryL2Rhs : public ContactOps::AssemblyBoundaryEleOp {
  OpConstrainBoundaryL2Rhs(
      const std::string row_field_name,
      boost::shared_ptr<ContactOps::CommonData> common_data_ptr,
      boost::shared_ptr<ContactTree> contact_tree_ptr,
      boost::shared_ptr<std::map<int, Range>> sdf_map_range_ptr = nullptr);
 
  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data);
 
private:
  boost::shared_ptr<ContactOps::CommonData> commonDataPtr;
  boost::shared_ptr<ContactTree> contactTreePtr;
  boost::shared_ptr<std::map<int, Range>> sdfMapRangePtr;
};
 
template <AssemblyType A, IntegrationType I>
struct OpConstrainBoundaryHDivRhs;
 
template <AssemblyType A>
struct OpConstrainBoundaryHDivRhs<A, IntegrationType::GAUSS>
    : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
 
  using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
      A>::OpBrokenBase;
 
  OpConstrainBoundaryHDivRhs(
      boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
      boost::shared_ptr<ContactOps::CommonData> common_data_ptr,
      boost::shared_ptr<ContactTree> contact_tree_ptr);
 
  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data);
 
private:
  boost::shared_ptr<ContactOps::CommonData> commonDataPtr;
  boost::shared_ptr<ContactTree> contactTreePtr;
};
 
struct OpConstrainBoundaryL2Lhs_dU : public ContactOps::AssemblyBoundaryEleOp {
 
  OpConstrainBoundaryL2Lhs_dU(
      const std::string row_field_name, const std::string col_field_name,
      boost::shared_ptr<ContactOps::CommonData> common_data_ptr,
      boost::shared_ptr<ContactTree> contact_tree_ptr,
      boost::shared_ptr<std::map<int, Range>> sdf_map_range_ptr = nullptr);
 
  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
                           EntitiesFieldData::EntData &col_data);
 
private:
  boost::shared_ptr<ContactOps::CommonData> commonDataPtr;
  boost::shared_ptr<ContactTree> contactTreePtr;
  boost::shared_ptr<std::map<int, Range>> sdfMapRangePtr;
};
 
template <AssemblyType A, IntegrationType I> struct OpConstrainBoundaryL2Lhs_dP;
 
template <AssemblyType A>
struct OpConstrainBoundaryL2Lhs_dP<A, IntegrationType::GAUSS>
    : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
 
  using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
      A>::OpBrokenBase;
 
  OpConstrainBoundaryL2Lhs_dP(
      std::string row_field_name,
      boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
      boost::shared_ptr<ContactOps::CommonData> common_data_ptr,
      boost::shared_ptr<ContactTree> contact_tree_ptr,
      boost::shared_ptr<std::map<int, Range>> sdf_map_range_ptr = nullptr);
 
  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
                           EntitiesFieldData::EntData &col_data);
 
private:
  boost::shared_ptr<ContactOps::CommonData> commonDataPtr;
  boost::shared_ptr<ContactTree> contactTreePtr;
  boost::shared_ptr<std::map<int, Range>> sdfMapRangePtr;
};
 
template <AssemblyType A, IntegrationType I>
struct OpConstrainBoundaryHDivLhs_dU;
 
template <AssemblyType A>
struct OpConstrainBoundaryHDivLhs_dU<A, IntegrationType::GAUSS>
    : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
 
  using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
      A>::OpBrokenBase;
 
  OpConstrainBoundaryHDivLhs_dU(
      boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
      std::string col_field_name,
      boost::shared_ptr<ContactOps::CommonData> common_data_ptr,
      boost::shared_ptr<ContactTree> contact_tree_ptr);
 
  MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
                           EntitiesFieldData::EntData &col_data);
 
private:
  boost::shared_ptr<ContactOps::CommonData> commonDataPtr;
  boost::shared_ptr<ContactTree> contactTreePtr;
};
 
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);
  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;
};
 
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,
               boost::shared_ptr<MatrixDouble> u_h1_ptr, Range r,
 
               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;
  boost::shared_ptr<MatrixDouble> uH1Ptr;
 
  moab::Interface *postProcMeshPtr = nullptr;
  std::vector<EntityHandle> *mapGaussPtsPtr = nullptr;
 
  Range contactRange;
};
 
} // namespace EshelbianPlasticity