v0.15.0
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Member Functions | List of all members
EshelbianPlasticity::OpNormalDispLhsBc_dP Struct Reference

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

Inheritance diagram for EshelbianPlasticity::OpNormalDispLhsBc_dP:
[legend]
Collaboration diagram for EshelbianPlasticity::OpNormalDispLhsBc_dP:
[legend]

Public Types

using OP = OpNormalDispBcLhsImpl_dP<A, GAUSS>
 
- Public Types inherited from EshelbianPlasticity::OpNormalDispBcLhsImpl_dP< A, GAUSS >
using OP
 

Public Member Functions

 OpNormalDispBcLhsImpl_dP (std::string row_field, boost::shared_ptr< std::vector< BrokenBaseSideData > > broken_base_side_data, boost::shared_ptr< NormalDisplacementBcVec > &bc_disp_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv, boost::shared_ptr< Range > ents_ptr=nullptr)
 
- Public Member Functions inherited from EshelbianPlasticity::OpNormalDispBcLhsImpl_dP< A, GAUSS >
 OpNormalDispBcLhsImpl_dP (std::string row_field, boost::shared_ptr< std::vector< BrokenBaseSideData > > broken_base_side_data, 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 Member Functions inherited from EshelbianPlasticity::OpNormalDispBcLhsImpl_dP< A, GAUSS >
MoFEMErrorCode iNtegrate (EntData &row_data, EntData &col_data)
 

Additional Inherited Members

- Protected Attributes inherited from EshelbianPlasticity::OpNormalDispBcLhsImpl_dP< A, GAUSS >
boost::shared_ptr< NormalDisplacementBcVec > bcDispPtr
 
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
 

Detailed Description

Definition at line 666 of file EshelbianPlasticity.hpp.

Member Typedef Documentation

◆ OP

using EshelbianPlasticity::OpNormalDispLhsBc_dP::OP = OpNormalDispBcLhsImpl_dP<A, GAUSS>

Definition at line 667 of file EshelbianPlasticity.hpp.

Member Function Documentation

◆ iNtegrate()

MoFEMErrorCode OpNormalDispLhsBc_dP::iNtegrate ( EntData & row_data,
EntData & col_data )
protected
Examples
EshelbianOperators.cpp.

Definition at line 1842 of file EshelbianOperators.cpp.

1843 {
1844 return OP::iNtegrate(row_data, col_data);
1845}
EshelbianPlasticity::OpNormalDispBcLhsImpl_dP< A, GAUSS >::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Definition EshelbianOperators.cpp:1749

◆ OpNormalDispBcLhsImpl_dP()

EshelbianPlasticity::OpNormalDispBcLhsImpl_dP< A, GAUSS >::OpNormalDispBcLhsImpl_dP ( std::string row_field,
boost::shared_ptr< std::vector< BrokenBaseSideData > > broken_base_side_data,
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 635 of file EshelbianPlasticity.hpp.

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