EshelbianMonitor.cpp

Go to the documentation of this file.

/** @file
    @brief Contains definition of EshelbianMonitor class.
    @ingroup EshelbianPlasticty
*/
 
struct EshelbianMonitor : public FEMethod {
 
  using Ele = ForcesAndSourcesCore;
  using VolEle = VolumeElementForcesAndSourcesCore;
  using VolOp = VolumeElementForcesAndSourcesCore::UserDataOperator;
  using SetPtsData = FieldEvaluatorInterface::SetPtsData;
  using PtsHashMap = std::map<std::string, std::array<double, 3>>;
  using FaceSideEle =
      PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::FaceSideEle;
 
  EshelbianMonitor(EshelbianCore &ep)
      : eP(ep), dataFieldEval(ep.mField.getInterface<FieldEvaluatorInterface>()
                                  ->getData<VolEle>()),
        volPostProcEnergy(new VolEle(ep.mField)), gEnergy(new double) {
    CHK_THROW_MESSAGE(
        ep.mField.getInterface<FieldEvaluatorInterface>()->buildTree<SPACE_DIM>(
            dataFieldEval, "EP"),
        "build field evaluator tree");
 
    CHK_THROW_MESSAGE(setElementForFieldEval(), "set element for field");
    CHK_THROW_MESSAGE(readPtsFromFile(), "read post proc points");
    CHK_THROW_MESSAGE(readPtsFromOptions(), "read post proc point options");
    CHK_THROW_MESSAGE(setElementForPostProcessEnergy(),
                      "set element for post energy");
 
    CHK_THROW_MESSAGE(PetscOptionsGetBool(PETSC_NULLPTR, "", "-write_restart",
                                          &writeRestart, PETSC_NULLPTR),
                      "get write restart option");
    CHK_THROW_MESSAGE(PetscOptionsGetInt(PETSC_NULLPTR, "",
                                         "-write_restart_every",
                                         &writeRestartEvery, PETSC_NULLPTR),
                      "get write restart option");
    if (writeRestartEvery <= 0)
      CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                        "-write_restart_every must be positive");
 
    MOFEM_LOG("EP", Sev::inform) << "EshelbianMonitor writeRestart "
                                 << (writeRestart ? "true" : "false");
 
    MOFEM_LOG("EP", Sev::inform) << "EshelbianMonitor writeRestartEvery "
                                 << writeRestartEvery << " steps";
  }
 
  virtual ~EshelbianMonitor() {
    adjointGradientVector.reset();
  }
 
  MoFEMErrorCode preProcess() { return 0; }
 
  MoFEMErrorCode operator()() { return 0; }
 
  MoFEMErrorCode postProcess() {
    MoFEMFunctionBegin;
 
    MOFEM_LOG("EP", Sev::inform) << "Monitor postProcess";
 
    CHKERR saveRestartFile();
    CHKERR calculateReactionForces();
    CHKERR calculateEnergy();
    CHKERR postProcessPoints();
 
    CHKERR postProcessMaterialForces();
    CHKERR postProcessSkin();
    CHKERR postProcessSkeletonResults();
 
    MoFEMFunctionReturn(0);
  }
 
  MoFEMErrorCode setElementForPostProcessEnergy();
  std::string getStep();
  MoFEMErrorCode calculateReactionForces();
  MoFEMErrorCode calculateEnergy();
  MoFEMErrorCode saveRestartFile();
  MoFEMErrorCode postProcessSkin();
  MoFEMErrorCode postProcessMaterialForces();
  MoFEMErrorCode postProcessSkeletonResults();
  MoFEMErrorCode readPtsFromFile();
  MoFEMErrorCode readPtsFromOptions();
  MoFEMErrorCode setElementForFieldEval();
  MoFEMErrorCode postProcessPoints();
  MoFEMErrorCode postProcAtPoints(std::array<double, 3> point, std::string str);
 
  std::map<std::string, std::array<double, 6>> &getReactionMap() {
    return reactionForcesMap;
  }
 
  EshelbianCore &getEpCore() { return eP; }
 
  boost::shared_ptr<SetPtsData> &getDataField() { return dataFieldEval; }
 
  PtsHashMap &getHashMap() { return ptsHashMap; }
 
  boost::shared_ptr<double> &getEnergy() { return gEnergy; }
 
  inline static SmartPetscObj<Vec> adjointGradientVector = SmartPetscObj<Vec>();
 
protected:
  std::map<std::string, std::array<double, 6>> reactionForcesMap;
  EshelbianCore &eP;
  boost::shared_ptr<SetPtsData> dataFieldEval;
  PtsHashMap ptsHashMap;
  boost::shared_ptr<double> gEnergy;
  boost::shared_ptr<VolEle> volPostProcEnergy;
  PetscBool writeRestart = PETSC_FALSE;
  PetscInt writeRestartEvery = 1;
};
 
MoFEMErrorCode EshelbianMonitor::setElementForPostProcessEnergy() {
  MoFEMFunctionBegin;
  // set time to post processing elements
  volPostProcEnergy->data_ctx |= PetscData::CTX_SET_TIME;
  CHKERR eP.setBaseVolumeElementOps(1, false, false, false, volPostProcEnergy);
 
  CHKERR eP.physicalEquations->pushEnergyEvaluation(
      eP, volPostProcEnergy->getOpPtrVector(), eP.dataAtPts, gEnergy);
 
  MoFEMFunctionReturn(0);
};
 
std::string EshelbianMonitor::getStep() {
  std::ostringstream ss;
  ss << boost::str(boost::format("%d") % static_cast<int>(ts_step));
  return ss.str();
};
 
MoFEMErrorCode EshelbianMonitor::calculateReactionForces() {
  MoFEMFunctionBegin;
 
  // Get boundary faces marked in blocks name "SPATIAL_DISP_...".
  auto get_ents_on_mesh_skin = [&]() {
    std::map<std::string, Range> boundary_entities_vec;
 
    auto get_block_vec_impl = [&](auto block_name) {
      return eP.mField.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(
          std::regex(
 
              (boost::format("%s(.*)") % block_name).str()
 
                  ));
    };
 
    auto add_blockset_ents_impl = [&](auto &&vec) {
      MoFEMFunctionBegin;
      for (auto it : vec) {
        Range boundary_entities;
        CHKERR it->getMeshsetIdEntitiesByDimension(eP.mField.get_moab(), 2,
                                                   boundary_entities, true);
        std::string meshset_name = it->getName();
        boundary_entities_vec[meshset_name] = boundary_entities;
        boundary_entities.clear();
      }
      MoFEMFunctionReturn(0);
    };
 
    for (auto block_name :
         {"SPATIAL_DISP", "FIX", "CONTACT", "SPATIAL_ROTATION",
          "NORMAL_DISPLACEMENT", "ANALYTICAL_DISPLACEMENT", "SPRING_BC"}) {
      CHK_THROW_MESSAGE(add_blockset_ents_impl(get_block_vec_impl(block_name)),
                        "add blockset entities");
    }
 
    return boundary_entities_vec;
  };
 
  auto boundary_entities_vec = get_ents_on_mesh_skin();
 
  std::vector<std::tuple<std::string, Range, std::array<double, 6>>>
      reactionForces;
  for (const auto &pair : boundary_entities_vec) {
    reactionForces.push_back(
        std::make_tuple(pair.first, pair.second,
                        std::array<double, 6>{0.0, 0.0, 0.0, 0.0, 0.0, 0.0}));
  }
 
  auto integration_rule_face = [](int, int, int approx_order) {
    return 2 * approx_order + 1;
  };
  auto face_fe = boost::make_shared<FaceElementForcesAndSourcesCore>(eP.mField);
  face_fe->getRuleHook = integration_rule_face;
  CHKERR
  EshelbianPlasticity::AddHOOps<SPACE_DIM - 1, SPACE_DIM, SPACE_DIM>::add(
      face_fe->getOpPtrVector(), {L2}, eP.materialH1Positions,
      eP.frontAdjEdges);
 
  auto op_side =
      new OpLoopSide<FaceSideEle>(eP.mField, "EP", SPACE_DIM, Sev::noisy);
  face_fe->getOpPtrVector().push_back(op_side);
  auto side_fe_ptr = op_side->getSideFEPtr();
  auto base_ptr =
      boost::make_shared<EshelbianPlasticity::CGGUserPolynomialBase>();
  side_fe_ptr->getUserPolynomialBase() = base_ptr;
  CHKERR
  EshelbianPlasticity::AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
      side_fe_ptr->getOpPtrVector(), {H1, HDIV, L2}, eP.materialH1Positions,
      eP.frontAdjEdges);
  auto piola_scale_ptr = boost::make_shared<double>(1.0);
  side_fe_ptr->getOpPtrVector().push_back(
      new OpCalculateHVecTensorField<SPACE_DIM, SPACE_DIM>(
          eP.piolaStress, eP.dataAtPts->getApproxPAtPts(), piola_scale_ptr));
  constexpr bool add_bubble_field = false;
  if (add_bubble_field) {
    side_fe_ptr->getOpPtrVector().push_back(
        new OpCalculateHTensorTensorField<3, 3>(
            eP.bubbleField, eP.dataAtPts->getApproxPAtPts(), MBMAXTYPE));
  }
  side_fe_ptr->getOpPtrVector().push_back(
      new OpCalculateTractionFromSideEle(eP.dataAtPts));
  side_fe_ptr->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
      eP.spatialL2Disp, eP.dataAtPts->getSmallWL2AtPts(), MBTET));
  for (auto &[name, ents, reaction_vec] : reactionForces) {
    face_fe->getOpPtrVector().push_back(
        new OpCalculateReactionForces(eP.dataAtPts, name, ents, reaction_vec));
  }
 
  CHKERR eP.mField.loop_finite_elements(problemPtr->getName(), eP.skinElement,
                                        *face_fe);
 
  for (auto &[name, ents, reaction_vec] : reactionForces) {
    std::array<double, 6> block_reaction_force{0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
 
    MPI_Allreduce(reaction_vec.data(), &block_reaction_force, 6, MPI_DOUBLE,
                  MPI_SUM, eP.mField.get_comm());
 
    for (auto &force : block_reaction_force) {
      if (std::abs(force) < 1e-12) {
        force = 0.0;
      }
    }
    // Store the reaction forces for later access
    reactionForcesMap[name] = block_reaction_force;
    MOFEM_LOG_C("EP", Sev::inform,
                "Step %d time %3.4g Block %s Reaction force [%3.6e, "
                "%3.6e, %3.6e]",
                ts_step, ts_t, name.c_str(), block_reaction_force[0],
                block_reaction_force[1], block_reaction_force[2]);
    MOFEM_LOG_C("EP", Sev::inform,
                "Step %d time %3.4g  Block %s Moment [%3.6e, %3.6e, %3.6e]",
                ts_step, ts_t, name.c_str(), block_reaction_force[3],
                block_reaction_force[4], block_reaction_force[5]);
  }
  MoFEMFunctionReturn(0);
};
 
MoFEMErrorCode EshelbianMonitor::calculateEnergy() {
  MoFEMFunctionBegin;
  // Loop boundary elements with traction boundary conditions
  *gEnergy = 0;
  // set time to post proc energy
  const bool has_ts = (ts != PETSC_NULLPTR);
  if (has_ts) {
    CHKERR TSGetTime(ts, &(volPostProcEnergy->ts_t));
    CHKERR TSGetTimeStep(ts, &(volPostProcEnergy->ts_dt));
  }
  TetPolynomialBase::switchCacheBaseOn<HDIV>({volPostProcEnergy.get()});
  CHKERR eP.mField.loop_finite_elements(problemPtr->getName(), "EP",
                                        *volPostProcEnergy);
  TetPolynomialBase::switchCacheBaseOff<HDIV>({volPostProcEnergy.get()});
 
  double body_energy = 0;
  MPI_Allreduce(gEnergy.get(), &body_energy, 1, MPI_DOUBLE, MPI_SUM,
                eP.mField.get_comm());
  *gEnergy = body_energy;
  if (EshelbianCore::crackingOn) {
    CHKERR eP.calculateCrackArea(eP.currentCrackAreaPtr);
    // store strain energy
    eP.strainEnergy = body_energy;
    MOFEM_LOG_C("EP", Sev::inform,
                "Step %d time %3.4g strain energy %3.12e crack "
                "area %3.12e",
                ts_step, ts_t, body_energy, *eP.currentCrackAreaPtr);
    if (eP.mField.get_comm_rank() == 0) {
      auto crack_faces = *eP.crackFaces;
      if (crack_faces.empty()) {
        crack_faces = *eP.frontEdges;
      }
      CHKERR save_range(
          eP.mField.get_moab(),
          (boost::format("crack_faces_step_%d.vtk") % ts_step).str(),
          crack_faces);
      CHKERR save_range(
          eP.mField.get_moab(),
          (boost::format("front_edges_step_%d.vtk") % ts_step).str(),
          *eP.frontEdges);
    }
 
  } else {
    MOFEM_LOG_C("EP", Sev::inform, "Step %d time %3.4g strain energy %3.6e",
                ts_step, ts_t, body_energy);
  }
  MoFEMFunctionReturn(0);
};
 
MoFEMErrorCode EshelbianMonitor::saveRestartFile() {
  MoFEMFunctionBegin;
 
  if (writeRestart && ts_u && (ts_step % writeRestartEvery == 0)) {
    const std::string restart_file = "restart_" + getStep() + ".dat";
    PetscViewer viewer;
    CHKERR PetscViewerBinaryOpen(PETSC_COMM_WORLD,
                                 restart_file.c_str(),
                                 FILE_MODE_WRITE, &viewer);
    CHKERR PetscViewerBinarySetSkipInfo(viewer, PETSC_TRUE);
    CHKERR VecView(ts_u, viewer);
    CHKERR PetscViewerDestroy(&viewer);
    CHKERR writeRestartLayout(eP, ts_u, restart_file);
    CHKERR eP.postProcessRestartMesh(1, "out_restart_mesh_" +
                                            getStep() + ".h5m");
  }
  MoFEMFunctionReturn(0);
};
 
MoFEMErrorCode EshelbianMonitor::postProcessSkin() {
  MoFEMFunctionBegin;
  CHKERR eP.postProcessResults(1, "out_sol_elastic_" + getStep() + ".h5m",
                               PETSC_NULLPTR, PETSC_NULLPTR,
                               adjointGradientVector, {}, ts);
  MoFEMFunctionReturn(0);
};
 
MoFEMErrorCode EshelbianMonitor::postProcessMaterialForces() {
  MoFEMFunctionBegin;
  // Function to get material force tags
  if (!EshelbianCore::crackingOn) {
    int nb_front_faces = eP.frontEdges->size();
    MPI_Allreduce(MPI_IN_PLACE, &nb_front_faces, 1, MPI_INT, MPI_SUM,
                  eP.mField.get_comm());
    if (nb_front_faces > 0) {
      CHKERR eP.calculateFaceMaterialForce(1, ts, &adjointGradientVector);
    }
  }
  MoFEMFunctionReturn(0);
};
 
MoFEMErrorCode EshelbianMonitor::postProcessSkeletonResults() {
  MoFEMFunctionBegin;
  auto get_material_force_tags = [&]() {
    auto &moab = eP.mField.get_moab();
    std::vector<Tag> tags;
    for (const auto *name : {"MaterialForce", "FacePressure"}) {
      Tag tag;
      const auto rval = moab.tag_get_handle(name, tag);
      if (rval == MB_SUCCESS)
        tags.push_back(tag);
      else if (rval != MB_TAG_NOT_FOUND)
        CHK_MOAB_THROW(rval, "can't get tag");
    }
    return tags;
  };
  // Post-process skeleton elements
  bool post_process_skeleton = false;
#ifndef NDEBUG
  post_process_skeleton = true;
#endif
  if (post_process_skeleton) {
    CHKERR eP.postProcessSkeletonResults(
        1, "out_skeleton_" + getStep() + ".h5m", PETSC_NULLPTR,
        get_material_force_tags(), ts);
  }
  MoFEMFunctionReturn(0);
};
 
MoFEMErrorCode EshelbianMonitor::readPtsFromFile() {
  MoFEMFunctionBegin;
  std::ifstream file("points.txt"); // Open the file with the name "data.txt"
 
  if (!file.is_open()) {
    MoFEMFunctionReturnHot(0);
  }
 
  std::string line;
 
  while (std::getline(file, line)) {
    std::istringstream iss(line);
    std::string col1;
    double col2, col3, col4;
 
    if (iss >> col1 >> col2 >> col3 >> col4) {
      MOFEM_LOG("EP", Sev::verbose)
          << "Read: " << col1 << ", " << col2 << ", " << col3 << ", " << col4;
      ptsHashMap[col1] = {col2, col3, col4};
    } else {
      MOFEM_LOG("EP", Sev::error) << "Error parsing line: " << line;
    }
  }
 
  file.close(); // Close the file
  MoFEMFunctionReturn(0);
};
 
MoFEMErrorCode EshelbianMonitor::readPtsFromOptions() {
  MoFEMFunctionBegin;
 
  std::array<double, SPACE_DIM> field_eval_coords{};
  PetscInt coords_dim = SPACE_DIM;
  PetscBool do_eval_field = PETSC_FALSE;
  CHKERR PetscOptionsGetRealArray(
      PETSC_NULLPTR, PETSC_NULLPTR, "-field_eval_coords",
      field_eval_coords.data(), &coords_dim, &do_eval_field);
 
  if (do_eval_field && coords_dim != SPACE_DIM)
    SETERRQ(PETSC_COMM_WORLD, MOFEM_INVALID_DATA,
            "-field_eval_coords requires exactly three coordinates");
 
  if (do_eval_field) {
    ptsHashMap["field_eval_coords"] = field_eval_coords;
    MOFEM_LOG_C("EP", Sev::inform,
                "FieldEvaluator added command-line point [%6.4e, %6.4e, "
                "%6.4e]",
                field_eval_coords[0], field_eval_coords[1],
                field_eval_coords[2]);
  }
 
  PetscBool test_cook_pts = PETSC_FALSE;
  CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-test_cook_pts",
                             &test_cook_pts, PETSC_NULLPTR);
  if (test_cook_pts) {
    ptsHashMap["Point A"] = {48., 60., 4.999};
    ptsHashMap["Point B"] = {48. / 2., 44. + (60. - 44.) / 2., 0.};
    ptsHashMap["Point C"] = {48. / 2., (44. - 0.) / 2., 0.};
  }
 
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode EshelbianMonitor::setElementForFieldEval() {
  MoFEMFunctionBegin;
  boost::shared_ptr<Ele> vol_ele(dataFieldEval->feMethodPtr);
  auto no_rule = [](int, int, int) { return -1; };
  vol_ele->getRuleHook = no_rule;
  vol_ele->getUserPolynomialBase() =
      boost::make_shared<CGGUserPolynomialBase>();
  EshelbianPlasticity::AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
      vol_ele->getOpPtrVector(), {HDIV, H1, L2}, eP.materialH1Positions,
      eP.frontAdjEdges);
 
  auto piola_scale_ptr = boost::make_shared<double>(1.0);
  vol_ele->getOpPtrVector().push_back(new OpCalculateHVecTensorField<3, 3>(
      eP.piolaStress, eP.dataAtPts->getApproxPAtPts(), piola_scale_ptr));
  vol_ele->getOpPtrVector().push_back(new OpCalculateHTensorTensorField<3, 3>(
      eP.bubbleField, eP.dataAtPts->getApproxPAtPts(), piola_scale_ptr,
      SmartPetscObj<Vec>(), MBMAXTYPE));
  vol_ele->getOpPtrVector().push_back(new OpCalculateL2RotationValues(
      eP.rotAxis, eP.dataAtPts->getRotAxisAtPts(),
      eP.dataAtPts->constantRotation, eP.dataAtPts->higherRotation));
  CHKERR VecSetDM(eP.solTSStep, PETSC_NULLPTR);
  vol_ele->getOpPtrVector().push_back(new OpCalculateHVecTensorField<3, 3>(
      eP.piolaStress, eP.dataAtPts->getApproxP0AtPts(), nullptr,
      eP.solTSStep));
  CHKERR eP.physicalEquations->pushMaterialFields(
      eP, vol_ele->getOpPtrVector(), eP.dataAtPts, PhysicalEquations::PREVIOUS);
  CHKERR eP.physicalEquations->pushMaterialFields(eP, vol_ele->getOpPtrVector(),
                                                  eP.dataAtPts);
  vol_ele->getOpPtrVector().push_back(new OpCalculateL2RotationValues(
      eP.rotAxis, boost::make_shared<MatrixDouble>(),
      eP.dataAtPts->previousConstantRotation,
      eP.dataAtPts->previousHigherRotation, eP.solTSStep));
  vol_ele->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
      eP.spatialL2Disp, eP.dataAtPts->getSmallWL2AtPts(), MBTET));
 
  // H1 displacements
  vol_ele->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
      eP.spatialH1Disp, eP.dataAtPts->getSmallWH1AtPts()));
  vol_ele->getOpPtrVector().push_back(new OpCalculateVectorFieldGradient<3, 3>(
      eP.spatialH1Disp, eP.dataAtPts->getSmallWGradH1AtPts()));
 
  CHKERR addCalculatePlasticLogarithmicStretchFieldValues(
      vol_ele->getOpPtrVector(), eP.plasticHField,
      eP.dataAtPts->getPlasticH(), MBTET);
  vol_ele->getOpPtrVector().push_back(
      new OpCalculateRotationAndSpatialGradient(eP.dataAtPts));
  MoFEMFunctionReturn(0);
};
 
MoFEMErrorCode EshelbianMonitor::postProcessPoints() {
  MoFEMFunctionBegin;
 
  for (const auto &[label, point] : ptsHashMap)
    CHKERR postProcAtPoints(point, label);
 
  if (!ptsHashMap.empty())
    MOFEM_LOG_SEVERITY_SYNC(eP.mField.get_comm(), Sev::inform);
 
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode EshelbianMonitor::postProcAtPoints(std::array<double, 3> point,
                                                  std::string str) {
  MoFEMFunctionBegin;
 
  dataFieldEval->setEvalPoints(point.data(), point.size() / 3);
  auto point_found_ptr = boost::make_shared<int>(0);
 
  struct OpPrint : public VolOp {
 
    EshelbianCore &eP;
    std::array<double, 3> point;
    std::string str;
    boost::shared_ptr<int> pointFoundPtr;
    PetscInt step;
    double time;
 
    OpPrint(EshelbianCore &ep, std::array<double, 3> &point, std::string &str,
            boost::shared_ptr<int> point_found_ptr, PetscInt step, double time)
        : VolOp(ep.spatialL2Disp, VolOp::OPROW), eP(ep), point(point),
          str(str), pointFoundPtr(point_found_ptr), step(step), time(time) {}
 
    MoFEMErrorCode doWork(int side, EntityType type,
                          EntitiesFieldData::EntData &data) {
      MoFEMFunctionBegin;
      if (type == MBTET) {
        const int nb_gauss_pts = getGaussPts().size2();
        if (nb_gauss_pts) {
          *pointFoundPtr = 1;
 
          auto t_h = eP.dataAtPts->getFTensorSmallH(nb_gauss_pts);
          auto t_approx_P = eP.dataAtPts->getFTensorApproxP(nb_gauss_pts);
          auto t_disp =
              getFTensor1FromMat<SPACE_DIM>(*eP.dataAtPts->getSmallWL2AtPts());
 
          FTensor::Index<'i', 3> i;
          FTensor::Index<'j', 3> j;
          FTensor::Index<'k', 3> k;
          const double jac = determinantTensor3by3(t_h);
          FTensor::Tensor2<double, 3, 3> t_cauchy;
          t_cauchy(i, j) = (1. / jac) * (t_approx_P(i, k) * t_h(j, k));
 
          auto add = [&]() {
            std::ostringstream s;
            s << str << " elem " << getFEEntityHandle() << " ";
            return s.str();
          };
 
          auto print_tensor = [](auto &t) {
            std::ostringstream s;
            s << t;
            return s.str();
          };
 
          std::ostringstream print;
          MOFEM_LOG("EPSYNC", Sev::inform)
              << add() << "comm rank " << eP.mField.get_comm_rank();
          MOFEM_LOG("EPSYNC", Sev::inform)
              << add() << "point " << getVectorAdaptor(point.data(), 3);
          MOFEM_LOG("EPSYNC", Sev::inform)
              << add() << "coords at gauss pts " << getCoordsAtGaussPts();
          MOFEM_LOG("EPSYNC", Sev::inform)
              << add() << "w " << *(eP.dataAtPts->getSmallWL2AtPts());
          MOFEM_LOG("EPSYNC", Sev::inform)
              << add() << "Piola " << *(eP.dataAtPts->getApproxPAtPts());
          MOFEM_LOG("EPSYNC", Sev::inform)
              << add() << "Cauchy " << print_tensor(t_cauchy);
          MOFEM_LOG_C(
              "EPSYNC", Sev::inform,
              "FieldEvaluator step %d time %6.4e label \"%s\" point [%6.4e, "
              "%6.4e, %6.4e]",
              step, time, str.c_str(), point[0], point[1], point[2]);
          MOFEM_LOG_C("EPSYNC", Sev::inform,
                      "FieldEvaluator displacement [Ux, Uy, Uz] = [%6.4e, "
                      "%6.4e, %6.4e]",
                      t_disp(0), t_disp(1), t_disp(2));
          MOFEM_LOG_C(
              "EPSYNC", Sev::inform,
              "FieldEvaluator Cauchy stress [Sxx, Syy, Szz, Sxy, Syz, Sxz] "
              "= [%6.4e, %6.4e, %6.4e, %6.4e, %6.4e, %6.4e]",
              t_cauchy(0, 0), t_cauchy(1, 1), t_cauchy(2, 2),
              t_cauchy(0, 1), t_cauchy(1, 2), t_cauchy(0, 2));
        }
      }
      MoFEMFunctionReturn(0);
    }
  };
 
  if (auto fe_ptr = dataFieldEval->feMethodPtr) {
    fe_ptr->data_ctx |= PetscData::CtxSetTime;
    fe_ptr->ts_t = EshelbianCore::physicalTimeFlg
                       ? EshelbianCore::currentPhysicalTime
                       : ts_t;
    fe_ptr->ts_dt =
        EshelbianCore::physicalTimeFlg ? EshelbianCore::physicalDt : ts_dt;
 
    const double time = EshelbianCore::physicalTimeFlg
                            ? EshelbianCore::currentPhysicalTime
                            : ts_t;
    fe_ptr->getOpPtrVector().push_back(
        new OpPrint(eP, point, str, point_found_ptr, ts_step, time));
    CHKERR eP.mField.getInterface<FieldEvaluatorInterface>()
        ->evalFEAtThePoint<SPACE_DIM>(
            point.data(), 1e-12, problemPtr->getName(), "EP", dataFieldEval,
            eP.mField.get_comm_rank(), eP.mField.get_comm_rank(), nullptr,
            MF_EXIST, QUIET);
    fe_ptr->getOpPtrVector().pop_back();
  }
 
  int global_point_found = 0;
  MPI_Allreduce(point_found_ptr.get(), &global_point_found, 1, MPI_INT, MPI_SUM,
                eP.mField.get_comm());
  if (!global_point_found && !eP.mField.get_comm_rank())
    MOFEM_LOG_C("EP", Sev::warning,
                "FieldEvaluator did not find point [%6.4e, %6.4e, %6.4e] in "
                "the EP domain",
                point[0], point[1], point[2]);
 
  MoFEMFunctionReturn(0);
}