16 #ifndef dealii_symmetric_tensor_h
17 #define dealii_symmetric_tensor_h
33 template <
int rank,
int dim,
typename Number =
double>
47 template <
int dim,
typename Number =
double>
79 template <
int dim,
typename Number =
double>
120 template <
int dim,
typename Number =
double>
124 template <
int dim,
typename Number>
128 template <
int dim,
typename Number>
141 template <
int dim2,
typename Number>
155 template <
int dim,
typename Number>
172 template <
int dim,
typename Number>
184 template <
int rank,
int dim,
typename T,
typename U>
190 std::complex<typename ProductType<T, U>::type>>;
193 template <
int rank,
int dim,
typename T,
typename U>
200 std::complex<typename ProductType<T, U>::type>>;
203 template <
typename T,
int rank,
int dim,
typename U>
209 std::complex<typename ProductType<T, U>::type>>;
212 template <
int rank,
int dim,
typename T,
typename U>
219 std::complex<typename ProductType<T, U>::type>>;
227 namespace SymmetricTensorImplementation
233 template <
int rank,
int dim,
typename Number>
241 namespace SymmetricTensorAccessors
251 const unsigned int new_index,
252 const unsigned int position)
259 return {previous_indices[0], new_index};
272 const unsigned int new_index,
273 const unsigned int position)
285 return {previous_indices[0],
290 return {previous_indices[0],
295 return {previous_indices[0],
316 typename OtherNumber = Number>
331 template <
int dim,
typename Number,
typename OtherNumber>
351 template <
int rank,
int dim,
typename Number>
357 template <
int dim,
typename Number>
364 static const unsigned int n_independent_components =
365 (dim * dim + dim) / 2;
378 template <
int dim,
typename Number>
386 static const unsigned int n_rank2_components = (dim * dim + dim) / 2;
391 static const unsigned int n_independent_components =
392 (n_rank2_components *
410 template <
int rank,
int dim,
bool constness,
typename Number>
419 template <
int rank,
int dim,
typename Number>
433 template <
int rank,
int dim,
typename Number>
474 template <
int rank,
int dim,
bool constness,
int P,
typename Number>
518 constexpr
Accessor<rank, dim, constness, P - 1, Number>
524 constexpr
Accessor<rank, dim, constness, P - 1, Number>
536 template <
int,
int,
typename>
537 friend class ::SymmetricTensor;
538 template <
int,
int,
bool,
int,
typename>
540 friend class ::SymmetricTensor<rank, dim, Number>;
541 friend class Accessor<rank, dim, constness, P + 1, Number>;
553 template <
int rank,
int dim,
bool constness,
typename Number>
618 template <
int,
int,
typename>
619 friend class ::SymmetricTensor;
620 template <
int,
int,
bool,
int,
typename>
622 friend class ::SymmetricTensor<rank, dim, Number>;
623 friend class SymmetricTensorAccessors::
624 Accessor<rank, dim, constness, 2, Number>;
703 template <int rank_, int dim, typename Number>
707 static_assert(rank_ % 2 == 0,
"A SymmetricTensor must have even rank!");
717 static constexpr
unsigned int dimension = dim;
722 static const unsigned int rank = rank_;
729 static constexpr
unsigned int n_independent_components =
731 n_independent_components;
752 template <
typename OtherNumber>
777 template <
typename OtherNumber>
836 template <
typename OtherNumber>
870 template <
typename OtherNumber>
877 template <
typename OtherNumber>
885 template <
typename OtherNumber>
892 template <
typename OtherNumber>
954 template <
typename OtherNumber>
963 template <
typename OtherNumber>
977 constexpr
const Number &
984 constexpr internal::SymmetricTensorAccessors::
985 Accessor<rank_, dim,
true, rank_ - 1, Number>
992 constexpr internal::SymmetricTensorAccessors::
993 Accessor<rank_, dim,
false, rank_ - 1, Number>
1001 constexpr
const Number &
1018 constexpr
const Number &
1049 static constexpr
unsigned int
1079 static constexpr std::size_t
1087 template <
class Archive>
1111 template <
int,
int,
typename>
1115 template <
int dim2,
typename Number2>
1116 friend constexpr Number2
1119 template <
int dim2,
typename Number2>
1123 template <
int dim2,
typename Number2>
1127 template <
int dim2,
typename Number2>
1131 template <
int dim2,
typename Number2>
1135 template <
int dim2,
typename Number2>
1142 Inverse<2, dim, Number>;
1145 Inverse<4, dim, Number>;
1156 template <int rank, int dim, typename Number>
1159 template <int rank_, int dim, typename Number>
1160 constexpr unsigned int
1165 namespace SymmetricTensorAccessors
1167 template <
int rank_,
int dim,
bool constness,
int P,
typename Number>
1178 template <
int rank_,
int dim,
bool constness,
int P,
typename Number>
1180 Accessor<rank_, dim, constness, P - 1, Number>
1181 Accessor<rank_, dim, constness, P, Number>::operator[](
1182 const unsigned int i)
1184 return Accessor<rank_, dim, constness, P - 1, Number>(
1185 tensor,
merge(previous_indices, i, rank_ - P));
1190 template <
int rank_,
int dim,
bool constness,
int P,
typename Number>
1192 Accessor<rank_, dim, constness, P - 1, Number>
1193 Accessor<rank_, dim, constness, P, Number>::operator[](
1194 const unsigned int i)
const
1196 return Accessor<rank_, dim, constness, P - 1, Number>(
1197 tensor,
merge(previous_indices, i, rank_ - P));
1202 template <
int rank_,
int dim,
bool constness,
typename Number>
1204 Accessor<rank_, dim, constness, 1, Number>::Accessor(
1205 tensor_type & tensor,
1208 , previous_indices(previous_indices)
1213 template <
int rank_,
int dim,
bool constness,
typename Number>
1215 typename Accessor<rank_, dim, constness, 1, Number>::reference
1216 Accessor<rank_, dim, constness, 1, Number>::operator[](
1217 const unsigned int i)
1219 return tensor(
merge(previous_indices, i, rank_ - 1));
1223 template <
int rank_,
int dim,
bool constness,
typename Number>
1225 typename Accessor<rank_, dim, constness, 1, Number>::reference
1226 Accessor<rank_, dim, constness, 1, Number>::operator[](
1227 const unsigned int i)
const
1229 return tensor(
merge(previous_indices, i, rank_ - 1));
1236 template <
int rank_,
int dim,
typename Number>
1237 template <
typename OtherNumber>
1242 static_assert(rank == 2,
"This function is only implemented for rank==2");
1243 for (
unsigned int d = 0;
d < dim; ++
d)
1244 for (
unsigned int e = 0;
e <
d; ++
e)
1246 ExcMessage(
"The incoming Tensor must be exactly symmetric."));
1248 for (
unsigned int d = 0;
d < dim; ++
d)
1251 for (
unsigned int d = 0, c = 0;
d < dim; ++
d)
1252 for (
unsigned int e =
d + 1;
e < dim; ++
e, ++c)
1253 data[dim + c] = t[
d][
e];
1258 template <
int rank_,
int dim,
typename Number>
1259 template <
typename OtherNumber>
1263 : data(initializer.data)
1268 template <
int rank_,
int dim,
typename Number>
1271 const Number (&array)[n_independent_components])
1273 *reinterpret_cast<const typename base_tensor_type::array_type *>(array))
1276 Assert(
sizeof(
typename base_tensor_type::array_type) ==
sizeof(array),
1282 template <
int rank_,
int dim,
typename Number>
1283 template <
typename OtherNumber>
1294 template <
int rank_,
int dim,
typename Number>
1299 ExcMessage(
"Only assignment with zero is allowed"));
1310 namespace SymmetricTensorImplementation
1312 template <
int dim,
typename Number>
1313 constexpr
inline DEAL_II_ALWAYS_INLINE ::Tensor<2, dim, Number>
1314 convert_to_tensor(const ::SymmetricTensor<2, dim, Number> &s)
1319 for (
unsigned int d = 0;
d < dim; ++
d)
1320 t[
d][
d] = s.access_raw_entry(
d);
1323 for (
unsigned int d = 0, c = 0;
d < dim; ++
d)
1324 for (
unsigned int e =
d + 1;
e < dim; ++
e, ++c)
1326 t[
d][
e] = s.access_raw_entry(dim + c);
1327 t[
e][
d] = s.access_raw_entry(dim + c);
1333 template <
int dim,
typename Number>
1334 constexpr ::Tensor<4, dim, Number>
1335 convert_to_tensor(const ::SymmetricTensor<4, dim, Number> &st)
1342 for (
unsigned int i = 0; i < dim; ++i)
1343 for (
unsigned int j = i; j < dim; ++j)
1344 for (
unsigned int k = 0; k < dim; ++k)
1345 for (
unsigned int l = k;
l < dim; ++
l)
1355 template <
typename Number>
1356 struct Inverse<2, 1, Number>
1358 constexpr
static inline DEAL_II_ALWAYS_INLINE
1359 ::SymmetricTensor<2, 1, Number>
1360 value(const ::SymmetricTensor<2, 1, Number> &t)
1364 tmp[0][0] = 1.0 / t[0][0];
1371 template <
typename Number>
1372 struct Inverse<2, 2, Number>
1374 constexpr
static inline DEAL_II_ALWAYS_INLINE
1375 ::SymmetricTensor<2, 2, Number>
1376 value(const ::SymmetricTensor<2, 2, Number> &t)
1386 const Number inv_det_t =
1387 1.0 / (t[idx_00] * t[idx_11] - t[idx_01] * t[idx_01]);
1388 tmp[idx_00] = t[idx_11];
1389 tmp[idx_01] = -t[idx_01];
1390 tmp[idx_11] = t[idx_00];
1398 template <
typename Number>
1399 struct Inverse<2, 3, Number>
1401 constexpr static ::SymmetricTensor<2, 3, Number>
1402 value(const ::SymmetricTensor<2, 3, Number> &t)
1446 const Number inv_det_t =
1447 1.0 / (t[idx_00] * t[idx_11] * t[idx_22] -
1448 t[idx_00] * t[idx_12] * t[idx_12] -
1449 t[idx_01] * t[idx_01] * t[idx_22] +
1450 2.0 * t[idx_01] * t[idx_02] * t[idx_12] -
1451 t[idx_02] * t[idx_02] * t[idx_11]);
1452 tmp[idx_00] = t[idx_11] * t[idx_22] - t[idx_12] * t[idx_12];
1453 tmp[idx_01] = -t[idx_01] * t[idx_22] + t[idx_02] * t[idx_12];
1454 tmp[idx_02] = t[idx_01] * t[idx_12] - t[idx_02] * t[idx_11];
1455 tmp[idx_11] = t[idx_00] * t[idx_22] - t[idx_02] * t[idx_02];
1456 tmp[idx_12] = -t[idx_00] * t[idx_12] + t[idx_01] * t[idx_02];
1457 tmp[idx_22] = t[idx_00] * t[idx_11] - t[idx_01] * t[idx_01];
1465 template <
typename Number>
1466 struct Inverse<4, 1, Number>
1468 constexpr
static inline ::SymmetricTensor<4, 1, Number>
1469 value(const ::SymmetricTensor<4, 1, Number> &t)
1472 tmp.
data[0][0] = 1.0 / t.data[0][0];
1478 template <
typename Number>
1479 struct Inverse<4, 2, Number>
1481 constexpr
static inline ::SymmetricTensor<4, 2, Number>
1482 value(const ::SymmetricTensor<4, 2, Number> &t)
1508 const Number t4 = t.
data[0][0] * t.data[1][1],
1509 t6 = t.data[0][0] * t.data[1][2],
1510 t8 = t.data[0][1] * t.data[1][0],
1511 t00 = t.data[0][2] * t.data[1][0],
1512 t01 = t.data[0][1] * t.data[2][0],
1513 t04 = t.data[0][2] * t.data[2][0],
1514 t07 = 1.0 / (t4 * t.data[2][2] - t6 * t.data[2][1] -
1515 t8 * t.data[2][2] + t00 * t.data[2][1] +
1516 t01 * t.data[1][2] - t04 * t.data[1][1]);
1518 (t.data[1][1] * t.data[2][2] - t.data[1][2] * t.data[2][1]) * t07;
1520 -(t.data[0][1] * t.data[2][2] - t.data[0][2] * t.data[2][1]) * t07;
1522 -(-t.data[0][1] * t.data[1][2] + t.data[0][2] * t.data[1][1]) * t07;
1524 -(t.data[1][0] * t.data[2][2] - t.data[1][2] * t.data[2][0]) * t07;
1525 tmp.
data[1][1] = (t.data[0][0] * t.data[2][2] - t04) * t07;
1526 tmp.
data[1][2] = -(t6 - t00) * t07;
1528 -(-t.data[1][0] * t.data[2][1] + t.data[1][1] * t.data[2][0]) * t07;
1529 tmp.
data[2][1] = -(t.data[0][0] * t.data[2][1] - t01) * t07;
1530 tmp.
data[2][2] = (t4 - t8) * t07;
1534 tmp.
data[2][0] /= 2;
1535 tmp.
data[2][1] /= 2;
1536 tmp.
data[0][2] /= 2;
1537 tmp.
data[1][2] /= 2;
1538 tmp.
data[2][2] /= 4;
1545 template <
typename Number>
1546 struct Inverse<4, 3, Number>
1548 static ::SymmetricTensor<4, 3, Number>
1549 value(const ::SymmetricTensor<4, 3, Number> &t)
1559 const unsigned int N = 6;
1565 for (
unsigned int i = 0; i <
N; ++i)
1567 const Number typical_diagonal_element =
1568 diagonal_sum /
static_cast<double>(
N);
1569 (void)typical_diagonal_element;
1572 for (
unsigned int i = 0; i <
N; ++i)
1575 for (
unsigned int j = 0; j <
N; ++j)
1581 for (
unsigned int i = j + 1; i <
N; ++i)
1589 Assert(
max > 1.e-16 * typical_diagonal_element,
1590 ExcMessage(
"This tensor seems to be noninvertible"));
1595 for (
unsigned int k = 0; k <
N; ++k)
1602 const Number hr = 1. / tmp.
data[j][j];
1603 tmp.
data[j][j] = hr;
1604 for (
unsigned int k = 0; k <
N; ++k)
1608 for (
unsigned int i = 0; i <
N; ++i)
1612 tmp.
data[i][k] -= tmp.
data[i][j] * tmp.
data[j][k] * hr;
1615 for (
unsigned int i = 0; i <
N; ++i)
1617 tmp.
data[i][j] *= hr;
1618 tmp.
data[j][i] *= -hr;
1620 tmp.
data[j][j] = hr;
1625 for (
unsigned int i = 0; i <
N; ++i)
1627 for (
unsigned int k = 0; k <
N; ++k)
1628 hv[p[k]] = tmp.
data[i][k];
1629 for (
unsigned int k = 0; k <
N; ++k)
1630 tmp.
data[i][k] = hv[k];
1635 for (
unsigned int i = 3; i < 6; ++i)
1636 for (
unsigned int j = 0; j < 3; ++j)
1637 tmp.
data[i][j] /= 2;
1639 for (
unsigned int i = 0; i < 3; ++i)
1640 for (
unsigned int j = 3; j < 6; ++j)
1641 tmp.
data[i][j] /= 2;
1643 for (
unsigned int i = 3; i < 6; ++i)
1644 for (
unsigned int j = 3; j < 6; ++j)
1645 tmp.
data[i][j] /= 4;
1656 template <
int rank_,
int dim,
typename Number>
1661 return internal::SymmetricTensorImplementation::convert_to_tensor(*
this);
1666 template <
int rank_,
int dim,
typename Number>
1671 return data == t.
data;
1676 template <
int rank_,
int dim,
typename Number>
1681 return data != t.
data;
1686 template <
int rank_,
int dim,
typename Number>
1687 template <
typename OtherNumber>
1698 template <
int rank_,
int dim,
typename Number>
1699 template <
typename OtherNumber>
1710 template <
int rank_,
int dim,
typename Number>
1711 template <
typename OtherNumber>
1721 template <
int rank_,
int dim,
typename Number>
1722 template <
typename OtherNumber>
1732 template <
int rank_,
int dim,
typename Number>
1743 template <
int rank_,
int dim,
typename Number>
1752 template <
int rank_,
int dim,
typename Number>
1753 constexpr std::size_t
1765 template <
int dim,
typename Number,
typename OtherNumber = Number>
1769 perform_double_contraction(
1770 const typename SymmetricTensorAccessors::StorageType<2, dim, Number>::
1771 base_tensor_type &data,
1772 const typename SymmetricTensorAccessors::
1773 StorageType<2, dim, OtherNumber>::base_tensor_type &sdata)
1781 return data[0] * sdata[0];
1786 result_type
sum = data[dim] * sdata[dim];
1787 for (
unsigned int d = dim + 1;
d < (dim * (dim + 1) / 2); ++
d)
1788 sum += data[
d] * sdata[
d];
1792 for (
unsigned int d = 0;
d < dim; ++
d)
1793 sum += data[
d] * sdata[
d];
1800 template <
int dim,
typename Number,
typename OtherNumber = Number>
1804 perform_double_contraction(
1805 const typename SymmetricTensorAccessors::StorageType<4, dim, Number>::
1806 base_tensor_type &data,
1807 const typename SymmetricTensorAccessors::
1808 StorageType<2, dim, OtherNumber>::base_tensor_type &sdata)
1815 const unsigned int data_dim = SymmetricTensorAccessors::
1816 StorageType<2, dim, value_type>::n_independent_components;
1817 value_type tmp[data_dim]{};
1818 for (
unsigned int i = 0; i < data_dim; ++i)
1820 perform_double_contraction<dim, Number, OtherNumber>(data[i], sdata);
1821 return result_type(tmp);
1826 template <
int dim,
typename Number,
typename OtherNumber = Number>
1828 typename SymmetricTensorAccessors::StorageType<
1834 perform_double_contraction(
1835 const typename SymmetricTensorAccessors::StorageType<2, dim, Number>::
1836 base_tensor_type &data,
1837 const typename SymmetricTensorAccessors::
1838 StorageType<4, dim, OtherNumber>::base_tensor_type &sdata)
1842 using base_tensor_type =
typename SymmetricTensorAccessors::
1843 StorageType<2, dim, value_type>::base_tensor_type;
1845 base_tensor_type tmp;
1846 for (
unsigned int i = 0; i < tmp.dimension; ++i)
1849 value_type
sum = data[dim] * sdata[dim][i];
1850 for (
unsigned int d = dim + 1;
d < (dim * (dim + 1) / 2); ++
d)
1851 sum += data[
d] * sdata[
d][i];
1855 for (
unsigned int d = 0;
d < dim; ++
d)
1856 sum += data[
d] * sdata[
d][i];
1864 template <
int dim,
typename Number,
typename OtherNumber = Number>
1866 typename SymmetricTensorAccessors::StorageType<
1872 perform_double_contraction(
1873 const typename SymmetricTensorAccessors::StorageType<4, dim, Number>::
1874 base_tensor_type &data,
1875 const typename SymmetricTensorAccessors::
1876 StorageType<4, dim, OtherNumber>::base_tensor_type &sdata)
1880 using base_tensor_type =
typename SymmetricTensorAccessors::
1881 StorageType<4, dim, value_type>::base_tensor_type;
1883 const unsigned int data_dim = SymmetricTensorAccessors::
1884 StorageType<2, dim, value_type>::n_independent_components;
1885 base_tensor_type tmp;
1886 for (
unsigned int i = 0; i < data_dim; ++i)
1887 for (
unsigned int j = 0; j < data_dim; ++j)
1890 for (
unsigned int d = dim;
d < (dim * (dim + 1) / 2); ++
d)
1891 tmp[i][j] += data[i][
d] * sdata[
d][j];
1892 tmp[i][j] += tmp[i][j];
1895 for (
unsigned int d = 0;
d < dim; ++
d)
1896 tmp[i][j] += data[i][
d] * sdata[
d][j];
1905 template <
int rank_,
int dim,
typename Number>
1906 template <
typename OtherNumber>
1917 return internal::perform_double_contraction<dim, Number, OtherNumber>(data,
1923 template <
int rank_,
int dim,
typename Number>
1924 template <
typename OtherNumber>
1933 internal::perform_double_contraction<dim, Number, OtherNumber>(data,
1950 template <
int dim,
typename Number>
1953 typename SymmetricTensorAccessors::
1954 StorageType<2, dim, Number>::base_tensor_type &data)
1962 if (indices[0] == indices[1])
1963 return data[indices[0]];
1970 Assert(((indices[0] == 1) && (indices[1] == 0)) ||
1971 ((indices[0] == 0) && (indices[1] == 1)),
1980 for (
unsigned int d = 0, c = 0;
d < dim; ++
d)
1981 for (
unsigned int e =
d + 1;
e < dim; ++
e, ++c)
1982 if ((sorted_indices[0] ==
d) && (sorted_indices[1] ==
e))
1983 return data[dim + c];
1997 template <
int dim,
typename Number>
2000 const typename SymmetricTensorAccessors::
2001 StorageType<2, dim, Number>::base_tensor_type &data)
2009 if (indices[0] == indices[1])
2010 return data[indices[0]];
2017 Assert(((indices[0] == 1) && (indices[1] == 0)) ||
2018 ((indices[0] == 0) && (indices[1] == 1)),
2027 for (
unsigned int d = 0, c = 0;
d < dim; ++
d)
2028 for (
unsigned int e =
d + 1;
e < dim; ++
e, ++c)
2029 if ((sorted_indices[0] ==
d) && (sorted_indices[1] ==
e))
2030 return data[dim + c];
2044 template <
int dim,
typename Number>
2045 constexpr
inline Number &
2047 typename SymmetricTensorAccessors::
2048 StorageType<4, dim, Number>::base_tensor_type &data)
2062 constexpr std::size_t base_index[2][2] = {{0, 2}, {2, 1}};
2063 return data[base_index[indices[0]][indices[1]]]
2064 [base_index[indices[2]][indices[3]]];
2073 constexpr std::size_t base_index[3][3] = {{0, 3, 4},
2076 return data[base_index[indices[0]][indices[1]]]
2077 [base_index[indices[2]][indices[3]]];
2092 template <
int dim,
typename Number>
2095 const typename SymmetricTensorAccessors::
2096 StorageType<4, dim, Number>::base_tensor_type &data)
2110 constexpr std::size_t base_index[2][2] = {{0, 2}, {2, 1}};
2111 return data[base_index[indices[0]][indices[1]]]
2112 [base_index[indices[2]][indices[3]]];
2121 constexpr std::size_t base_index[3][3] = {{0, 3, 4},
2124 return data[base_index[indices[0]][indices[1]]]
2125 [base_index[indices[2]][indices[3]]];
2143 template <
int rank_,
int dim,
typename Number>
2148 for (
unsigned int r = 0; r < rank; ++r)
2150 return internal::symmetric_tensor_access<dim, Number>(indices, data);
2155 template <
int rank_,
int dim,
typename Number>
2160 for (
unsigned int r = 0; r < rank; ++r)
2162 return internal::symmetric_tensor_access<dim, Number>(indices, data);
2169 namespace SymmetricTensorImplementation
2171 template <
int rank_>
2173 get_partially_filled_indices(
const unsigned int row,
2174 const std::integral_constant<int, 2> &)
2180 template <
int rank_>
2182 get_partially_filled_indices(
const unsigned int row,
2183 const std::integral_constant<int, 4> &)
2194 template <
int rank_,
int dim,
typename Number>
2196 Accessor<rank_, dim,
true, rank_ - 1, Number>
2199 return internal::SymmetricTensorAccessors::
2200 Accessor<rank_, dim,
true, rank_ - 1, Number>(
2202 internal::SymmetricTensorImplementation::get_partially_filled_indices<
2203 rank_>(row, std::integral_constant<int, rank_>()));
2208 template <
int rank_,
int dim,
typename Number>
2210 Accessor<rank_, dim,
false, rank_ - 1, Number>
2213 return internal::SymmetricTensorAccessors::
2214 Accessor<rank_, dim,
false, rank_ - 1, Number>(
2216 internal::SymmetricTensorImplementation::get_partially_filled_indices<
2217 rank_>(row, std::integral_constant<int, rank_>()));
2222 template <
int rank_,
int dim,
typename Number>
2227 return operator()(indices);
2232 template <
int rank_,
int dim,
typename Number>
2237 return operator()(indices);
2242 template <
int rank_,
int dim,
typename Number>
2246 return std::addressof(this->access_raw_entry(0));
2251 template <
int rank_,
int dim,
typename Number>
2252 inline const Number *
2255 return std::addressof(this->access_raw_entry(0));
2260 template <
int rank_,
int dim,
typename Number>
2264 return begin_raw() + n_independent_components;
2269 template <
int rank_,
int dim,
typename Number>
2270 inline const Number *
2273 return begin_raw() + n_independent_components;
2280 namespace SymmetricTensorImplementation
2282 template <
int dim,
typename Number>
2283 constexpr
unsigned int
2284 entry_to_indices(const ::SymmetricTensor<2, dim, Number> &,
2285 const unsigned int index)
2291 template <
int dim,
typename Number>
2292 constexpr ::TableIndices<2>
2293 entry_to_indices(const ::SymmetricTensor<4, dim, Number> &,
2294 const unsigned int index)
2305 template <
int rank_,
int dim,
typename Number>
2306 constexpr
inline const Number &
2308 const unsigned int index)
const
2311 return data[internal::SymmetricTensorImplementation::entry_to_indices(*
this,
2317 template <
int rank_,
int dim,
typename Number>
2318 constexpr
inline Number &
2322 return data[internal::SymmetricTensorImplementation::entry_to_indices(*
this,
2330 template <
int dim,
typename Number>
2332 compute_norm(
const typename SymmetricTensorAccessors::
2333 StorageType<2, dim, Number>::base_tensor_type &data)
2360 for (
unsigned int d = 0;
d < dim; ++
d)
2363 for (
unsigned int d = dim;
d < (dim * dim + dim) / 2; ++
d)
2367 return sqrt(return_value);
2374 template <
int dim,
typename Number>
2376 compute_norm(
const typename SymmetricTensorAccessors::
2377 StorageType<4, dim, Number>::base_tensor_type &data)
2391 const unsigned int n_independent_components = data.dimension;
2393 for (
unsigned int i = 0; i < dim; ++i)
2394 for (
unsigned int j = 0; j < dim; ++j)
2397 for (
unsigned int i = 0; i < dim; ++i)
2398 for (
unsigned int j = dim; j < n_independent_components; ++j)
2401 for (
unsigned int i = dim; i < n_independent_components; ++i)
2402 for (
unsigned int j = 0; j < dim; ++j)
2405 for (
unsigned int i = dim; i < n_independent_components; ++i)
2406 for (
unsigned int j = dim; j < n_independent_components; ++j)
2410 return sqrt(return_value);
2419 template <
int rank_,
int dim,
typename Number>
2423 return internal::compute_norm<dim, Number>(data);
2430 namespace SymmetricTensorImplementation
2453 constexpr
unsigned int table[2][2] = {{0, 2}, {2, 1}};
2454 return table[indices[0]][indices[1]];
2459 constexpr
unsigned int table[3][3] = {{0, 3, 4},
2462 return table[indices[0]][indices[1]];
2467 constexpr
unsigned int table[4][4] = {{0, 4, 5, 6},
2471 return table[indices[0]][indices[1]];
2477 if (indices[0] == indices[1])
2481 sorted_indices.sort();
2483 for (
unsigned int d = 0, c = 0;
d < dim; ++
d)
2484 for (
unsigned int e =
d + 1;
e < dim; ++
e, ++c)
2485 if ((sorted_indices[0] ==
d) && (sorted_indices[1] ==
e))
2501 template <
int dim,
int rank_>
2502 constexpr
inline unsigned int
2513 template <
int rank_,
int dim,
typename Number>
2514 constexpr
unsigned int
2518 return internal::SymmetricTensorImplementation::component_to_unrolled_index<
2526 namespace SymmetricTensorImplementation
2538 const std::integral_constant<int, 2> &)
2576 for (
unsigned int d = 0, c = dim;
d < dim; ++
d)
2577 for (
unsigned int e =
d + 1;
e < dim; ++
e, ++c)
2595 template <
int dim,
int rank_>
2596 constexpr
inline std::enable_if_t<rank_ != 2, TableIndices<rank_>>
2598 const std::integral_constant<int, rank_> &)
2607 n_independent_components));
2615 template <
int rank_,
int dim,
typename Number>
2618 const unsigned int i)
2620 return internal::SymmetricTensorImplementation::unrolled_to_component_indices<
2621 dim>(i, std::integral_constant<int, rank_>());
2626 template <
int rank_,
int dim,
typename Number>
2627 template <
class Archive>
2652 template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2677 template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2697 template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2714 template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2731 template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2748 template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2759 template <
int dim,
typename Number>
2775 return (tmp + tmp + t.
data[0] * t.
data[1] * t.
data[2] -
2799 template <
int dim,
typename Number>
2808 template <
int dim,
typename Number>
2812 Number t =
d.data[0];
2813 for (
unsigned int i = 1; i < dim; ++i)
2830 template <
int dim,
typename Number>
2849 template <
typename Number>
2876 template <
typename Number>
2880 return t[0][0] * t[1][1] - t[0][1] * t[0][1];
2893 template <
typename Number>
2897 return (t[0][0] * t[1][1] + t[1][1] * t[2][2] + t[2][2] * t[0][0] -
2898 t[0][1] * t[0][1] - t[0][2] * t[0][2] - t[1][2] * t[1][2]);
2910 template <
typename Number>
2911 std::array<Number, 1>
2938 template <
typename Number>
2939 std::array<Number, 2>
2966 template <
typename Number>
2967 std::array<Number, 3>
2974 namespace SymmetricTensorImplementation
3013 template <
int dim,
typename Number>
3017 std::array<Number, dim> &
d,
3018 std::array<Number, dim - 1> &
e);
3061 template <
int dim,
typename Number>
3062 std::array<std::pair<Number, Tensor<1, dim, Number>>, dim>
3106 template <
int dim,
typename Number>
3107 std::array<std::pair<Number, Tensor<1, dim, Number>>, dim>
3125 template <
typename Number>
3126 std::array<std::pair<Number, Tensor<1, 2, Number>>, 2>
3163 template <
typename Number>
3164 std::array<std::pair<Number, Tensor<1, 3, Number>>, 3>
3171 template <
int dim,
typename Number>
3178 return lhs.first > rhs.first;
3281 template <
int dim,
typename Number>
3282 std::array<std::pair<Number, Tensor<1, dim, Number>>,
3283 std::integral_constant<int, dim>::value>
3298 template <
int rank_,
int dim,
typename Number>
3307 template <
int dim,
typename Number>
3314 const Number tr =
trace(t) / dim;
3315 for (
unsigned int i = 0; i < dim; ++i)
3323 template <
int dim,
typename Number>
3343 for (
unsigned int d = 0;
d < dim; ++
d)
3351 template <
int dim,
typename Number>
3358 for (
unsigned int i = 0; i < dim; ++i)
3359 for (
unsigned int j = 0; j < dim; ++j)
3368 for (
unsigned int i = dim;
3369 i < internal::SymmetricTensorAccessors::StorageType<4, dim, Number>::
3379 template <
int dim,
typename Number>
3386 for (
unsigned int i = 0; i < dim; ++i)
3394 for (
unsigned int i = dim;
3395 i < internal::SymmetricTensorAccessors::StorageType<4, dim, Number>::
3414 template <
int dim,
typename Number>
3434 template <
int dim,
typename Number>
3465 template <
int dim,
typename Number>
3473 for (
unsigned int i = 0; i < dim; ++i)
3474 for (
unsigned int j = i; j < dim; ++j)
3475 for (
unsigned int k = 0; k < dim; ++k)
3476 for (
unsigned int l = k;
l < dim; ++
l)
3477 tmp[i][j][k][
l] = t1[i][j] * t2[k][
l];
3491 template <
int dim,
typename Number>
3496 for (
unsigned int d = 0;
d < dim; ++
d)
3497 result[
d][
d] = t[
d][
d];
3500 for (
unsigned int d = 0;
d < dim; ++
d)
3501 for (
unsigned int e =
d + 1;
e < dim; ++
e)
3502 result[
d][
e] = (t[
d][
e] + t[
e][
d]) * half;
3515 template <
int rank_,
int dim,
typename Number>
3533 template <
int rank_,
int dim,
typename Number>
3567 template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
3574 const OtherNumber & factor)
3596 template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
3606 return (t * factor);
3616 template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
3623 const OtherNumber & factor)
3639 template <
int rank_,
int dim>
3656 template <
int rank_,
int dim>
3672 template <
int rank_,
int dim>
3690 template <
int dim,
typename Number,
typename OtherNumber>
3711 template <
int dim,
typename Number,
typename OtherNumber>
3719 for (
unsigned int i = 0; i < dim; ++i)
3720 for (
unsigned int j = 0; j < dim; ++j)
3721 s += t1[i][j] * t2[i][j];
3738 template <
int dim,
typename Number,
typename OtherNumber>
3761 template <
typename Number,
typename OtherNumber>
3768 tmp[0][0] = t[0][0][0][0] * s[0][0];
3787 template <
typename Number,
typename OtherNumber>
3788 constexpr
inline void
3794 tmp[0][0] = t[0][0][0][0] * s[0][0];
3813 template <
typename Number,
typename OtherNumber>
3814 constexpr
inline void
3820 const unsigned int dim = 2;
3822 for (
unsigned int i = 0; i < dim; ++i)
3823 for (
unsigned int j = i; j < dim; ++j)
3824 tmp[i][j] = t[i][j][0][0] * s[0][0] + t[i][j][1][1] * s[1][1] +
3825 2 * t[i][j][0][1] * s[0][1];
3844 template <
typename Number,
typename OtherNumber>
3845 constexpr
inline void
3851 const unsigned int dim = 2;
3853 for (
unsigned int i = 0; i < dim; ++i)
3854 for (
unsigned int j = i; j < dim; ++j)
3855 tmp[i][j] = s[0][0] * t[0][0][i][j] * +s[1][1] * t[1][1][i][j] +
3856 2 * s[0][1] * t[0][1][i][j];
3875 template <
typename Number,
typename OtherNumber>
3876 constexpr
inline void
3882 const unsigned int dim = 3;
3884 for (
unsigned int i = 0; i < dim; ++i)
3885 for (
unsigned int j = i; j < dim; ++j)
3886 tmp[i][j] = t[i][j][0][0] * s[0][0] + t[i][j][1][1] * s[1][1] +
3887 t[i][j][2][2] * s[2][2] + 2 * t[i][j][0][1] * s[0][1] +
3888 2 * t[i][j][0][2] * s[0][2] + 2 * t[i][j][1][2] * s[1][2];
3907 template <
typename Number,
typename OtherNumber>
3908 constexpr
inline void
3914 const unsigned int dim = 3;
3916 for (
unsigned int i = 0; i < dim; ++i)
3917 for (
unsigned int j = i; j < dim; ++j)
3918 tmp[i][j] = s[0][0] * t[0][0][i][j] + s[1][1] * t[1][1][i][j] +
3919 s[2][2] * t[2][2][i][j] + 2 * s[0][1] * t[0][1][i][j] +
3920 2 * s[0][2] * t[0][2][i][j] + 2 * s[1][2] * t[1][2][i][j];
3931 template <
int dim,
typename Number,
typename OtherNumber>
3937 for (
unsigned int i = 0; i < dim; ++i)
3938 for (
unsigned int j = 0; j < dim; ++j)
3939 dest[i] += src1[i][j] * src2[j];
3950 template <
int dim,
typename Number,
typename OtherNumber>
3980 template <
int rank_1,
3984 typename OtherNumber>
3986 typename Tensor<rank_1 + rank_2 - 2,
4016 template <
int rank_1,
4020 typename OtherNumber>
4022 typename Tensor<rank_1 + rank_2 - 2,
4042 template <
int dim,
typename Number>
4043 inline std::ostream &
4051 for (
unsigned int i = 0; i < dim; ++i)
4052 for (
unsigned int j = 0; j < dim; ++j)
4069 template <
int dim,
typename Number>
4070 inline std::ostream &
4078 for (
unsigned int i = 0; i < dim; ++i)
4079 for (
unsigned int j = 0; j < dim; ++j)
4080 for (
unsigned int k = 0; k < dim; ++k)
4081 for (
unsigned int l = 0;
l < dim; ++
l)
4082 tt[i][j][k][
l] = t[i][j][k][
l];
OutputOperator< VectorType > & operator<<(OutputOperator< VectorType > &out, unsigned int step)
constexpr const Number & operator()(const TableIndices< rank_ > &indices) const
constexpr SymmetricTensor< 2, dim, Number > deviator(const SymmetricTensor< 2, dim, Number > &)
constexpr bool operator==(const SymmetricTensor &) const
constexpr Number & operator()(const TableIndices< rank_ > &indices)
constexpr Number first_invariant(const SymmetricTensor< 2, dim, Number > &t)
constexpr void double_contract(SymmetricTensor< 2, 2, typename ProductType< Number, OtherNumber >::type > &tmp, const SymmetricTensor< 2, 2, Number > &s, const SymmetricTensor< 4, 2, OtherNumber > &t)
constexpr void double_contract(SymmetricTensor< 2, 1, typename ProductType< Number, OtherNumber >::type > &tmp, const SymmetricTensor< 4, 1, Number > &t, const SymmetricTensor< 2, 1, OtherNumber > &s)
constexpr ProductType< Number, OtherNumber >::type scalar_product(const Tensor< 2, dim, Number > &t1, const SymmetricTensor< 2, dim, OtherNumber > &t2)
constexpr SymmetricTensor< 4, dim, Number > invert(const SymmetricTensor< 4, dim, Number > &t)
constexpr SymmetricTensor< rank_, dim > operator*(const SymmetricTensor< rank_, dim > &t, const double factor)
constexpr Tensor< 1, dim, typename ProductType< Number, OtherNumber >::type > operator*(const SymmetricTensor< 2, dim, Number > &src1, const Tensor< 1, dim, OtherNumber > &src2)
constexpr SymmetricTensor< 2, dim, Number > symmetrize(const Tensor< 2, dim, Number > &t)
constexpr SymmetricTensor(const Number(&array)[n_independent_components])
constexpr Tensor< rank_1+rank_2 - 2, dim, typename ProductType< Number, OtherNumber >::type >::tensor_type operator*(const Tensor< rank_1, dim, Number > &src1, const SymmetricTensor< rank_2, dim, OtherNumber > &src2)
constexpr SymmetricTensor & operator*=(const OtherNumber &factor)
constexpr const Number & operator[](const TableIndices< rank_ > &indices) const
static constexpr TableIndices< rank_ > unrolled_to_component_indices(const unsigned int i)
constexpr Tensor< rank_, dim, typename ProductType< Number, OtherNumber >::type > operator-(const SymmetricTensor< rank_, dim, Number > &left, const Tensor< rank_, dim, OtherNumber > &right)
constexpr void double_contract(SymmetricTensor< 2, 2, typename ProductType< Number, OtherNumber >::type > &tmp, const SymmetricTensor< 4, 2, Number > &t, const SymmetricTensor< 2, 2, OtherNumber > &s)
static constexpr unsigned int component_to_unrolled_index(const TableIndices< rank_ > &indices)
constexpr Number determinant(const SymmetricTensor< 2, dim, Number > &)
constexpr SymmetricTensor< 2, dim, Number > invert(const SymmetricTensor< 2, dim, Number > &t)
constexpr internal::SymmetricTensorAccessors::Accessor< rank_, dim, false, rank_ - 1, Number > operator[](const unsigned int row)
constexpr SymmetricTensor & operator=(const Number &d)
constexpr Tensor< 1, dim, typename ProductType< Number, OtherNumber >::type > operator*(const Tensor< 1, dim, Number > &src1, const SymmetricTensor< 2, dim, OtherNumber > &src2)
constexpr const Number & access_raw_entry(const unsigned int unrolled_index) const
std::array< Number, 2 > eigenvalues(const SymmetricTensor< 2, 2, Number > &T)
void serialize(Archive &ar, const unsigned int version)
constexpr Tensor< rank_, dim, typename ProductType< Number, OtherNumber >::type > operator-(const Tensor< rank_, dim, Number > &left, const SymmetricTensor< rank_, dim, OtherNumber > &right)
constexpr Number trace(const SymmetricTensor< 2, dim2, Number > &)
std::array< Number, 1 > eigenvalues(const SymmetricTensor< 2, 1, Number > &T)
constexpr numbers::NumberTraits< Number >::real_type norm() const
typename base_tensor_descriptor::base_tensor_type base_tensor_type
constexpr SymmetricTensor< 4, dim, Number > deviator_tensor()
constexpr bool operator!=(const SymmetricTensor &) const
const Number * end_raw() const
constexpr void double_contract(SymmetricTensor< 2, 1, typename ProductType< Number, OtherNumber >::type > &tmp, const SymmetricTensor< 2, 1, Number > &s, const SymmetricTensor< 4, 1, OtherNumber > &t)
constexpr SymmetricTensor< rank_, dim, typename ProductType< OtherNumber, typename EnableIfScalar< Number >::type >::type > operator*(const Number &factor, const SymmetricTensor< rank_, dim, OtherNumber > &t)
constexpr SymmetricTensor< rank_, dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type > operator/(const SymmetricTensor< rank_, dim, Number > &t, const OtherNumber &factor)
static constexpr std::size_t memory_consumption()
constexpr ProductType< Number, OtherNumber >::type scalar_product(const SymmetricTensor< 2, dim, Number > &t1, const Tensor< 2, dim, OtherNumber > &t2)
constexpr Tensor< rank_, dim, typename ProductType< Number, OtherNumber >::type > operator+(const SymmetricTensor< rank_, dim, Number > &left, const Tensor< rank_, dim, OtherNumber > &right)
constexpr SymmetricTensor & operator=(const SymmetricTensor< rank_, dim, OtherNumber > &rhs)
const Number * begin_raw() const
SymmetricTensor(const Tensor< 2, dim, OtherNumber > &t)
constexpr SymmetricTensor< 4, dim, Number > outer_product(const SymmetricTensor< 2, dim, Number > &t1, const SymmetricTensor< 2, dim, Number > &t2)
constexpr SymmetricTensor & operator/=(const OtherNumber &factor)
constexpr SymmetricTensor operator-() const
constexpr SymmetricTensor & operator+=(const SymmetricTensor< rank_, dim, OtherNumber > &)
constexpr SymmetricTensor()=default
constexpr internal::SymmetricTensorAccessors::Accessor< rank_, dim, true, rank_ - 1, Number > operator[](const unsigned int row) const
std::array< std::pair< Number, Tensor< 1, dim, Number > >, std::integral_constant< int, dim >::value > eigenvectors(const SymmetricTensor< 2, dim, Number > &T, const SymmetricTensorEigenvectorMethod method=SymmetricTensorEigenvectorMethod::ql_implicit_shifts)
constexpr Number second_invariant(const SymmetricTensor< 2, 1, Number > &)
constexpr Number third_invariant(const SymmetricTensor< 2, dim, Number > &t)
constexpr SymmetricTensor & operator-=(const SymmetricTensor< rank_, dim, OtherNumber > &)
constexpr SymmetricTensor(const SymmetricTensor< rank_, dim, OtherNumber > &initializer)
constexpr SymmetricTensor< rank_, dim, Number > operator*(const Number &factor, const SymmetricTensor< rank_, dim, Number > &t)
constexpr internal::SymmetricTensorAccessors::double_contraction_result< rank_, 2, dim, Number, OtherNumber >::type operator*(const SymmetricTensor< 2, dim, OtherNumber > &s) const
constexpr SymmetricTensor< rank_, dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type > operator*(const SymmetricTensor< rank_, dim, Number > &t, const OtherNumber &factor)
constexpr ProductType< Number, OtherNumber >::type scalar_product(const SymmetricTensor< 2, dim, Number > &t1, const SymmetricTensor< 2, dim, OtherNumber > &t2)
constexpr Number & access_raw_entry(const unsigned int unrolled_index)
constexpr SymmetricTensor< 4, dim, Number > identity_tensor()
constexpr void double_contract(SymmetricTensor< 2, 3, typename ProductType< Number, OtherNumber >::type > &tmp, const SymmetricTensor< 4, 3, Number > &t, const SymmetricTensor< 2, 3, OtherNumber > &s)
constexpr SymmetricTensor< rank_, dim, typename ProductType< Number, OtherNumber >::type > operator-(const SymmetricTensor< rank_, dim, Number > &left, const SymmetricTensor< rank_, dim, OtherNumber > &right)
constexpr SymmetricTensor< rank_, dim, typename ProductType< Number, OtherNumber >::type > operator+(const SymmetricTensor< rank_, dim, Number > &left, const SymmetricTensor< rank_, dim, OtherNumber > &right)
constexpr Number second_invariant(const SymmetricTensor< 2, 3, Number > &t)
constexpr SymmetricTensor< rank_, dim, Number > operator*(const SymmetricTensor< rank_, dim, Number > &t, const Number &factor)
constexpr SymmetricTensor< rank_, dim, Number > transpose(const SymmetricTensor< rank_, dim, Number > &t)
constexpr SymmetricTensor< rank_, dim > operator*(const double factor, const SymmetricTensor< rank_, dim > &t)
constexpr internal::SymmetricTensorAccessors::double_contraction_result< rank_, 4, dim, Number, OtherNumber >::type operator*(const SymmetricTensor< 4, dim, OtherNumber > &s) const
constexpr Tensor< rank_1+rank_2 - 2, dim, typename ProductType< Number, OtherNumber >::type >::tensor_type operator*(const SymmetricTensor< rank_1, dim, Number > &src1, const Tensor< rank_2, dim, OtherNumber > &src2)
constexpr Tensor< rank_, dim, typename ProductType< Number, OtherNumber >::type > operator+(const Tensor< rank_, dim, Number > &left, const SymmetricTensor< rank_, dim, OtherNumber > &right)
constexpr Number & operator[](const TableIndices< rank_ > &indices)
constexpr Number second_invariant(const SymmetricTensor< 2, 2, Number > &t)
constexpr SymmetricTensor< 2, dim, Number > unit_symmetric_tensor()
constexpr SymmetricTensor< rank_, dim > operator/(const SymmetricTensor< rank_, dim > &t, const double factor)
std::array< Number, 3 > eigenvalues(const SymmetricTensor< 2, 3, Number > &T)
constexpr void double_contract(SymmetricTensor< 2, 3, typename ProductType< Number, OtherNumber >::type > &tmp, const SymmetricTensor< 2, 3, Number > &s, const SymmetricTensor< 4, 3, OtherNumber > &t)
typename AccessorTypes< rank, dim, constness, Number >::reference reference
constexpr reference operator[](const unsigned int) const
const TableIndices< rank > previous_indices
constexpr Accessor(const Accessor &)=default
constexpr Accessor(tensor_type &tensor, const TableIndices< rank > &previous_indices)
constexpr reference operator[](const unsigned int)
typename AccessorTypes< rank, dim, constness, Number >::tensor_type tensor_type
const TableIndices< rank > previous_indices
constexpr Accessor< rank, dim, constness, P - 1, Number > operator[](const unsigned int i) const
typename AccessorTypes< rank, dim, constness, Number >::tensor_type tensor_type
constexpr Accessor< rank, dim, constness, P - 1, Number > operator[](const unsigned int i)
constexpr Accessor(tensor_type &tensor, const TableIndices< rank > &previous_indices)
constexpr Accessor(const Accessor &)=default
typename AccessorTypes< rank, dim, constness, Number >::reference reference
#define DEAL_II_ALWAYS_INLINE
#define DEAL_II_DEPRECATED
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_CONSTEXPR
#define DEAL_II_NAMESPACE_CLOSE
static ::ExceptionBase & ExcInternalError()
#define Assert(cond, exc)
static ::ExceptionBase & ExcNotImplemented()
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcIndexRange(std::size_t arg1, std::size_t arg2, std::size_t arg3)
static ::ExceptionBase & ExcMessage(std::string arg1)
void swap(MemorySpaceData< T, MemorySpace > &u, MemorySpaceData< T, MemorySpace > &v)
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
Tensor< 2, dim, Number > l(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
T sum(const T &t, const MPI_Comm &mpi_communicator)
constexpr TableIndices< 2 > merge(const TableIndices< 2 > &previous_indices, const unsigned int new_index, const unsigned int position)
constexpr TableIndices< 4 > merge(const TableIndices< 4 > &previous_indices, const unsigned int new_index, const unsigned int position)
void tridiagonalize(const ::SymmetricTensor< 2, dim, Number > &A, ::Tensor< 2, dim, Number > &Q, std::array< Number, dim > &d, std::array< Number, dim - 1 > &e)
constexpr bool value_is_zero(const Number &value)
static const unsigned int invalid_unsigned_int
::VectorizedArray< Number, width > sqrt(const ::VectorizedArray< Number, width > &)
typename internal::ProductTypeImpl< typename std::decay< T >::type, typename std::decay< U >::type >::type type
static constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE const T & value(const T &t)
typename ProductType< Number, OtherNumber >::type type
typename ProductType< Number, OtherNumber >::type value_type
::SymmetricTensor< rank1+rank2 - 4, dim, value_type > type
std::pair< Number, Tensor< 1, dim, Number > > EigValsVecs
bool operator()(const EigValsVecs &lhs, const EigValsVecs &rhs)
static real_type abs(const number &x)
constexpr SymmetricTensor< 2, dim, Number > deviator(const SymmetricTensor< 2, dim, Number > &)
constexpr Number determinant(const SymmetricTensor< 2, dim, Number > &)
constexpr Number trace(const SymmetricTensor< 2, dim2, Number > &)
constexpr SymmetricTensor< 4, dim, Number > deviator_tensor()
constexpr SymmetricTensor< 4, dim, Number > identity_tensor()
SymmetricTensorEigenvectorMethod
constexpr SymmetricTensor< 2, dim, Number > unit_symmetric_tensor()