186 enum bases { AINSWORTH, DEMKOWICZ, LASBASETOPT };
187 const char *list_bases[LASBASETOPT] = {
"ainsworth",
"demkowicz"};
188 PetscInt choice_base_value = AINSWORTH;
189 CHKERR PetscOptionsGetEList(PETSC_NULLPTR, NULL,
"-base", list_bases,
190 LASBASETOPT, &choice_base_value, PETSC_NULLPTR);
192 switch (choice_base_value) {
196 <<
"Set AINSWORTH_LEGENDRE_BASE for displacements";
201 <<
"Set DEMKOWICZ_JACOBI_BASE for displacements";
213 CHKERR PetscOptionsGetInt(PETSC_NULLPTR,
"",
"-order", &
order, PETSC_NULLPTR);
218 auto project_ho_geometry = [&]() {
219 Projection10NodeCoordsOnField ent_method(
mField,
"GEOMETRY");
222 CHKERR project_ho_geometry();
224 MOFEM_LOG(
"WORLD", Sev::inform) <<
"Use ageing UMAT material model";
226 auto tag_meshest = [&]() {
229 auto set_block = [&](
auto name,
int dim) {
230 std::map<int, Range> map;
231 auto set_tag_impl = [&](
auto name) {
234 auto bcs = mesh_mng->getCubitMeshsetPtr(
236 std::regex((boost::format(
"%s(.*)") %
name).str())
239 std::map<int, int> ids_map;
241 for (
auto bc : bcs) {
242 int id = bc->getMeshsetId();
243 ids_map[id] = bit_id;
246 for (
auto bc : bcs) {
250 map[ids_map[bc->getMeshsetId()]] = r;
252 <<
"Block " <<
name <<
" id " << bc->getMeshsetId() <<
" : "
253 << ids_map[bc->getMeshsetId()] <<
" has " << r.size()
261 return std::make_pair(
name, map);
264 auto set_skin = [&](
auto &&map) {
265 for (
auto &
m : map.second) {
269 <<
"Skin for block " << map.first <<
" id " <<
m.first <<
" has "
270 <<
m.second.size() <<
" entities";
275 auto set_tag = [&](
auto &&map) {
277 auto name = map.first;
278 int def_val[] = {-1};
280 name, 1, MB_TYPE_INTEGER, th,
281 MB_TAG_SPARSE | MB_TAG_CREAT, def_val),
283 for (
auto &
m : map.second) {
285 for (
auto ent :
m.second) {
290 if (current_id != -1) {
414 char output_sdv[PETSC_MAX_PATH_LEN];
415 PetscBool output_sdv_flg = PETSC_FALSE;
416 CHKERR PetscOptionsGetString(PETSC_NULLPTR,
"",
"-output_sdv", output_sdv,
417 sizeof(output_sdv), &output_sdv_flg);
419 if (output_sdv_flg == PETSC_TRUE) {
420 std::set<PetscInt> selected_sdv_indices;
421 auto parse_sdv_index = [](
const std::string &str, PetscInt &
index) {
422 std::istringstream stream(str);
423 std::string remainder;
424 return (stream >>
index) && !(stream >> remainder);
426 std::istringstream output_sdv_stream(output_sdv);
427 std::string output_sdv_item;
428 while (std::getline(output_sdv_stream, output_sdv_item,
',')) {
429 const auto range_separator = output_sdv_item.find(
'-');
430 PetscInt first_index;
432 if (range_separator == std::string::npos) {
433 if (!parse_sdv_index(output_sdv_item, first_index) || first_index < 0)
435 "Invalid -output_sdv index %s", output_sdv_item.c_str());
436 selected_sdv_indices.insert(first_index);
438 if (!parse_sdv_index(output_sdv_item.substr(0, range_separator),
440 !parse_sdv_index(output_sdv_item.substr(range_separator + 1),
442 first_index < 0 || last_index < 0 || first_index > last_index)
444 "Invalid -output_sdv range %s", output_sdv_item.c_str());
446 selected_sdv_indices.insert(
index);
447 if (
index == last_index)
453 output_statev_tags.reserve(selected_sdv_indices.size());
454 for (
const auto &state_tag : statev_tags) {
456 if (selected_sdv_indices.erase(statev_index) != 0)
457 output_statev_tags.push_back(state_tag);
460 if (!selected_sdv_indices.empty())
462 "Requested -output_sdv index %" PetscInt_FMT
463 " does not correspond to an available UMAT state variable",
464 *selected_sdv_indices.begin());
466 statev_tags.swap(output_statev_tags);
467 }
else if (statev_tags.size() > 30) {
469 output_statev_tags.reserve(33);
470 for (
const auto &state_tag : statev_tags) {
472 if (output_statev_tags.size() < 30 || statev_index == 35 ||
473 statev_index == 41 || statev_index == 50)
474 output_statev_tags.push_back(state_tag);
476 statev_tags.swap(output_statev_tags);
499 MatOps::createMatOpsPhysicalEquationsPtr<MatOps::AMENTUM_UMAT, modelType>(
505 auto add_domain_ops_lhs = [&](
auto &pip) {
507 CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {
H1},
511 template opLhsFactory<PETSC, GAUSS, DomainEleOp>(
517 auto add_domain_ops_rhs = [&](
auto &pip) {
519 CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {
H1},
523 template opRhsFactory<PETSC, GAUSS, DomainEleOp>(
529 auto add_domain_ops_update = [&](
auto &pip) {
531 CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {
H1},
541 CHKERR add_domain_ops_lhs(pipeline_mng->getOpDomainLhsPipeline());
542 CHKERR add_domain_ops_rhs(pipeline_mng->getOpDomainRhsPipeline());
548 CHKERR add_domain_ops_rhs(pipeline_mng->getOpEvaluationPipeline());
549 auto &domain_reaction_fe = pipeline_mng->getEvaluationFE();
550 domain_reaction_fe->postProcessHook =
551 EssentialPreProcReaction<DisplacementCubitBcData>(
mField,
554 PetscBool post_proc_vol;
555 PetscBool post_proc_skin;
558 post_proc_vol = PETSC_TRUE;
559 post_proc_skin = PETSC_FALSE;
561 post_proc_vol = PETSC_FALSE;
562 post_proc_skin = PETSC_TRUE;
565 CHKERR PetscOptionsGetBool(PETSC_NULLPTR,
"",
"-post_proc_vol",
566 &post_proc_vol, PETSC_NULLPTR);
567 CHKERR PetscOptionsGetBool(PETSC_NULLPTR,
"",
"-post_proc_skin",
568 &post_proc_skin, PETSC_NULLPTR);
571 auto select_post_proc_state_tags = [&]() {
580 statev_tags.reserve(state_tags.size());
582 constexpr auto statev_prefix =
"UMAT_STATEV_";
583 for (
const auto &state_tag : state_tags) {
584 const auto &
name = state_tag.name;
585 if (
name ==
"AMENTUM_FIELD_IRRA" ||
586 name ==
"AMENTUM_FIELD_PREDEF_TEMP" ||
587 name ==
"AMENTUM_FIELD_CORR" ||
name ==
"AMENTUM_TEMP" ||
588 name ==
"AMENTUM_DTEMP" ||
name ==
"FIRST_PIOLA_TAG" ||
589 name ==
"AMENTUM_DEBUG" ||
name ==
"UMAT_STRESS" ||
590 name ==
"UMAT_DFGRD0") {
592 }
else if (
name.rfind(statev_prefix, 0) == 0) {
593 statev_tags.push_back(state_tag);
597 std::sort(statev_tags.begin(), statev_tags.end(),
598 [](
const auto &lhs,
const auto &rhs) {
599 return get_statev_index(lhs.name) < get_statev_index(rhs.name);
601 if (!state_tags.empty()) {
603 std::ostringstream output_sdv_log;
604 bool first_output_sdv =
true;
605 for (
const auto &state_tag : statev_tags) {
606 if (!first_output_sdv)
607 output_sdv_log <<
',';
609 first_output_sdv =
false;
612 <<
"Output UMAT SDV indices: " << output_sdv_log.str();
618 CHKERR select_post_proc_state_tags();
620 auto create_post_proc_fe = [&]() {
621 using OpPPMap = OpPostProcMapInMoab<SPACE_DIM, SPACE_DIM>;
623 auto post_proc_ele_domain = [&](
auto &pip_domain) {
625 CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip_domain, {
H1},
638 auto post_proc_map = [&](
auto &pip,
auto u_ptr) {
644 post_proc_fields_map[
"GRAD"] = grad_ptr;
645 pip->getOpPtrVector().push_back(
646 new OpPPMap(pip->getPostProcMesh(), pip->getMapGaussPts(), {},
647 {{
"U", u_ptr}}, post_proc_fields_map, {}));
652 auto post_proc_state = [&](
auto &pip,
auto &post_proc_fe) {
656 int state_projection_order = 0;
657 CHKERR PetscOptionsGetInt(PETSC_NULLPTR,
"",
"-state_projection_order",
658 &state_projection_order, PETSC_NULLPTR);
659 auto op_loop_this =
new OpLoopThis<DomainEle>(
662 pip.push_back(op_loop_this);
663 CHKERR addTagDGProjectionOps<SPACE_DIM, SPACE_DIM>(
665 op_loop_this->getThisFEPtr()->getOpPtrVector(),
666 post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
672 auto push_post_proc_bdy = [&](
auto &pip_bdy) {
673 if (post_proc_skin == PETSC_FALSE)
674 return boost::shared_ptr<PostProcEleBdy>();
676 auto domain_fe_name =
simple->getDomainFEName();
677 auto u_ptr = boost::make_shared<MatrixDouble>();
678 pip_bdy->getOpPtrVector().push_back(
679 new OpCalculateVectorFieldValues<SPACE_DIM>(
"U", u_ptr));
682 CHKERR post_proc_ele_domain(op_loop_side->getOpPtrVector());
683 CHKERR post_proc_state(op_loop_side->getOpPtrVector(), pip_bdy);
684 pip_bdy->getOpPtrVector().push_back(op_loop_side);
685 CHKERR post_proc_map(pip_bdy, u_ptr);
689 auto push_post_proc_domain = [&](
auto &pip_domain) {
690 if (post_proc_vol == PETSC_FALSE)
691 return boost::shared_ptr<PostProcEleDomain>();
692 auto u_ptr = boost::make_shared<MatrixDouble>();
693 pip_domain->getOpPtrVector().push_back(
694 new OpCalculateVectorFieldValues<SPACE_DIM>(
"U", u_ptr));
695 CHKERR post_proc_ele_domain(pip_domain->getOpPtrVector());
697 CHKERR post_proc_state(pip_domain->getOpPtrVector(), pip_domain);
699 CHKERR post_proc_map(pip_domain, u_ptr);
704 auto post_proc_fe_domain = boost::make_shared<PostProcEleDomain>(
mField);
705 auto post_proc_fe_bdy = boost::make_shared<PostProcEleBdy>(
mField);
707 return std::make_pair(push_post_proc_domain(post_proc_fe_domain),
708 push_post_proc_bdy(post_proc_fe_bdy));
711 auto post_proc_pair = create_post_proc_fe();
712 postProcDomainFe = post_proc_pair.first;
713 postProcBdyFe = post_proc_pair.second;
724 auto dm =
simple->getDM();
725 auto ts = pipeline_mng->createTSIM();
727 auto add_extra_finite_elements_to_solver_pipelines = [&]() {
730 auto pre_proc_ptr = boost::make_shared<FEMethod>();
731 auto post_proc_rhs_ptr = boost::make_shared<FEMethod>();
732 auto post_proc_lhs_ptr = boost::make_shared<FEMethod>();
734 auto time_scale = boost::make_shared<ExampleTimeScale>();
736 auto get_bc_hook_rhs = [
this, pre_proc_ptr, time_scale]() {
738 CHKERR EssentialPreProc<DisplacementCubitBcData>(
mField, pre_proc_ptr,
739 {time_scale},
false)();
743 pre_proc_ptr->preProcessHook = get_bc_hook_rhs;
745 auto get_post_proc_hook_rhs = [
this, post_proc_rhs_ptr]() {
747 CHKERR EssentialPreProcReaction<DisplacementCubitBcData>(
748 mField, post_proc_rhs_ptr,
nullptr, Sev::verbose)();
749 CHKERR EssentialPostProcRhs<DisplacementCubitBcData>(
750 mField, post_proc_rhs_ptr, 1.)();
753 auto get_post_proc_hook_lhs = [
this, post_proc_lhs_ptr]() {
755 CHKERR EssentialPostProcLhs<DisplacementCubitBcData>(
756 mField, post_proc_lhs_ptr, 1.)();
759 post_proc_rhs_ptr->postProcessHook = get_post_proc_hook_rhs;
760 post_proc_lhs_ptr->postProcessHook = get_post_proc_hook_lhs;
763 auto ts_ctx_ptr = getDMTsCtx(
simple->getDM());
764 ts_ctx_ptr->getPreProcessIFunction().push_front(pre_proc_ptr);
765 ts_ctx_ptr->getPreProcessIJacobian().push_front(pre_proc_ptr);
766 ts_ctx_ptr->getPostProcessIFunction().push_back(post_proc_rhs_ptr);
767 ts_ctx_ptr->getPostProcessIJacobian().push_back(post_proc_lhs_ptr);
773 CHKERR add_extra_finite_elements_to_solver_pipelines();
775 auto create_vertex_post_proc = [&]() {
776 using VertexStateTags = std::vector<std::tuple<std::string, Tag, int>>;
777 auto moab_vert_post_proc_ptr = boost::make_shared<moab::Core>();
778 auto fe_post_proc_ptr = boost::make_shared<DomainEle>(
mField);
782 pipeline_mng->getDomainRhsFE());
783 if (!source_fe_ptr) {
785 "Missing domain integration rule for vertex output");
787 fe_post_proc_ptr->getRuleHook = source_fe_ptr->getRuleHook;
790 OpMoabVertPostProc(boost::shared_ptr<moab::Core> moab_ptr,
791 moab::Interface &source_mesh,
int partition,
792 VertexStateTags state_tags)
794 sourceMesh(source_mesh), partitionId(partition),
795 stateTags(std::move(state_tags)) {}
797 MoFEMErrorCode doWork(
int, EntityType,
EntData &)
override {
800 const int nb_gauss_pts = getGaussPts().size2();
804 const auto &coords = getCoordsAtGaussPts();
806 if (coords.size1() != nb_gauss_pts || coords.size2() != 3) {
808 "Invalid integration-point coordinates for vertex output");
812 CHKERR moabPtr->create_vertices(coords.data().data(), nb_gauss_pts,
815 Tag partition_tag = 0;
816 const int default_partition = -1;
817 CHKERR moabPtr->tag_get_handle(
818 "PARALLEL_PARTITION", 1, MB_TYPE_INTEGER, partition_tag,
819 MB_TAG_CREAT | MB_TAG_SPARSE, &default_partition);
820 CHKERR moabPtr->tag_clear_data(partition_tag,
vertices, &partitionId);
822 const auto entity = getFEEntityHandle();
823 for (
const auto &[
name,
tag, num_components] : stateTags) {
825 const std::vector<double> default_values(num_components, 0.0);
826 CHKERR moabPtr->tag_get_handle(
827 name.c_str(), num_components, MB_TYPE_DOUBLE, output_tag,
828 MB_TAG_CREAT | MB_TAG_SPARSE, default_values.data());
830 const void *state_data =
nullptr;
832 const auto rval = sourceMesh.tag_get_by_ptr(
833 tag, &entity, 1, &state_data, &state_size);
834 if (rval == MB_TAG_NOT_FOUND)
837 if (!state_data || !state_size)
839 if (state_size < 0 || state_size % num_components != 0) {
841 "Inconsistent state tag size for %s",
name.c_str());
844 const int required_size = nb_gauss_pts * num_components;
845 if (state_size < required_size) {
847 std::vector<double>
values(required_size, 0.0);
848 std::copy_n(
static_cast<const double *
>(state_data), state_size,
861 boost::shared_ptr<moab::Core> moabPtr;
862 moab::Interface &sourceMesh;
864 VertexStateTags stateTags;
867 VertexStateTags state_tags;
869 state_tags.emplace_back(
name,
tag, num_components);
870 auto &pip = fe_post_proc_ptr->getOpPtrVector();
872 (AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {
H1},
"GEOMETRY")),
873 "Cannot set geometry for integration-point output");
874 pip.push_back(
new OpMoabVertPostProc(moab_vert_post_proc_ptr,
876 std::move(state_tags)));
878 return std::make_pair(moab_vert_post_proc_ptr, fe_post_proc_ptr);
881 auto create_monitor_fe = [
this, dm](
auto &&post_proc_fe,
882 auto &&post_proc_vert) {
883 return boost::make_shared<Monitor>(dm.get(), post_proc_fe, post_proc_vert,
888 boost::shared_ptr<FEMethod> null_fe;
895 auto monitor_ptr = create_monitor_fe(
897 CHKERR DMMoFEMTSSetMonitor(dm, ts,
simple->getDomainFEName(), null_fe,
898 null_fe, monitor_ptr);
904 CHKERR TSSetMaxTime(ts, ftime);
905 CHKERR TSSetExactFinalTime(ts, TS_EXACTFINALTIME_MATCHSTEP);
907 auto B = createDMMatrix(dm);
908 CHKERR TSSetI2Jacobian(ts,
B,
B, PETSC_NULLPTR, PETSC_NULLPTR);
909 auto D = createDMVector(
simple->getDM());
911 CHKERR TSSetFromOptions(ts);
919 CHKERR TSGetTime(ts, &ftime);
921 PetscInt steps, snesfails, rejects, nonlinits, linits;
922 CHKERR TSGetStepNumber(ts, &steps);
923 CHKERR TSGetSNESFailures(ts, &snesfails);
924 CHKERR TSGetStepRejections(ts, &rejects);
925 CHKERR TSGetSNESIterations(ts, &nonlinits);
926 CHKERR TSGetKSPIterations(ts, &linits);
928 "steps %d (%d rejected, %d SNES fails), ftime %g, nonlinits "
930 steps, rejects, snesfails, ftime, nonlinits, linits);
941 auto dm =
simple->getDM();
943 auto T = createDMVector(
simple->getDM());
944 CHKERR DMoFEMMeshToLocalVector(
simple->getDM(), T, INSERT_VALUES,
947 CHKERR VecNorm(T, NORM_2, &nrm2);
948 MOFEM_LOG(
"EXAMPLE", Sev::inform) <<
"Solution norm " << nrm2;
950 auto post_proc_norm_fe = boost::make_shared<DomainEle>(
mField);
955 auto post_proc_norm_rule_hook = [](int, int,
int p) ->
int {
return 2 * p; };
956 post_proc_norm_fe->getRuleHook = post_proc_norm_rule_hook;
958 CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
959 post_proc_norm_fe->getOpPtrVector(), {H1},
"GEOMETRY");
961 enum NORMS { U_NORM_L2 = 0, PIOLA_NORM, LAST_NORM };
965 CHKERR VecZeroEntries(norms_vec);
967 auto u_ptr = boost::make_shared<MatrixDouble>();
968 post_proc_norm_fe->getOpPtrVector().push_back(
969 new OpCalculateVectorFieldValues<SPACE_DIM>(
"U", u_ptr));
971 post_proc_norm_fe->getOpPtrVector().push_back(
972 new OpCalcNormL2Tensor1<SPACE_DIM>(u_ptr, norms_vec, U_NORM_L2));
979 OpGetFirstPiolaTag(moab::Interface &
mesh,
981 boost::shared_ptr<MatrixDouble> first_piola_ptr)
983 firstPiolaTag(first_piola_tag), firstPiolaPtr(first_piola_ptr) {}
985 MoFEMErrorCode doWork(
int, EntityType,
986 EntitiesFieldData::EntData &)
override {
988 const auto nb_gauss_pts = this->getGaussPts().size2();
990 std::fill(firstPiolaPtr->data().begin(), firstPiolaPtr->data().end(),
993 const auto ent = this->getFEEntityHandle();
994 double *tag_data =
nullptr;
996 CHKERR meshRef.tag_get_by_ptr(firstPiolaTag.tag, &ent, 1,
997 (
const void **)&tag_data, &tag_size);
1000 tag_size <
static_cast<int>(nb_gauss_pts *
1001 firstPiolaTag.numComponents)) {
1003 "Missing FIRST_PIOLA_TAG data for Piola norm");
1006 for (
size_t gg = 0; gg != nb_gauss_pts; ++gg) {
1007 for (
int dd = 0; dd != firstPiolaTag.numComponents; ++dd)
1008 (*firstPiolaPtr)(gg, dd) =
1009 tag_data[gg * firstPiolaTag.numComponents + dd];
1015 moab::Interface &meshRef;
1017 boost::shared_ptr<MatrixDouble> firstPiolaPtr;
1021 auto first_piola_tag_it = std::find_if(
1022 state_tags.begin(), state_tags.end(), [](
const auto &state_tag) {
1023 return state_tag.name ==
"FIRST_PIOLA_TAG";
1025 if (first_piola_tag_it == state_tags.end()) {
1027 "FIRST_PIOLA_TAG is not available for Piola norm");
1031 "FIRST_PIOLA_TAG has inconsistent size for Piola norm");
1034 post_proc_norm_fe->getRuleHook = [](
int p, int, int) ->
int {
1037 auto first_piola_ptr = boost::make_shared<MatrixDouble>();
1038 post_proc_norm_fe->getOpPtrVector().push_back(
new OpGetFirstPiolaTag(
1040 post_proc_norm_fe->getOpPtrVector().push_back(
1041 new OpCalcNormL2Tensor2<SPACE_DIM, SPACE_DIM>(first_piola_ptr,
1042 norms_vec, PIOLA_NORM));
1045 CHKERR DMoFEMLoopFiniteElements(dm,
simple->getDomainFEName(),
1048 CHKERR VecAssemblyBegin(norms_vec);
1049 CHKERR VecAssemblyEnd(norms_vec);
1053 const double *norms;
1054 CHKERR VecGetArrayRead(norms_vec, &norms);
1056 <<
"norm_u: " << std::scientific << std::sqrt(norms[U_NORM_L2]);
1058 <<
"norm_piola: " << std::scientific << std::sqrt(norms[PIOLA_NORM]);
1059 CHKERR VecRestoreArrayRead(norms_vec, &norms);