v0.15.0
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
EshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS > Struct Template Reference

#include "users_modules/eshelbian_plasticity/src/EshelbianPlasticity.hpp"

Inheritance diagram for EshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS >:
[legend]
Collaboration diagram for EshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS >:
[legend]

Public Types

using OP
 

Public Member Functions

 OpNormalDispBcLhsImpl_dU (std::string row_field, boost::shared_ptr< NormalDisplacementBcVec > &bc_disp_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv, boost::shared_ptr< Range > ents_ptr=nullptr)
 

Protected Member Functions

MoFEMErrorCode iNtegrate (EntData &row_data, EntData &col_data)
 

Protected Attributes

boost::shared_ptr< NormalDisplacementBcVec > bcDispPtr
 
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
 

Detailed Description

template<AssemblyType A>
struct EshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS >

Definition at line 608 of file EshelbianPlasticity.hpp.

Member Typedef Documentation

◆ OP

template<AssemblyType A>
using EshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS >::OP
Initial value:
typename FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBase

Definition at line 611 of file EshelbianPlasticity.hpp.

Constructor & Destructor Documentation

◆ OpNormalDispBcLhsImpl_dU()

template<AssemblyType A>
EshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS >::OpNormalDispBcLhsImpl_dU ( std::string row_field,
boost::shared_ptr< NormalDisplacementBcVec > & bc_disp_ptr,
std::map< std::string, boost::shared_ptr< ScalingMethod > > smv,
boost::shared_ptr< Range > ents_ptr = nullptr )
inline

Definition at line 614 of file EshelbianPlasticity.hpp.

648 {
649
650struct CGGUserPolynomialBase : public TetPolynomialBase {
651
652 using CachePhi = boost::tuple<int, int, MatrixDouble>;
653
654 CGGUserPolynomialBase(boost::shared_ptr<CachePhi> cache_phi = nullptr);
655 ~CGGUserPolynomialBase() = default;
656
657 MoFEMErrorCode query_interface(boost::typeindex::type_index type_index,
658 BaseFunctionUnknownInterface **iface) const;
659 MoFEMErrorCode getValue(MatrixDouble &pts,
660 boost::shared_ptr<BaseFunctionCtx> ctx_ptr);
661
662private:
663 MatrixDouble shapeFun;
664 boost::shared_ptr<CachePhi> cachePhiPtr;
665
666 MoFEMErrorCode getValueHdivForCGGBubble(MatrixDouble &pts);
667};
668
669struct ContactTree;
670
671enum SymmetrySelector { SYMMETRIC, NOT_SYMMETRIC, ANIT_SYMMETRIC };
672enum RotSelector { SMALL_ROT, MODERATE_ROT, LARGE_ROT, NO_H1_CONFIGURATION };
673enum StretchSelector {
674 LINEAR,
675 LOG /*linar extenion*/,
676 LOG_QUADRATIC /*quadratic extension*/,
677 STRETCH_SELECTOR_LAST
678};
679enum EnergyReleaseSelector { GRIFFITH_FORCE, GRIFFITH_SKELETON };
680
681using MatrixPtr = boost::shared_ptr<MatrixDouble>;
682using VectorPtr = boost::shared_ptr<VectorDouble>;
683
684using EntData = EntitiesFieldData::EntData;
685using UserDataOperator = ForcesAndSourcesCore::UserDataOperator;
686using VolUserDataOperator = VolumeElementForcesAndSourcesCore::UserDataOperator;
687using FaceUserDataOperator = FaceElementForcesAndSourcesCore::UserDataOperator;
688using EleOnSide = PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::FaceSideEle;
689using SideEleOp = EleOnSide::UserDataOperator;
690
691struct PhysicalEquations;
692
693struct AnalyticalExprPython;
694
695struct DataAtIntegrationPts
696 : public boost::enable_shared_from_this<DataAtIntegrationPts> {
697
698 MatrixDouble approxPAtPts;
699 MatrixDouble approxSigmaAtPts;
700 MatrixDouble divPAtPts;
701 MatrixDouble divSigmaAtPts;
702 MatrixDouble wL2AtPts;
703 MatrixDouble wL2DotAtPts;
704 MatrixDouble wL2DotDotAtPts;
705 MatrixDouble logStretchTensorAtPts;
706 MatrixDouble stretchTensorAtPts;
707 VectorDouble jacobianAtPts;
708 MatrixDouble tractionAtPts;
709
710 MatrixDouble diffStretchTensorAtPts;
711 VectorDouble detStretchTensorAtPts;
712 MatrixDouble detStretchTensorAtPts_du;
713 MatrixDouble logStretchDotTensorAtPts;
714 MatrixDouble gradLogStretchDotTensorAtPts;
715 MatrixDouble rotAxisAtPts;
716 MatrixDouble rotAxisDotAtPts;
717 MatrixDouble rotAxisGradDotAtPts;
718 MatrixDouble rotAxis0AtPts;
719 MatrixDouble WAtPts;
720 MatrixDouble W0AtPts;
721 MatrixDouble GAtPts;
722 MatrixDouble G0AtPts;
723 MatrixDouble wH1AtPts;
724 MatrixDouble XH1AtPts;
725 MatrixDouble contactL2AtPts;
726 MatrixDouble wGradH1AtPts;
727 MatrixDouble logStretch2H1AtPts;
728 MatrixDouble logStretchTotalTensorAtPts;
729
730 MatrixDouble hAtPts;
731 MatrixDouble hdOmegaAtPts;
732 MatrixDouble hdLogStretchAtPts;
733 MatrixDouble leviKirchhoffAtPts;
734 MatrixDouble leviKirchhoffdOmegaAtPts;
735 MatrixDouble leviKirchhoffdLogStreatchAtPts;
736 MatrixDouble leviKirchhoffPAtPts;
737 MatrixDouble adjointPdstretchAtPts;
738 MatrixDouble adjointPdUAtPts;
739 MatrixDouble adjointPdUdOmegaAtPts;
740 MatrixDouble adjointPdUdPAtPts;
741 MatrixDouble rotMatAtPts;
742 MatrixDouble PAtPts;
743 MatrixDouble SigmaAtPts;
744 VectorDouble energyAtPts; //< this is density of energy at integration points
745 MatrixDouble flowL2AtPts;
746
747 MatrixDouble varRotAxis;
748 MatrixDouble varLogStreach;
749 MatrixDouble varPiola;
750 MatrixDouble varDivPiola;
751 MatrixDouble varWL2;
752
753 MatrixDouble P_du;
754
755 MatrixDouble eigenVals;
756 MatrixDouble eigenVecs;
757 VectorInt nbUniq;
758 MatrixDouble eigenValsC;
759 MatrixDouble eigenVecsC;
760 VectorInt nbUniqC;
761
762 MatrixDouble matD;
763 MatrixDouble matAxiatorD;
764 MatrixDouble matDeviatorD;
765 MatrixDouble matInvD;
766
767 MatrixDouble internalStressAtPts;
768
769 MatrixDouble facePiolaAtPts;
770 MatrixDouble gradHybridDispAtPts;
771 MatrixDouble faceMaterialForceAtPts;
772 VectorDouble normalPressureAtPts;
773
774 double mu;
775 double lambda;
776 double piolaScale = 1.;
777 double faceEnergy = 0.;
778
779 inline auto getPiolaScalePtr() {
780 return boost::shared_ptr<double>(shared_from_this(), &piolaScale);
781 }
782
783 inline MatrixPtr getApproxSigmaAtPts() {
784 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
785 &approxSigmaAtPts);
786 }
787 inline MatrixPtr getApproxPAtPts() {
788 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &approxPAtPts);
789 }
790
791 inline MatrixPtr getDivPAtPts() {
792 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &divPAtPts);
793 }
794
795 inline MatrixPtr getDivSigmaAtPts() {
796 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &divSigmaAtPts);
797 }
798
799 inline MatrixPtr getSmallWL2AtPts() {
800 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &wL2AtPts);
801 }
802
803 inline MatrixPtr getSmallWL2DotAtPts() {
804 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &wL2DotAtPts);
805 }
806
807 inline MatrixPtr getSmallWL2DotDotAtPts() {
808 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &wL2DotDotAtPts);
809 }
810
811 inline MatrixPtr getLogStretchTensorAtPts() {
812 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
813 &logStretchTensorAtPts);
814 }
815
816 inline MatrixPtr getStretchTensorAtPts() {
817 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
818 &stretchTensorAtPts);
819 }
820
821 inline MatrixPtr getLogStretchDotTensorAtPts() {
822 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
823 &logStretchDotTensorAtPts);
824 }
825
826 inline MatrixPtr getGradLogStretchDotTensorAtPts() {
827 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
828 &gradLogStretchDotTensorAtPts);
829 }
830
831 inline MatrixPtr getRotAxisAtPts() {
832 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &rotAxisAtPts);
833 }
834
835 inline MatrixPtr getRotAxis0AtPts() {
836 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &rotAxis0AtPts);
837 }
838
839 inline MatrixPtr getRotAxisDotAtPts() {
840 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
841 &rotAxisDotAtPts);
842 }
843
844 inline MatrixPtr getRotAxisGradDotAtPts() {
845 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
846 &rotAxisGradDotAtPts);
847 }
848
849 inline MatrixPtr getBigGAtPts() {
850 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &GAtPts);
851 }
852
853 inline MatrixPtr getBigG0AtPts() {
854 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &GAtPts);
855 }
856
857 inline MatrixPtr getMatDPtr() {
858 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &matD);
859 }
860
861 inline MatrixPtr getMatInvDPtr() {
862 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &matInvD);
863 }
864
865 inline MatrixPtr getMatAxiatorDPtr() {
866 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &matAxiatorD);
867 }
868
869 inline MatrixPtr getMatDeviatorDPtr() {
870 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &matDeviatorD);
871 }
872
873 inline MatrixPtr getSmallWH1AtPts() {
874 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &wH1AtPts);
875 }
876
877 inline MatrixPtr getLargeXH1AtPts() {
878 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &XH1AtPts);
879 }
880
881 inline MatrixPtr getContactL2AtPts() {
882 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &contactL2AtPts);
883 }
884
885 inline MatrixPtr getSmallWGradH1AtPts() {
886 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &wGradH1AtPts);
887 }
888
889 inline VectorPtr getJacobianAtPts() {
890 return boost::shared_ptr<VectorDouble>(shared_from_this(), &jacobianAtPts);
891 }
892
893 inline MatrixPtr getLeviKirchhoffAtPts() {
894 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
895 &leviKirchhoffAtPts);
896 };
897
898 inline MatrixPtr getVarRotAxisPts() {
899 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &varRotAxis);
900 }
901
902 inline MatrixPtr getVarLogStreachPts() {
903 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &varLogStreach);
904 }
905
906 inline MatrixPtr getVarPiolaPts() {
907 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &varPiola);
908 }
909
910 inline MatrixPtr getDivVarPiolaPts() {
911 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &varDivPiola);
912 }
913
914 inline MatrixPtr getVarWL2Pts() {
915 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &varWL2);
916 }
917
918 inline MatrixPtr getInternalStressAtPts() {
919 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
920 &internalStressAtPts);
921 }
922
923 inline MatrixPtr getFacePiolaAtPts() {
924 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &facePiolaAtPts);
925 }
926
927 inline MatrixPtr getGradHybridDispAtPts() {
928 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
929 &gradHybridDispAtPts);
930 }
931
932 inline MatrixPtr getEigenValsAtPts() {
933 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &eigenVals);
934 }
935
936 boost::shared_ptr<PhysicalEquations> physicsPtr;
937};
938
939struct OpJacobian;
940
941// Forward declarations
942struct ExternalStrain;
943using ExternalStrainVec = std::vector<ExternalStrain>;
944struct PhysicalEquations {
945
946 typedef FTensor::Tensor1<adouble, 3> ATensor1;
947 typedef FTensor::Tensor2<adouble, 3, 3> ATensor2;
948 typedef FTensor::Tensor3<adouble, 3, 3, 3> ATensor3;
949 typedef FTensor::Tensor1<double, 3> DTensor1;
950 typedef FTensor::Tensor2<double, 3, 3> DTensor2;
951 typedef FTensor::Tensor3<double, 3, 3, 3> DTensor3;
952
953 typedef FTensor::Tensor0<FTensor::PackPtr<double *, 1>> DTensor0Ptr;
954
955 typedef FTensor::Tensor2<FTensor::PackPtr<double *, 1>, 3, 3> DTensor2Ptr;
956 typedef FTensor::Tensor3<FTensor::PackPtr<double *, 1>, 3, 3, 3> DTensor3Ptr;
957
958 PhysicalEquations() = delete;
959 PhysicalEquations(const int size_active, const int size_dependent)
960 : activeVariables(size_active, 0),
961 dependentVariablesPiola(size_dependent, 0),
962 dependentVariablesPiolaDirevatives(size_dependent * size_active, 0) {}
963 virtual ~PhysicalEquations() = default;
964
965 virtual MoFEMErrorCode recordTape(const int tag, DTensor2Ptr *t_h) = 0;
966
967 virtual UserDataOperator *
968 returnOpJacobian(const int tag, const bool eval_rhs, const bool eval_lhs,
969 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
970 boost::shared_ptr<PhysicalEquations> physics_ptr);
971
972 virtual VolUserDataOperator *
973 returnOpSpatialPhysical(const std::string &field_name,
974 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
975 const double alpha_u);
976
977 virtual VolUserDataOperator *
978 returnOpSpatialPhysicalExternalStrain(
979 const std::string &field_name,
980 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
981 boost::shared_ptr<ExternalStrainVec> external_strain_vec_ptr,
982 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv);
983
984 virtual VolUserDataOperator *returnOpSpatialPhysical_du_du(
985 std::string row_field, std::string col_field,
986 boost::shared_ptr<DataAtIntegrationPts> data_ptr, const double alpha);
987
988 virtual VolUserDataOperator *
989 returnOpCalculateEnergy(boost::shared_ptr<DataAtIntegrationPts> data_ptr,
990 boost::shared_ptr<double> total_energy_ptr);
991
992 virtual VolUserDataOperator *returnOpCalculateStretchFromStress(
993 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
994 boost::shared_ptr<PhysicalEquations> physics_ptr);
995
996 virtual VolUserDataOperator *returnOpCalculateVarStretchFromStress(
997 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
998 boost::shared_ptr<PhysicalEquations> physics_ptr);
999
1000 virtual VolUserDataOperator *
1001 returnOpSetScale(boost::shared_ptr<double> scale_ptr,
1002 boost::shared_ptr<PhysicalEquations> physics_ptr);
1003
1004 std::vector<double> activeVariables;
1005 std::vector<double> dependentVariablesPiola;
1006 std::vector<double> dependentVariablesPiolaDirevatives;
1007
1008 /** \name Active variables */
1009
1010 /**@{*/
1011
1012 template <int S>
1013 inline static DTensor2Ptr get_VecTensor2(std::vector<double> &v) {
1014 return DTensor2Ptr(&v[S + 0], &v[S + 1], &v[S + 2], &v[S + 3], &v[S + 4],
1015 &v[S + 5], &v[S + 6], &v[S + 7], &v[S + 8]);
1016 }
1017
1018 template <int S>
1019 inline static DTensor0Ptr get_VecTensor0(std::vector<double> &v) {
1020 return DTensor0Ptr(&v[S + 0]);
1021 }
1022
1023 template <int S0>
1024 inline static DTensor3Ptr get_vecTensor3(std::vector<double> &v,
1025 const int nba) {
1026
1027 const int A00 = nba * 0 + S0;
1028 const int A01 = nba * 1 + S0;
1029 const int A02 = nba * 2 + S0;
1030 const int A10 = nba * 3 + S0;
1031 const int A11 = nba * 4 + S0;
1032 const int A12 = nba * 5 + S0;
1033 const int A20 = nba * 6 + S0;
1034 const int A21 = nba * 7 + S0;
1035 const int A22 = nba * 8 + S0;
1036
1037 return DTensor3Ptr(
1038
1039 &v[A00 + 0], &v[A00 + 1], &v[A00 + 2], &v[A01 + 0], &v[A01 + 1],
1040 &v[A01 + 2], &v[A02 + 0], &v[A02 + 1], &v[A02 + 2],
1041
1042 &v[A10 + 0], &v[A10 + 1], &v[A10 + 2], &v[A11 + 0], &v[A11 + 1],
1043 &v[A11 + 2], &v[A12 + 0], &v[A12 + 1], &v[A12 + 2],
1044
1045 &v[A20 + 0], &v[A20 + 1], &v[A20 + 2], &v[A21 + 0], &v[A21 + 1],
1046 &v[A21 + 2], &v[A22 + 0], &v[A22 + 1], &v[A22 + 2]
1047
1048 );
1049 }
1050
1051 /**@}*/
1052
1053 /** \name Active variables */
1054
1055 /**@{*/
1056
1057 inline DTensor2Ptr get_h() { return get_VecTensor2<0>(activeVariables); }
1058
1059 /**@}*/
1060
1061 /** \name Dependent variables */
1062
1063 /**@{*/
1064
1065 inline DTensor2Ptr get_P() {
1066 return get_VecTensor2<0>(dependentVariablesPiola);
1067 }
1068
1069 /**@}*/
1070
1071 /** \name Derivatives of dependent variables */
1072
1073 /**@{*/
1074
1075 inline DTensor3Ptr get_P_dh0() {
1076 return get_vecTensor3<0>(dependentVariablesPiolaDirevatives,
1077 activeVariables.size());
1078 }
1079 inline DTensor3Ptr get_P_dh1() {
1080 return get_vecTensor3<3>(dependentVariablesPiolaDirevatives,
1081 activeVariables.size());
1082 }
1083 inline DTensor3Ptr get_P_dh2() {
1084 return get_vecTensor3<6>(dependentVariablesPiolaDirevatives,
1085 activeVariables.size());
1086 }
1087
1088 /**@}*/
1089};
1090
1091struct BcDisp {
1092 BcDisp(std::string name, std::vector<double> attr, Range faces);
1093 std::string blockName;
1094 Range faces;
1095 VectorDouble3 vals;
1096 VectorInt3 flags;
1097};
1098using BcDispVec = std::vector<BcDisp>;
1099
1100struct BcRot {
1101 BcRot(std::string name, std::vector<double> attr, Range faces);
1102 std::string blockName;
1103 Range faces;
1104 VectorDouble vals;
1105 double theta;
1106};
1107using BcRotVec = std::vector<BcRot>;
1108
1109typedef std::vector<Range> TractionFreeBc;
1110
1111struct TractionBc {
1112 TractionBc(std::string name, std::vector<double> attr, Range faces);
1113 std::string blockName;
1114 Range faces;
1115 VectorDouble3 vals;
1116 VectorInt3 flags;
1117};
1118using TractionBcVec = std::vector<TractionBc>;
1119
1120struct NormalDisplacementBc {
1121 NormalDisplacementBc(std::string name, std::vector<double> attr, Range faces);
1122 std::string blockName;
1123 Range faces;
1124 double val;
1125};
1126using NormalDisplacementBcVec = std::vector<NormalDisplacementBc>;
1127
1128struct AnalyticalDisplacementBc {
1129 AnalyticalDisplacementBc(std::string name, std::vector<double> attr,
1130 Range faces);
1131 std::string blockName;
1132 Range faces;
1133 VectorInt3 flags;
1134};
1135using AnalyticalDisplacementBcVec = std::vector<AnalyticalDisplacementBc>;
1136
1137struct AnalyticalTractionBc {
1138 AnalyticalTractionBc(std::string name, std::vector<double> attr, Range faces);
1139 std::string blockName;
1140 Range faces;
1141 VectorInt3 flags;
1142};
1143using AnalyticalTractionBcVec = std::vector<AnalyticalTractionBc>;
1144
1145struct PressureBc {
1146 PressureBc(std::string name, std::vector<double> attr, Range faces);
1147 std::string blockName;
1148 Range faces;
1149 double val;
1150};
1151using PressureBcVec = std::vector<PressureBc>;
1152
1153struct ExternalStrain {
1154 ExternalStrain(std::string name, std::vector<double> attr, Range ents);
1155 std::string blockName;
1156 Range ents;
1157 double val;
1158 double bulkModulusK;
1159};
1160
1161 #ifdef ENABLE_PYTHON_BINDING
1162struct AnalyticalExprPython {
1163 AnalyticalExprPython() = default;
1164 virtual ~AnalyticalExprPython() = default;
1165
1166 MoFEMErrorCode analyticalExprInit(const std::string py_file);
1167 MoFEMErrorCode evalAnalyticalDisp(double delta_t, double t, np::ndarray x,
1168 np::ndarray y, np::ndarray z,
1169 np::ndarray nx, np::ndarray ny,
1170 np::ndarray nz,
1171 const std::string &block_name,
1172 np::ndarray &analytical_expr);
1173 MoFEMErrorCode evalAnalyticalTraction(double delta_t, double t, np::ndarray x,
1174 np::ndarray y, np::ndarray z,
1175 np::ndarray nx, np::ndarray ny,
1176 np::ndarray nz,
1177 const std::string &block_name,
1178 np::ndarray &analytical_expr);
1179
1180 template <typename T>
1181 inline std::vector<T>
1182 py_list_to_std_vector(const boost::python::object &iterable) {
1183 return std::vector<T>(boost::python::stl_input_iterator<T>(iterable),
1184 boost::python::stl_input_iterator<T>());
1185 }
1186
1187private:
1188 bp::object mainNamespace;
1189 bp::object analyticalDispFun;
1190 bp::object analyticalTractionFun;
1191};
1192
1193extern boost::weak_ptr<AnalyticalExprPython> AnalyticalExprPythonWeakPtr;
1194 #endif
1195
1196 #include "EshelbianCore.hpp"
1197 #include "EshelbianOperators.hpp"
1198
1199} // namespace EshelbianPlasticity
1200
1201#endif //__ESHELBIAN_PLASTICITY_HPP__
UserDataOperator
ForcesAndSourcesCore::UserDataOperator UserDataOperator
Definition HookeElement.hpp:75
mu
double mu
Definition dynamic_first_order_con_law.cpp:97
lambda
static double lambda
Definition incompressible_elasticity.cpp:181
v
const double v
phase velocity of light in medium (cm/ns)
Definition initial_diffusion.cpp:40
EshelbianPlasticity::VectorPtr
boost::shared_ptr< VectorDouble > VectorPtr
Definition EshelbianPlasticity.hpp:69
EshelbianPlasticity::AnalyticalTractionBcVec
std::vector< AnalyticalTractionBc > AnalyticalTractionBcVec
Definition EshelbianPlasticity.hpp:530
EshelbianPlasticity::BcDispVec
std::vector< BcDisp > BcDispVec
Definition EshelbianPlasticity.hpp:485
EshelbianPlasticity::NormalDisplacementBcVec
std::vector< NormalDisplacementBc > NormalDisplacementBcVec
Definition EshelbianPlasticity.hpp:513
EshelbianPlasticity::BcRotVec
std::vector< BcRot > BcRotVec
Definition EshelbianPlasticity.hpp:494
EshelbianPlasticity::ExternalStrainVec
std::vector< ExternalStrain > ExternalStrainVec
Definition EshelbianPlasticity.hpp:330
EshelbianPlasticity::AnalyticalDisplacementBcVec
std::vector< AnalyticalDisplacementBc > AnalyticalDisplacementBcVec
Definition EshelbianPlasticity.hpp:522
EshelbianPlasticity::TractionFreeBc
std::vector< Range > TractionFreeBc
Definition EshelbianPlasticity.hpp:496
EshelbianPlasticity::PressureBcVec
std::vector< PressureBc > PressureBcVec
Definition EshelbianPlasticity.hpp:538
EshelbianPlasticity::TractionBcVec
std::vector< TractionBc > TractionBcVec
Definition EshelbianPlasticity.hpp:505
EshelbianPlasticity::MatrixPtr
boost::shared_ptr< MatrixDouble > MatrixPtr
Definition EshelbianPlasticity.hpp:68
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition Exceptions.hpp:56
t
constexpr double t
plate stiffness
Definition plate.cpp:58
field_name
constexpr auto field_name
Definition poisson_2d_homogeneous.cpp:13
EleOnSide
PipelineManager::ElementsAndOpsByDim< SPACE_DIM >::FaceSideEle EleOnSide
Definition scalar_check_approximation.cpp:27
MoFEM::EntitiesFieldData::EntData
Data on single entity (This is passed as argument to DataOperator::doWork)
Definition EntitiesFieldData.hpp:128

Member Function Documentation

◆ iNtegrate()

template<AssemblyType A>
MoFEMErrorCode OpNormalDispBcLhsImpl_dU< A, GAUSS >::iNtegrate ( EntData & row_data,
EntData & col_data )
protected
Examples
EshelbianOperators.cpp.

Definition at line 1664 of file EshelbianOperators.cpp.

1665 {
1666 MoFEMFunctionBegin;
1667
1668 double time = OP::getFEMethod()->ts_t;
1669 if (EshelbianCore::dynamicRelaxation) {
1670 time = EshelbianCore::dynamicTime;
1671 }
1672
1673 int row_nb_dofs = row_data.getIndices().size();
1674 int col_nb_dofs = col_data.getIndices().size();
1675 auto &locMat = OP::locMat;
1676 locMat.resize(row_nb_dofs, col_nb_dofs, false);
1677 locMat.clear();
1678
1679 // get entity of face
1680 EntityHandle fe_ent = OP::getFEEntityHandle();
1681 // iterate over all boundary data
1682 for (auto &bc : (*bcDispPtr)) {
1683 // check if finite element entity is part of boundary condition
1684 if (bc.faces.find(fe_ent) != bc.faces.end()) {
1685
1686 auto t_normal = OP::getFTensor1NormalsAtGaussPts();
1687 auto t_w = OP::getFTensor0IntegrationWeight();
1688
1689 FTENSOR_INDEX(SPACE_DIM, i);
1690 FTENSOR_INDEX(SPACE_DIM, j);
1691
1692 double scale = 1;
1693 if (scalingMethodsMap.find(bc.blockName) != scalingMethodsMap.end()) {
1694 scale *= scalingMethodsMap.at(bc.blockName)->getScale(time);
1695 } else {
1696 MOFEM_LOG("SELF", Sev::warning)
1697 << "No scaling method found for " << bc.blockName;
1698 }
1699
1700 int nb_integration_pts = OP::getGaussPts().size2();
1701 int row_nb_dofs = row_data.getIndices().size();
1702 int col_nb_dofs = col_data.getIndices().size();
1703 int nb_base_functions = row_data.getN().size2();
1704 auto t_row_base = row_data.getFTensor0N();
1705
1706 auto t_kd = FTensor::Kronecker_Delta<double>();
1707
1708 for (int gg = 0; gg != nb_integration_pts; ++gg) {
1709
1710 FTensor::Tensor1<double, SPACE_DIM> t_N;
1711 t_N(i) = t_normal(i);
1712 t_N.normalize();
1713
1714 FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_P;
1715 t_P(i, j) = t_N(i) * t_N(j);
1716
1717 FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_d_res;
1718 t_d_res(i, j) = 2.0 * t_P(i, j);
1719
1720 int rr = 0;
1721 for (; rr != row_nb_dofs / SPACE_DIM; ++rr) {
1722 auto t_mat = getFTensor2FromArray<SPACE_DIM, SPACE_DIM, SPACE_DIM>(
1723 locMat, SPACE_DIM * rr);
1724 auto t_col_base = col_data.getFTensor0N(gg, 0);
1725 for (auto cc = 0; cc != col_nb_dofs / SPACE_DIM; ++cc) {
1726 t_mat(i, j) += (t_w * t_row_base * t_col_base) * t_d_res(i, j);
1727 ++t_mat;
1728 ++t_col_base;
1729 }
1730 ++t_row_base;
1731 }
1732
1733 for (; rr != nb_base_functions; ++rr)
1734 ++t_row_base;
1735
1736 ++t_w;
1737 ++t_normal;
1738 }
1739
1740 locMat *= OP::getMeasure();
1741
1742 }
1743 }
1744 MoFEMFunctionReturn(0);
1745}
FTENSOR_INDEX
#define FTENSOR_INDEX(DIM, I)
Definition Templates.hpp:2049
SPACE_DIM
constexpr int SPACE_DIM
Definition child_and_parent.cpp:16
FTensor::Kronecker_Delta
Kronecker Delta class.
Definition Kronecker_Delta.hpp:15
FTensor::Tensor1::normalize
Tensor1< T, Tensor_Dim > normalize()
Definition Tensor1_value.hpp:77
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition definitions.h:359
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition definitions.h:432
t_kd
constexpr auto t_kd
Definition free_surface.cpp:139
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition LogManager.hpp:316
i
FTensor::Index< 'i', SPACE_DIM > i
Definition hcurl_divergence_operator_2d.cpp:27
j
FTensor::Index< 'j', 3 > j
Definition matrix_function.cpp:19
MoFEM::getFTensor2FromArray
FTensor::Tensor2< FTensor::PackPtr< double *, S >, DIM1, DIM2 > getFTensor2FromArray(MatrixDouble &data, const size_t rr, const size_t cc=0)
Definition Templates.hpp:1354
scale
double scale
Definition plastic.cpp:123
EshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS >::bcDispPtr
boost::shared_ptr< NormalDisplacementBcVec > bcDispPtr
Definition EshelbianPlasticity.hpp:624
EshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS >::scalingMethodsMap
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
Definition EshelbianPlasticity.hpp:625
MoFEM::EntitiesFieldData::EntData::getFTensor0N
FTensor::Tensor0< FTensor::PackPtr< double *, 1 > > getFTensor0N(const FieldApproximationBase base)
Get base function as Tensor0.
Definition EntitiesFieldData.hpp:1524
MoFEM::EntitiesFieldData::EntData::getN
MatrixDouble & getN(const FieldApproximationBase base)
get base functions this return matrix (nb. of rows is equal to nb. of Gauss pts, nb....
Definition EntitiesFieldData.hpp:1318
MoFEM::EntitiesFieldData::EntData::getIndices
const VectorInt & getIndices() const
Get global indices of dofs on entity.
Definition EntitiesFieldData.hpp:1214

Member Data Documentation

◆ bcDispPtr

template<AssemblyType A>
boost::shared_ptr<NormalDisplacementBcVec> EshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS >::bcDispPtr
protected

Definition at line 624 of file EshelbianPlasticity.hpp.

◆ scalingMethodsMap

template<AssemblyType A>
std::map<std::string, boost::shared_ptr<ScalingMethod> > EshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS >::scalingMethodsMap
protected

Definition at line 625 of file EshelbianPlasticity.hpp.

The documentation for this struct was generated from the following files:
Generated by Doxygen 1.12.0 and hosted at University of Glasgow