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

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

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

Public Types

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)
 

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_dP< A, GAUSS >

Definition at line 629 of file EshelbianPlasticity.hpp.

Member Typedef Documentation

◆ OP

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

Definition at line 632 of file EshelbianPlasticity.hpp.

Constructor & Destructor Documentation

◆ OpNormalDispBcLhsImpl_dP()

template<AssemblyType A>
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__ltip=" ",!Z
1223
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_dP< A, GAUSS >::iNtegrate ( EntData & row_data,
EntData & col_data )
protected
Examples
EshelbianOperators.cpp.

Definition at line 1749 of file EshelbianOperators.cpp.

1750 {
1751 MoFEMFunctionBegin;
1752
1753 double time = OP::getFEMethod()->ts_t;
1754 if (EshelbianCore::dynamicRelaxation) {
1755 time = EshelbianCore::dynamicTime;
1756 }
1757
1758 int row_nb_dofs = row_data.getIndices().size();
1759 int col_nb_dofs = col_data.getIndices().size();
1760 auto &locMat = OP::locMat;
1761 locMat.resize(row_nb_dofs, col_nb_dofs, false);
1762 locMat.clear();
1763
1764 // get entity of face
1765 EntityHandle fe_ent = OP::getFEEntityHandle();
1766 // iterate over all boundary data
1767 for (auto &bc : (*bcDispPtr)) {
1768 // check if finite element entity is part of boundary condition
1769 if (bc.faces.find(fe_ent) != bc.faces.end()) {
1770
1771 auto t_normal = OP::getFTensor1NormalsAtGaussPts();
1772 auto t_w = OP::getFTensor0IntegrationWeight();
1773
1774 FTENSOR_INDEX(SPACE_DIM, i);
1775 FTENSOR_INDEX(SPACE_DIM, j);
1776 FTENSOR_INDEX(SPACE_DIM, k);
1777
1778 auto t_kd = FTensor::Kronecker_Delta<double>();
1779
1780 double scale = 1;
1781 if (scalingMethodsMap.find(bc.blockName) != scalingMethodsMap.end()) {
1782 scale *= scalingMethodsMap.at(bc.blockName)->getScale(time);
1783 } else {
1784 MOFEM_LOG("SELF", Sev::warning)
1785 << "No scaling method found for " << bc.blockName;
1786 }
1787
1788 int nb_integration_pts = OP::getGaussPts().size2();
1789 int nb_base_functions = row_data.getN().size2();
1790 auto t_row_base = row_data.getFTensor0N();
1791
1792 for (int gg = 0; gg != nb_integration_pts; ++gg) {
1793
1794 FTensor::Tensor1<double, SPACE_DIM> t_N;
1795 t_N(i) = t_normal(i);
1796 t_N.normalize();
1797
1798 FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_P;
1799 t_P(i, j) = t_N(i) * t_N(j);
1800 FTensor::Tensor2<double, 3, 3> t_Q;
1801 t_Q(i, j) = t_kd(i, j) - t_P(i, j);
1802
1803 FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_d_res;
1804 t_d_res(i, j) = t_Q(i, j);
1805
1806 int rr = 0;
1807 for (; rr != row_nb_dofs / SPACE_DIM; ++rr) {
1808 auto t_mat = getFTensor2FromArray<SPACE_DIM, SPACE_DIM, SPACE_DIM>(
1809 OP::locMat, SPACE_DIM * rr);
1810 auto t_col_base = col_data.getFTensor1N<3>(gg, 0);
1811 for (auto cc = 0; cc != col_nb_dofs / SPACE_DIM; ++cc) {
1812 t_mat(i, j) +=
1813 ((t_w * t_row_base) * (t_N(k) * t_col_base(k))) * t_d_res(i, j);
1814 ++t_mat;
1815 ++t_col_base;
1816 }
1817 ++t_row_base;
1818 }
1819
1820 for (; rr != nb_base_functions; ++rr)
1821 ++t_row_base;
1822
1823 ++t_w;
1824 ++t_normal;
1825 }
1826
1827 locMat *= OP::getMeasure();
1828 }
1829 }
1830 MoFEMFunctionReturn(0);
1831}
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
k
FTensor::Index< 'k', 3 > k
Definition matrix_function.cpp:20
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_dP< A, GAUSS >::scalingMethodsMap
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
Definition EshelbianPlasticity.hpp:647
EshelbianPlasticity::OpNormalDispBcLhsImpl_dP< A, GAUSS >::bcDispPtr
boost::shared_ptr< NormalDisplacementBcVec > bcDispPtr
Definition EshelbianPlasticity.hpp:646
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::getFTensor1N
FTensor::Tensor1< FTensor::PackPtr< double *, Tensor_Dim >, Tensor_Dim > getFTensor1N(FieldApproximationBase base)
Get base functions for Hdiv/Hcurl spaces.
Definition EntitiesFieldData.cpp:640
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_dP< A, GAUSS >::bcDispPtr
protected

Definition at line 646 of file EshelbianPlasticity.hpp.

◆ scalingMethodsMap

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

Definition at line 647 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