Loading [MathJax]/extensions/TeX/AMSsymbols.js
 Reference documentation for deal.II version 8.5.1
All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
transformations.h
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2016 - 2017 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE at
12 // the top level of the deal.II distribution.
13 //
14 // ---------------------------------------------------------------------
15 
16 #ifndef dealii__transformations_h
17 #define dealii__transformations_h
18 
19 #include <deal.II/base/point.h>
20 #include <deal.II/base/tensor.h>
21 #include <deal.II/base/symmetric_tensor.h>
22 
23 DEAL_II_NAMESPACE_OPEN
24 
25 
26 namespace Physics
27 {
28 
29  namespace Transformations
30  {
31 
38  namespace Rotations
39  {
44 
60  template<typename Number>
62  rotation_matrix_2d (const Number &angle);
63 
64 
93  template<typename Number>
96  const Number &angle);
97 
99 
100  }
101 
120  namespace Contravariant
121  {
122 
127 
141  template <int dim, typename Number>
144  const Tensor<2,dim,Number> &F);
145 
159  template <int dim, typename Number>
162  const Tensor<2,dim,Number> &F);
163 
178  template <int dim, typename Number>
181  const Tensor<2,dim,Number> &F);
182 
196  template <int dim, typename Number>
199  const Tensor<2,dim,Number> &F);
200 
215  template <int dim, typename Number>
218  const Tensor<2,dim,Number> &F);
219 
221 
226 
240  template <int dim, typename Number>
243  const Tensor<2,dim,Number> &F);
244 
258  template <int dim, typename Number>
261  const Tensor<2,dim,Number> &F);
262 
276  template <int dim, typename Number>
279  const Tensor<2,dim,Number> &F);
280 
294  template <int dim, typename Number>
297  const Tensor<2,dim,Number> &F);
298 
312  template <int dim, typename Number>
315  const Tensor<2,dim,Number> &F);
316 
318  }
319 
339  namespace Covariant
340  {
341 
346 
360  template <int dim, typename Number>
363  const Tensor<2,dim,Number> &F);
364 
378  template <int dim, typename Number>
381  const Tensor<2,dim,Number> &F);
382 
397  template <int dim, typename Number>
400  const Tensor<2,dim,Number> &F);
401 
415  template <int dim, typename Number>
418  const Tensor<2,dim,Number> &F);
419 
434  template <int dim, typename Number>
437  const Tensor<2,dim,Number> &F);
438 
440 
445 
459  template <int dim, typename Number>
462  const Tensor<2,dim,Number> &F);
463 
477  template <int dim, typename Number>
480  const Tensor<2,dim,Number> &F);
481 
495  template <int dim, typename Number>
498  const Tensor<2,dim,Number> &F);
499 
513  template <int dim, typename Number>
516  const Tensor<2,dim,Number> &F);
517 
531  template <int dim, typename Number>
534  const Tensor<2,dim,Number> &F);
535 
537  }
538 
546  namespace Piola
547  {
548 
553 
568  template <int dim, typename Number>
571  const Tensor<2,dim,Number> &F);
572 
587  template <int dim, typename Number>
590  const Tensor<2,dim,Number> &F);
591 
607  template <int dim, typename Number>
610  const Tensor<2,dim,Number> &F);
611 
626  template <int dim, typename Number>
629  const Tensor<2,dim,Number> &F);
630 
646  template <int dim, typename Number>
649  const Tensor<2,dim,Number> &F);
650 
652 
657 
672  template <int dim, typename Number>
675  const Tensor<2,dim,Number> &F);
676 
691  template <int dim, typename Number>
694  const Tensor<2,dim,Number> &F);
695 
710  template <int dim, typename Number>
713  const Tensor<2,dim,Number> &F);
714 
729  template <int dim, typename Number>
732  const Tensor<2,dim,Number> &F);
733 
748  template <int dim, typename Number>
751  const Tensor<2,dim,Number> &F);
752 
754  }
755 
760 
783  template<int dim, typename Number>
786  const Tensor<2,dim,Number> &F);
787 
789  }
790 }
791 
792 
793 
794 #ifndef DOXYGEN
795 
796 // ------------------------- inline functions ------------------------
797 
798 namespace internal
799 {
800  namespace Physics
801  {
802  namespace
803  {
804  template <int dim, typename Number>
805  inline
807  transformation_contraction (const Tensor<1,dim,Number> &V,
808  const Tensor<2,dim,Number> &F)
809  {
810  return contract<1,0>(F, V);
811  }
812 
813 
814 
815  template <int dim, typename Number>
816  inline
818  transformation_contraction (const Tensor<2,dim,Number> &T,
819  const Tensor<2,dim,Number> &F)
820  {
821  return contract<1,1>(F,contract<1,0>(F, T));
822  }
823 
824 
825 
826  template <int dim, typename Number>
827  inline
828  ::SymmetricTensor<2,dim,Number>
829  transformation_contraction (const ::SymmetricTensor<2,dim,Number> &T,
830  const Tensor<2,dim,Number> &F)
831  {
832  Tensor<2,dim,Number> tmp_1;
833  for (unsigned int i=0; i<dim; ++i)
834  for (unsigned int J=0; J<dim; ++J)
835  for (unsigned int I=0; I<dim; ++I)
836  tmp_1[i][J] += F[i][I] * T[I][J];
837 
839  for (unsigned int i=0; i<dim; ++i)
840  for (unsigned int j=i; j<dim; ++j)
841  for (unsigned int J=0; J<dim; ++J)
842  out[i][j] += F[j][J] * tmp_1[i][J];
843 
844  return out;
845  }
846 
847 
848 
849  template <int dim, typename Number>
850  inline
852  transformation_contraction (const Tensor<4,dim,Number> &H,
853  const Tensor<2,dim,Number> &F)
854  {
855  // Its significantly quicker (in 3d) to push forward
856  // each index individually
857  return contract<1,3>(F,contract<1,2>(F,contract<1,1>(F,contract<1,0>(F, H))));
858  }
859 
860 
861 
862  template <int dim, typename Number>
863  inline
864  ::SymmetricTensor<4,dim,Number>
865  transformation_contraction (const ::SymmetricTensor<4,dim,Number> &H,
866  const Tensor<2,dim,Number> &F)
867  {
868  // Its significantly quicker (in 3d) to push forward
869  // each index individually
870 
871  Tensor<4,dim,Number> tmp_1;
872  for (unsigned int i=0; i<dim; ++i)
873  for (unsigned int J=0; J<dim; ++J)
874  for (unsigned int K=0; K<dim; ++K)
875  for (unsigned int L=0; L<dim; ++L)
876  for (unsigned int I=0; I<dim; ++I)
877  tmp_1[i][J][K][L] += F[i][I] * H[I][J][K][L];
878 
879  Tensor<4,dim,Number> tmp_2;
880  for (unsigned int i=0; i<dim; ++i)
881  for (unsigned int j=0; j<dim; ++j)
882  for (unsigned int K=0; K<dim; ++K)
883  for (unsigned int L=0; L<dim; ++L)
884  for (unsigned int J=0; J<dim; ++J)
885  tmp_2[i][j][K][L] += F[j][J] * tmp_1[i][J][K][L];
886 
887  tmp_1 = 0.0;
888  for (unsigned int i=0; i<dim; ++i)
889  for (unsigned int j=0; j<dim; ++j)
890  for (unsigned int k=0; k<dim; ++k)
891  for (unsigned int L=0; L<dim; ++L)
892  for (unsigned int K=0; K<dim; ++K)
893  tmp_1[i][j][k][L] += F[k][K] * tmp_2[i][j][K][L];
894 
896  for (unsigned int i=0; i<dim; ++i)
897  for (unsigned int j=i; j<dim; ++j)
898  for (unsigned int k=0; k<dim; ++k)
899  for (unsigned int l=k; l<dim; ++l)
900  for (unsigned int L=0; L<dim; ++L)
901  out[i][j][k][l] += F[l][L] * tmp_1[i][j][k][L];
902 
903  return out;
904  }
905  }
906  }
907 }
908 
909 
910 
911 template<typename Number>
914 {
915  const double rotation[2][2]
916  = {{
917  std::cos(angle) , -std::sin(angle)
918  },
919  {
920  std::sin(angle) , std::cos(angle)
921  }
922  };
923  return Tensor<2,2> (rotation);
924 }
925 
926 
927 
928 template<typename Number>
931  const Number &angle)
932 {
933  Assert(std::abs(axis.norm() - 1.0) < 1e-9,
934  ExcMessage("The supplied axial vector is not a unit vector."));
935  const Number c = std::cos(angle);
936  const Number s = std::sin(angle);
937  const Number t = 1.-c;
938  const double rotation[3][3]
939  = {{
940  t *axis[0] *axis[0] + c,
941  t *axis[0] *axis[1] - s *axis[2],
942  t *axis[0] *axis[2] + s *axis[1]
943  },
944  {
945  t *axis[0] *axis[1] + s *axis[2],
946  t *axis[1] *axis[1] + c,
947  t *axis[1] *axis[2] - s *axis[0]
948  },
949  {
950  t *axis[0] *axis[2] - s *axis[1],
951  t *axis[1] *axis[2] + s *axis[0],
952  t *axis[2] *axis[2] + c
953  }
954  };
955  return Tensor<2,3,Number>(rotation);
956 }
957 
958 
959 
960 template <int dim, typename Number>
961 inline
964  const Tensor<2,dim,Number> &F)
965 {
966  return internal::Physics::transformation_contraction(V,F);
967 }
968 
969 
970 
971 template <int dim, typename Number>
972 inline
975  const Tensor<2,dim,Number> &F)
976 {
977  return internal::Physics::transformation_contraction(T,F);
978 }
979 
980 
981 
982 template <int dim, typename Number>
983 inline
986  const Tensor<2,dim,Number> &F)
987 {
988  return internal::Physics::transformation_contraction(T,F);
989 }
990 
991 
992 
993 template <int dim, typename Number>
994 inline
997  const Tensor<2,dim,Number> &F)
998 {
999  return internal::Physics::transformation_contraction(H,F);
1000 }
1001 
1002 
1003 
1004 template <int dim, typename Number>
1005 inline
1008  const Tensor<2,dim,Number> &F)
1009 {
1010  return internal::Physics::transformation_contraction(H,F);
1011 }
1012 
1013 
1014 
1015 template <int dim, typename Number>
1016 inline
1019  const Tensor<2,dim,Number> &F)
1020 {
1021  return internal::Physics::transformation_contraction(v,invert(F));
1022 }
1023 
1024 
1025 
1026 template <int dim, typename Number>
1027 inline
1030  const Tensor<2,dim,Number> &F)
1031 {
1032  return internal::Physics::transformation_contraction(t,invert(F));
1033 }
1034 
1035 
1036 
1037 template <int dim, typename Number>
1038 inline
1041  const Tensor<2,dim,Number> &F)
1042 {
1043  return internal::Physics::transformation_contraction(t,invert(F));
1044 }
1045 
1046 
1047 
1048 template <int dim, typename Number>
1049 inline
1052  const Tensor<2,dim,Number> &F)
1053 {
1054  return internal::Physics::transformation_contraction(h,invert(F));
1055 }
1056 
1057 
1058 
1059 template <int dim, typename Number>
1060 inline
1063  const Tensor<2,dim,Number> &F)
1064 {
1065  return internal::Physics::transformation_contraction(h,invert(F));
1066 }
1067 
1068 
1069 
1070 template <int dim, typename Number>
1071 inline
1074  const Tensor<2,dim,Number> &F)
1075 {
1076  return internal::Physics::transformation_contraction(V,transpose(invert(F)));
1077 }
1078 
1079 
1080 
1081 template <int dim, typename Number>
1082 inline
1085  const Tensor<2,dim,Number> &F)
1086 {
1087  return internal::Physics::transformation_contraction(T,transpose(invert(F)));
1088 }
1089 
1090 
1091 
1092 template <int dim, typename Number>
1093 inline
1096  const Tensor<2,dim,Number> &F)
1097 {
1098  return internal::Physics::transformation_contraction(T,transpose(invert(F)));
1099 }
1100 
1101 
1102 
1103 template <int dim, typename Number>
1104 inline
1107  const Tensor<2,dim,Number> &F)
1108 {
1109  return internal::Physics::transformation_contraction(H,transpose(invert(F)));
1110 }
1111 
1112 
1113 
1114 template <int dim, typename Number>
1115 inline
1118  const Tensor<2,dim,Number> &F)
1119 {
1120  return internal::Physics::transformation_contraction(H,transpose(invert(F)));
1121 }
1122 
1123 
1124 
1125 template <int dim, typename Number>
1126 inline
1129  const Tensor<2,dim,Number> &F)
1130 {
1131  return internal::Physics::transformation_contraction(v,transpose(F));
1132 }
1133 
1134 
1135 
1136 template <int dim, typename Number>
1137 inline
1140  const Tensor<2,dim,Number> &F)
1141 {
1142  return internal::Physics::transformation_contraction(t,transpose(F));
1143 }
1144 
1145 
1146 
1147 template <int dim, typename Number>
1148 inline
1151  const Tensor<2,dim,Number> &F)
1152 {
1153  return internal::Physics::transformation_contraction(t,transpose(F));
1154 }
1155 
1156 
1157 
1158 template <int dim, typename Number>
1159 inline
1162  const Tensor<2,dim,Number> &F)
1163 {
1164  return internal::Physics::transformation_contraction(h,transpose(F));
1165 }
1166 
1167 
1168 
1169 template <int dim, typename Number>
1170 inline
1173  const Tensor<2,dim,Number> &F)
1174 {
1175  return internal::Physics::transformation_contraction(h,transpose(F));
1176 }
1177 
1178 
1179 
1180 template <int dim, typename Number>
1181 inline
1184  const Tensor<2,dim,Number> &F)
1185 {
1186  return Number(1.0/determinant(F))*Contravariant::push_forward(V,F);
1187 }
1188 
1189 
1190 
1191 template <int dim, typename Number>
1192 inline
1195  const Tensor<2,dim,Number> &F)
1196 {
1197  return Number(1.0/determinant(F))*Contravariant::push_forward(T,F);
1198 }
1199 
1200 
1201 
1202 template <int dim, typename Number>
1203 inline
1206  const Tensor<2,dim,Number> &F)
1207 {
1208  return Number(1.0/determinant(F))*Contravariant::push_forward(T,F);
1209 }
1210 
1211 
1212 
1213 template <int dim, typename Number>
1214 inline
1217  const Tensor<2,dim,Number> &F)
1218 {
1219  return Number(1.0/determinant(F))*Contravariant::push_forward(H,F);
1220 }
1221 
1222 
1223 
1224 template <int dim, typename Number>
1225 inline
1228  const Tensor<2,dim,Number> &F)
1229 {
1230  return Number(1.0/determinant(F))*Contravariant::push_forward(H,F);
1231 }
1232 
1233 
1234 
1235 template <int dim, typename Number>
1236 inline
1239  const Tensor<2,dim,Number> &F)
1240 {
1241  return Number(determinant(F))*Contravariant::pull_back(v,F);
1242 }
1243 
1244 
1245 
1246 template <int dim, typename Number>
1247 inline
1250  const Tensor<2,dim,Number> &F)
1251 {
1252  return Number(determinant(F))*Contravariant::pull_back(t,F);
1253 }
1254 
1255 
1256 
1257 template <int dim, typename Number>
1258 inline
1261  const Tensor<2,dim,Number> &F)
1262 {
1263  return Number(determinant(F))*Contravariant::pull_back(t,F);
1264 }
1265 
1266 
1267 
1268 template <int dim, typename Number>
1269 inline
1272  const Tensor<2,dim,Number> &F)
1273 {
1274  return Number(determinant(F))*Contravariant::pull_back(h,F);
1275 }
1276 
1277 
1278 
1279 template <int dim, typename Number>
1280 inline
1283  const Tensor<2,dim,Number> &F)
1284 {
1285  return Number(determinant(F))*Contravariant::pull_back(h,F);
1286 }
1287 
1288 
1289 
1290 template<int dim, typename Number>
1291 inline Tensor<1,dim,Number>
1293  const Tensor<2,dim,Number> &F)
1294 {
1295  return cofactor(F)*N;
1296 }
1297 
1298 #endif // DOXYGEN
1299 
1300 DEAL_II_NAMESPACE_CLOSE
1301 
1302 #endif
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
Tensor< 1, dim, Number > nansons_formula(const Tensor< 1, dim, Number > &N, const Tensor< 2, dim, Number > &F)
Definition: point.h:89
Tensor< 2, dim, Number > F(const Tensor< 2, dim, Number > &Grad_u)
Tensor< 2, dim, Number > cofactor(const Tensor< 2, dim, Number > &t)
Definition: tensor.h:1935
Tensor< 1, dim, Number > push_forward(const Tensor< 1, dim, Number > &V, const Tensor< 2, dim, Number > &F)
Tensor< 1, dim, Number > pull_back(const Tensor< 1, dim, Number > &v, const Tensor< 2, dim, Number > &F)
static ::ExceptionBase & ExcMessage(std::string arg1)
#define Assert(cond, exc)
Definition: exceptions.h:313
Tensor< 1, dim, Number > push_forward(const Tensor< 1, dim, Number > &V, const Tensor< 2, dim, Number > &F)
Tensor< 2, 2, Number > rotation_matrix_2d(const Number &angle)
Tensor< 1, dim, Number > pull_back(const Tensor< 1, dim, Number > &v, const Tensor< 2, dim, Number > &F)
Number determinant(const SymmetricTensor< 2, dim, Number > &t)
Definition: mpi.h:41
Tensor< 1, dim, Number > push_forward(const Tensor< 1, dim, Number > &V, const Tensor< 2, dim, Number > &F)
SymmetricTensor< 2, dim, Number > invert(const SymmetricTensor< 2, dim, Number > &)
Tensor< 1, dim, Number > pull_back(const Tensor< 1, dim, Number > &v, const Tensor< 2, dim, Number > &F)
DerivativeForm< 1, spacedim, dim, Number > transpose(const DerivativeForm< 1, dim, spacedim, Number > &DF)
Tensor< 2, 3, Number > rotation_matrix_3d(const Point< 3, Number > &axis, const Number &angle)
Tensor< 2, dim, Number > l(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)