525 {
527
530
533 };
534
539
540#ifdef WITH_ADOL_C
542
543 #ifdef WITH_ADOL_C_UMAT
544 {
545 constexpr int umat_model_type =
547 auto umat_physical_equations_ptr =
548 MatOps::createMatOpsPhysicalEquationsPtr<MatOps::UMAT, umat_model_type>(
550
551 CHKERR umat_physical_equations_ptr->getOptions(&
mField);
552 CHKERR umat_physical_equations_ptr->recordTape();
553
555 }
556 #else
561 mat_ops_data_ptr,
563 }
564
565 #ifdef WITH_ADOL_C_GENERIC_ELASTIC
566 if (true) {
567 auto generic_physical_equations_ptr =
570 mat_ops_data_ptr,
572
574
575 generic_physical_equations_ptr->hookEvaluateVariable =
577 generic_physical_equations_ptr->hookEvaluateDerivatives =
579 generic_physical_equations_ptr->hookUpdateState =
581
582 CHKERR generic_physical_equations_ptr->getOptions(&
mField);
583 CHKERR generic_physical_equations_ptr->recordTape();
584
585
587 boost::static_pointer_cast<MatOps::MatPiolaResponse>(
589 material_map[generic_physical_equations_ptr->tAg] =
590 boost::static_pointer_cast<MatOps::MatPiolaResponse>(
591 generic_physical_equations_ptr);
593 }
594 #endif
595
596 #ifdef WITH_ADOL_C_SIMPLE_DAMAGE
597 {
598 auto generic_physical_equations_ptr =
602 "GenericElasticSimpleDamage"));
603
605 mField, boost::dynamic_pointer_cast<MatOps::GenericElastic>(
606 generic_physical_equations_ptr));
607
608 CHKERR generic_physical_equations_ptr->getOptions(&
mField);
609 CHKERR generic_physical_equations_ptr->recordTape();
610
611
613 boost::static_pointer_cast<MatOps::MatPiolaResponse>(
615 material_map[generic_physical_equations_ptr->tAg] =
616 boost::static_pointer_cast<MatOps::MatPiolaResponse>(
617 generic_physical_equations_ptr);
619 }
620 #endif
621
625 }
626
628 ->getCubitMeshsetPtr(std::regex("MAT_HUHU(.*)"))
629 .empty()) {
632 MatOps::createMatOpsPhysicalEquationsPtr<MatOps::HUHU, modelType>(
636 }
637 #endif
638
639 auto add_domain_ops_lhs = [&](auto &pip) {
641 CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {
H1},
642 "GEOMETRY");
645 template opLhsFactory<PETSC, GAUSS, DomainEleOp>(
647 }
650 template opLhsFactory<PETSC, GAUSS, DomainEleOp>(
652 }
654 };
655
656 auto add_domain_ops_rhs = [&](auto &pip) {
658 CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {
H1},
659 "GEOMETRY");
662 template opRhsFactory<PETSC, GAUSS, DomainEleOp>(
664 }
667 template opRhsFactory<PETSC, GAUSS, DomainEleOp>(
669 }
671 };
672
673 auto add_domain_ops_update = [&](auto &pip) {
675 CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {
H1},
676 "GEOMETRY");
680 }
682 };
683
684 CHKERR add_domain_ops_lhs(pipeline_mng->getOpDomainLhsPipeline());
685 CHKERR add_domain_ops_rhs(pipeline_mng->getOpDomainRhsPipeline());
686
690
691 CHKERR add_domain_ops_rhs(pipeline_mng->getOpEvaluationPipeline());
692 auto &domain_reaction_fe = pipeline_mng->getEvaluationFE();
693 domain_reaction_fe->postProcessHook =
694 EssentialPreProcReaction<DisplacementCubitBcData>(
mField,
695 domain_reaction_fe);
696
697 PetscBool post_proc_vol;
698 PetscBool post_proc_skin;
699
701 post_proc_vol = PETSC_TRUE;
702 post_proc_skin = PETSC_FALSE;
703 } else {
704 post_proc_vol = PETSC_FALSE;
705 post_proc_skin = PETSC_TRUE;
706 }
707
709 &post_proc_vol, PETSC_NULLPTR);
711 &post_proc_skin, PETSC_NULLPTR);
712
713
714 auto create_post_proc_fe = [&]() {
715 using OpPPMap = OpPostProcMapInMoab<SPACE_DIM, SPACE_DIM>;
716
717 auto post_proc_ele_domain = [&](auto &pip_domain) {
719 CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip_domain, {
H1},
720 "GEOMETRY");
724 }
726 };
727
728 auto post_proc_map = [&](auto &pip, auto u_ptr) {
731 auto grad_ptr =
733 auto first_piola_ptr =
735 pip->getOpPtrVector().push_back(
new OpPPMap(pip->getPostProcMesh(),
736 pip->getMapGaussPts(), {},
737 {{"U", u_ptr}}, {}, {}));
738 pip->getOpPtrVector().push_back(
739 new OpPostProcMapInMoab<MAT_DIM, MAT_DIM>(
740 pip->getPostProcMesh(), pip->getMapGaussPts(), {}, {},
741 {{"GRAD", grad_ptr}, {"FIRST_PIOLA", first_piola_ptr}}, {}));
742 }
744 };
745
746 auto push_post_proc_bdy = [&](auto &pip_bdy) {
747 if (post_proc_skin == PETSC_FALSE)
748 return boost::shared_ptr<PostProcEleBdy>();
750 auto domain_fe_name =
simple->getDomainFEName();
751 auto u_ptr = boost::make_shared<MatrixDouble>();
752 pip_bdy->getOpPtrVector().push_back(
753 new OpCalculateVectorFieldValues<SPACE_DIM>("U", u_ptr));
754 auto op_loop_side =
756 CHKERR post_proc_ele_domain(op_loop_side->getOpPtrVector());
757 pip_bdy->getOpPtrVector().push_back(op_loop_side);
758 CHKERR post_proc_map(pip_bdy, u_ptr);
759 return pip_bdy;
760 };
761
762 auto push_post_proc_domain = [&](auto &pip_domain) {
763 if (post_proc_vol == PETSC_FALSE)
764 return boost::shared_ptr<PostProcEleDomain>();
765 auto u_ptr = boost::make_shared<MatrixDouble>();
766 pip_domain->getOpPtrVector().push_back(
767 new OpCalculateVectorFieldValues<SPACE_DIM>("U", u_ptr));
768 CHKERR post_proc_ele_domain(pip_domain->getOpPtrVector());
769
772 if (!state_tags.empty()) {
775 selected_state_tags.reserve(state_tags.size());
776 statev_tags.reserve(state_tags.size());
777
778 constexpr auto statev_prefix = "UMAT_STATEV_";
779 constexpr auto statev_prefix_len = sizeof("UMAT_STATEV_") - 1;
780 auto get_statev_index = [&](
const std::string &
name) {
781 return std::stoi(
name.substr(statev_prefix_len));
782 };
783
784 for (const auto &state_tag : state_tags) {
785 const auto &
name = state_tag.name;
786
787 if (
name ==
"UMAT_DFGRD0" ||
name ==
"UMAT_STRESS") {
788 selected_state_tags.push_back(state_tag);
789 continue;
790 }
791
792 if (
name.rfind(statev_prefix, 0) == 0) {
793 statev_tags.push_back(state_tag);
794 }
795 }
796
797 std::sort(statev_tags.begin(), statev_tags.end(),
798 [&](const auto &lhs, const auto &rhs) {
799 return get_statev_index(lhs.name) <
800 get_statev_index(rhs.name);
801 });
802 if (statev_tags.size() > 10)
803 statev_tags.resize(10);
804 selected_state_tags.insert(selected_state_tags.end(),
805 statev_tags.begin(), statev_tags.end());
806
807 if (selected_state_tags.empty())
808 return pip_domain;
809
811 int state_order = 2;
813 PETSC_NULLPTR);
814 auto op_loop_this = new OpLoopThis<DomainEle>(
817 pip_domain->getOpPtrVector().push_back(op_loop_this);
818 CHKERR addTagDGProjectionOps<SPACE_DIM, SPACE_DIM>(
820 op_loop_this->getThisFEPtr()->getOpPtrVector(),
821 pip_domain->getPostProcMesh(), pip_domain->getMapGaussPts(),
823 }
824 }
825
826 CHKERR post_proc_map(pip_domain, u_ptr);
827
828 return pip_domain;
829 };
830
831 auto post_proc_fe_domain = boost::make_shared<PostProcEleDomain>(
mField);
832 auto post_proc_fe_bdy = boost::make_shared<PostProcEleBdy>(
mField);
833
834 return std::make_pair(push_post_proc_domain(post_proc_fe_domain),
835 push_post_proc_bdy(post_proc_fe_bdy));
836 };
837
838 auto post_proc_pair = create_post_proc_fe();
841
842#else
844 "ADOL-C support is not enabled. Please reconfigure with "
845 "-DWITH_ADOL_C=ON and recompile to use AdolC material model.");
846
847#endif
849}
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 ...
@ MOFEM_DATA_INCONSISTENCY
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
MoFEMErrorCode configureSimpleDamage(MoFEM::Interface &m_field, boost::shared_ptr< MatOps::GenericElastic > physical_ptr)
std::vector< StateTag > StateTags
std::map< int, boost::shared_ptr< MatPiolaResponse > > & getMetaPiolaResponseMap(boost::shared_ptr< MatPiolaResponse > meta_ptr)
boost::shared_ptr< PhysicalEquations > createMatOpsPhysicalEquationsPtr(boost::shared_ptr< MatOpsData > mat_ops_data_ptr, int tag)
boost::shared_ptr< MatOpsData > createMatOpsDataPtr()
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
PetscErrorCode PetscOptionsGetBool(PetscOptions *, const char pre[], const char name[], PetscBool *bval, PetscBool *set)
OpPostProcMapInMoab< SPACE_DIM, SPACE_DIM > OpPPMap
static constexpr int approx_order
static MoFEMErrorCode hookEvaluateVariable(boost::shared_ptr< MatOps::MatOpsData > mat_ops_data_ptr, int, EntityHandle, int)
static MoFEMErrorCode hookEvaluateDerivatives(boost::shared_ptr< MatOps::MatOpsData > mat_ops_data_ptr, int, EntityHandle, int)
static MoFEMErrorCode hookUpdateState(boost::shared_ptr< MatOps::MatOpsData >, int, EntityHandle, int)
virtual moab::Interface & get_moab()=0
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
FieldApproximationBase approximationBase
boost::shared_ptr< PostProcEleBdy > postProcBdyFe
boost::shared_ptr< MatOps::PhysicalEquations > physicalEquationsPtr
static constexpr int modelType
boost::shared_ptr< PostProcEleDomain > postProcDomainFe
boost::shared_ptr< MatOps::PhysicalEquations > physicalHuHuPtr
boost::shared_ptr< DomainEle > updateFe