66                                                            {
   68 
   72 
   74 
   76        ->evalFEAtThePoint<DIM>(
   81 
   82    auto process_scalar_field =
   83        [](const std::string label,
   84           const boost::shared_ptr<VectorDouble> scalarFieldPtr) {
   85          if (scalarFieldPtr->size()) {
   86            auto t_scalar_holder = getFTensor0FromVec(*scalarFieldPtr);
   87 
   89                << "For " << label << " field, " << t_scalar_holder;
   90          }
   91        };
   92 
   93    auto process_vector_field =
   94        [](const std::string label,
   95           const boost::shared_ptr<MatrixDouble> vecFieldPtr) {
   96          if (vecFieldPtr->size1()) {
   97            auto t_vec_holder = getFTensor1FromMat<DIM>(*vecFieldPtr);
   98 
   99            std::string vec_holder_string = "";
  100            for (
int i = 0; 
i < DIM; 
i++) {
 
  101              vec_holder_string +=
  102                  " " + boost::lexical_cast<std::string>(t_vec_holder(
i));
 
  103            }
  104 
  106                << "For " << label << " field," << vec_holder_string;
  107          }
  108        };
  109 
  110    auto process_sym_tensor_field =
  111        [](const std::string label,
  112           const boost::shared_ptr<MatrixDouble> symTensorFieldPtr) {
  113          if (symTensorFieldPtr->size1()) {
  114            auto t_sym_tensor_holder =
  115                getFTensor2SymmetricFromMat<DIM>(*symTensorFieldPtr);
  116 
  117            std::string sym_tensor_holder_string = "";
  118            for (
int i = 0; 
i < DIM; 
i++) {
 
  119              for (
int j = 
i; 
j < DIM; 
j++) {
 
  120                sym_tensor_holder_string +=
  121                    ", entry " + boost::lexical_cast<std::string>(
i) +
 
  122                    boost::lexical_cast<std::string>(
j) + 
" = ";
 
  123                sym_tensor_holder_string +=
  124                    boost::lexical_cast<std::string>(t_sym_tensor_holder(
i, 
j));
 
  125              }
  126            }
  127 
  129                << "For " << label << " field" << sym_tensor_holder_string;
  130          }
  131        };
  132 
  133    auto process_tensor_field =
  134        [](const std::string label,
  135           const boost::shared_ptr<MatrixDouble> tensorFieldPtr) {
  136          if (tensorFieldPtr->size1()) {
  137            auto t_tensor_holder =
  138                getFTensor2FromMat<DIM, DIM>(*tensorFieldPtr);
  139 
  140            std::string tensor_holder_string = "";
  141            for (
int i = 0; 
i < DIM; 
i++) {
 
  142              for (
int j = 0; 
j < DIM; 
j++) {
 
  143                tensor_holder_string +=
  144                    ", entry " + boost::lexical_cast<std::string>(
i) +
 
  145                    boost::lexical_cast<std::string>(
j) + 
" = ";
 
  146                tensor_holder_string +=
  147                    boost::lexical_cast<std::string>(t_tensor_holder(
i, 
j));
 
  148              }
  149            }
  150 
  152                << "For " << label << " field" << tensor_holder_string;
  153          }
  154        };
  155 
  156    auto process_fields = [](auto &fieldPtr, auto process_field) {
  157      for (const auto &pair : fieldPtr) {
  158        const std::string &label = pair.first;
  159        const boost::shared_ptr<MatrixDouble> &ptr = pair.second;
  160 
  161        if (ptr) {
  162          process_field(label, ptr);
  163        }
  164      }
  165    };
  166 
  169        const std::string &label = pair.first;
  170        const boost::shared_ptr<VectorDouble> &ptr = pair.second;
  171 
  172        if (ptr) {
  173          process_scalar_field(label, ptr);
  174        }
  175      }
  176    }
  177 
  180        const std::string &label = pair.first;
  181        const boost::shared_ptr<MatrixDouble> &ptr = pair.second;
  182 
  183        if (ptr) {
  184          process_vector_field(label, ptr);
  185        }
  186      }
  187    }
  188 
  191        const std::string &label = pair.first;
  192        const boost::shared_ptr<MatrixDouble> &ptr = pair.second;
  193 
  194        if (ptr) {
  195          process_sym_tensor_field(label, ptr);
  196        }
  197      }
  198    }
  199 
  202        const std::string &label = pair.first;
  203        const boost::shared_ptr<MatrixDouble> &ptr = pair.second;
  204 
  205        if (ptr) {
  206          process_tensor_field(label, ptr);
  207        }
  208      }
  209    }
  210  }
  211 
  213 
  214  auto make_vtk = [&]() {
  219          "out_plastic_" + boost::lexical_cast<std::string>(ts_step) + ".h5m");
  220    }
  223                                      getCacheWeakPtr());
  225          "out_skin_plastic_" + boost::lexical_cast<std::string>(ts_step) +
  226          ".h5m");
  227    }
  229  };
  230 
  231  auto calculate_reaction = [&]() {
  237 
  238#ifndef NDEBUG
  239    auto post_proc_residual = [&](auto dm, auto f_res, auto out_name) {
  241      auto post_proc_fe =
  242          boost::make_shared<PostProcBrokenMeshInMoab<DomainEle>>(*m_field_ptr);
  243      using OpPPMap = OpPostProcMapInMoab<DIM, DIM>;
 
  244      auto u_vec = boost::make_shared<MatrixDouble>();
  245      post_proc_fe->getOpPtrVector().push_back(
  246          new OpCalculateVectorFieldValues<DIM>("U", u_vec, f_res));
  247      post_proc_fe->getOpPtrVector().push_back(
  248 
  250 
  251              post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
  252 
  253              {},
  254 
  255              {{"RES", u_vec}},
  256 
  257              {}, {})
  258 
  259      );
  260 
  262      post_proc_fe->writeFile("res.h5m");
  264    };
  265 
  266    CHKERR post_proc_residual(
dM, r, 
"reaction");
 
  267#endif 
  268 
  270  };
  271 
  272  auto print_max_min = [&](auto &tuple, const std::string msg) {
  274    CHKERR VecScatterBegin(std::get<1>(tuple), ts_u, std::get<0>(tuple),
 
  275                           INSERT_VALUES, SCATTER_FORWARD);
  276    CHKERR VecScatterEnd(std::get<1>(tuple), ts_u, std::get<0>(tuple),
 
  277                         INSERT_VALUES, SCATTER_FORWARD);
  278    double max, min;
  279    CHKERR VecMax(std::get<0>(tuple), PETSC_NULLPTR, &max);
 
  280    CHKERR VecMin(std::get<0>(tuple), PETSC_NULLPTR, &min);
 
  281    MOFEM_LOG_C(
"PLASTICITY", Sev::inform, 
"%s time %3.4e min %3.4e max %3.4e",
 
  282                msg.c_str(), ts_t, min, max);
  284  };
  285 
  286  int se = 1;
  288  if (!(ts_step % se)) {
  290  }
  292    CHKERR calculate_reaction();
 
  295  if (DIM == 3)
  297 
  299}
#define MOFEM_LOG_SEVERITY_SYNC(comm, severity)
Synchronise "SYNC" on curtain severity level.
#define MOFEM_LOG_C(channel, severity, format,...)
void simple(double P1[], double P2[], double P3[], double c[], const int N)
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
PetscErrorCode DMoFEMLoopFiniteElements(DM dm, const char fe_name[], MoFEM::FEMethod *method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
Executes FEMethod for finite elements in DM.
auto createDMVector(DM dm)
Get smart vector from DM.
PetscErrorCode DMoFEMGetInterfacePtr(DM dm, MoFEM::Interface **m_field_ptr)
Get pointer to MoFEM::Interface.
#define MOFEM_LOG(channel, severity)
Log.
FTensor::Index< 'i', SPACE_DIM > i
FTensor::Index< 'j', 3 > j
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
OpPostProcMapInMoab< SPACE_DIM, SPACE_DIM > OpPPMap
PetscBool do_eval_field
Evaluate field.
virtual MPI_Comm & get_comm() const =0
virtual int get_comm_rank() const =0
Deprecated interface functions.
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.