188 template <
int rank,
int dim,
typename T,
typename U>
194 std::complex<typename ProductType<T, U>::type>>;
197 template <
int rank,
int dim,
typename T,
typename U>
204 std::complex<typename ProductType<T, U>::type>>;
207 template <
typename T,
int rank,
int dim,
typename U>
213 std::complex<typename ProductType<T, U>::type>>;
216 template <
int rank,
int dim,
typename T,
typename U>
223 std::complex<typename ProductType<T, U>::type>>;
231 namespace SymmetricTensorImplementation
237 template <
int rank,
int dim,
typename Number>
231 namespace SymmetricTensorImplementation {
…}
245 namespace SymmetricTensorAccessors
256 const unsigned int new_index,
257 const unsigned int position)
264 return {previous_indices[0], new_index};
278 const unsigned int new_index,
279 const unsigned int position)
291 return {previous_indices[0],
296 return {previous_indices[0],
301 return {previous_indices[0],
322 typename OtherNumber = Number>
337 template <
int dim,
typename Number,
typename OtherNumber>
357 template <
int rank,
int dim,
typename Number>
363 template <
int dim,
typename Number>
370 static const unsigned int n_independent_components =
371 (dim * dim + dim) / 2;
384 template <
int dim,
typename Number>
392 static const unsigned int n_rank2_components = (dim * dim + dim) / 2;
397 static const unsigned int n_independent_components =
398 (n_rank2_components *
416 template <
int rank,
int dim,
bool constness,
typename Number>
425 template <
int rank,
int dim,
typename Number>
439 template <
int rank,
int dim,
typename Number>
480 template <
int rank,
int dim,
bool constness,
int P,
typename Number>
527 constexpr Accessor<rank, dim, constness, P - 1, Number>
534 constexpr Accessor<rank, dim, constness, P - 1, Number>
546 template <
int,
int,
typename>
547 friend class ::SymmetricTensor;
548 template <
int,
int,
bool,
int,
typename>
550 friend class ::SymmetricTensor<rank, dim, Number>;
551 friend class Accessor<rank, dim, constness, P + 1, Number>;
563 template <
int rank,
int dim,
bool constness,
typename Number>
632 template <
int,
int,
typename>
633 friend class ::SymmetricTensor;
634 template <
int,
int,
bool,
int,
typename>
636 friend class ::SymmetricTensor<rank, dim, Number>;
637 friend class SymmetricTensorAccessors::
638 Accessor<rank, dim, constness, 2, Number>;
245 namespace SymmetricTensorAccessors {
…}
717template <int rank_, int dim, typename Number>
721 static_assert(rank_ % 2 == 0,
"A SymmetricTensor must have even rank!");
731 static constexpr unsigned int dimension = dim;
736 static const unsigned int rank = rank_;
743 static constexpr unsigned int n_independent_components =
745 n_independent_components;
767 template <
typename OtherNumber>
793 template <
typename OtherNumber>
852 template <
typename OtherNumber>
890 template <
typename OtherNumber>
897 template <
typename OtherNumber>
905 template <
typename OtherNumber>
912 template <
typename OtherNumber>
975 template <
typename OtherNumber>
977 double_contraction_result<rank_, 2, dim, Number, OtherNumber>::type
984 template <
typename OtherNumber>
986 double_contraction_result<rank_, 4, dim, Number, OtherNumber>::type
1000 constexpr const Number &
1008 constexpr internal::SymmetricTensorAccessors::
1009 Accessor<rank_, dim,
true, rank_ - 1, Number>
1017 constexpr internal::SymmetricTensorAccessors::
1018 Accessor<rank_, dim,
false, rank_ - 1, Number>
1027 constexpr const Number &
1046 constexpr const Number &
1118 template <
class Archive>
1142 template <
int,
int,
typename>
1146 template <
int dim2,
typename Number2>
1150 template <
int dim2,
typename Number2>
1154 template <
int dim2,
typename Number2>
1158 template <
int dim2,
typename Number2>
1162 template <
int dim2,
typename Number2>
1166 template <
int dim2,
typename Number2>
1173 Inverse<2, dim, Number>;
1176 Inverse<4, dim, Number>;
1187template <int rank, int dim, typename Number>
1190template <int rank_, int dim, typename Number>
1191constexpr unsigned
int
1196 namespace SymmetricTensorAccessors
1198 template <
int rank_,
int dim,
bool constness,
int P,
typename Number>
1200 Accessor<rank_, dim, constness, P, Number>::Accessor(
1201 tensor_type &tensor,
1204 , previous_indices(previous_indices)
1209 template <
int rank_,
int dim,
bool constness,
int P,
typename Number>
1211 Accessor<rank_, dim, constness, P - 1, Number>
1212 Accessor<rank_, dim, constness, P, Number>::operator[](
1213 const unsigned int i)
1215 return Accessor<rank_, dim, constness, P - 1, Number>(
1216 tensor, merge(previous_indices, i, rank_ - P));
1221 template <
int rank_,
int dim,
bool constness,
int P,
typename Number>
1223 Accessor<rank_, dim, constness, P - 1, Number>
1224 Accessor<rank_, dim, constness, P, Number>::operator[](
1225 const unsigned int i)
const
1227 return Accessor<rank_, dim, constness, P - 1, Number>(
1228 tensor,
merge(previous_indices, i, rank_ - P));
1233 template <
int rank_,
int dim,
bool constness,
typename Number>
1235 Accessor<rank_, dim, constness, 1, Number>::Accessor(
1236 tensor_type &tensor,
1239 , previous_indices(previous_indices)
1244 template <
int rank_,
int dim,
bool constness,
typename Number>
1246 typename Accessor<rank_, dim, constness, 1, Number>::reference
1247 Accessor<rank_, dim, constness, 1, Number>::operator[](
1248 const unsigned int i)
1250 return tensor(
merge(previous_indices, i, rank_ - 1));
1254 template <
int rank_,
int dim,
bool constness,
typename Number>
1256 typename Accessor<rank_, dim, constness, 1, Number>::reference
1257 Accessor<rank_, dim, constness, 1, Number>::operator[](
1258 const unsigned int i)
const
1260 return tensor(
merge(previous_indices, i, rank_ - 1));
1267template <
int rank_,
int dim,
typename Number>
1268template <
typename OtherNumber>
1273 static_assert(rank == 2,
"This function is only implemented for rank==2");
1274 for (
unsigned int d = 0;
d < dim; ++
d)
1275 for (
unsigned int e = 0;
e <
d; ++
e)
1276 Assert(t[d][e] == t[e][d],
1277 ExcMessage(
"The incoming Tensor must be exactly symmetric."));
1279 for (
unsigned int d = 0;
d < dim; ++
d)
1282 for (
unsigned int d = 0, c = 0;
d < dim; ++
d)
1283 for (
unsigned int e = d + 1;
e < dim; ++
e, ++c)
1284 data[dim + c] = t[d][e];
1289template <
int rank_,
int dim,
typename Number>
1290template <
typename OtherNumber>
1294 : data(initializer.data)
1299template <
int rank_,
int dim,
typename Number>
1302 const Number (&array)[n_independent_components])
1304 *reinterpret_cast<const typename base_tensor_type::array_type *>(array))
1307 Assert(
sizeof(
typename base_tensor_type::array_type) ==
sizeof(array),
1313template <
int rank_,
int dim,
typename Number>
1314template <
typename OtherNumber>
1326template <
int rank_,
int dim,
typename Number>
1332 ExcMessage(
"Only assignment with zero is allowed"));
1343 namespace SymmetricTensorImplementation
1345 template <
int dim,
typename Number>
1346 constexpr inline DEAL_II_ALWAYS_INLINE ::Tensor<2, dim, Number>
1347 convert_to_tensor(const ::SymmetricTensor<2, dim, Number> &s)
1352 for (
unsigned int d = 0;
d < dim; ++
d)
1353 t[d][d] = s.access_raw_entry(d);
1356 for (
unsigned int d = 0, c = 0;
d < dim; ++
d)
1357 for (
unsigned int e = d + 1;
e < dim; ++
e, ++c)
1359 t[
d][
e] = s.access_raw_entry(dim + c);
1360 t[
e][
d] = s.access_raw_entry(dim + c);
1366 template <
int dim,
typename Number>
1367 constexpr ::Tensor<4, dim, Number>
1368 convert_to_tensor(const ::SymmetricTensor<4, dim, Number> &st)
1375 for (
unsigned int i = 0; i < dim; ++i)
1376 for (
unsigned int j = i; j < dim; ++j)
1377 for (
unsigned int k = 0; k < dim; ++k)
1378 for (
unsigned int l = k;
l < dim; ++
l)
1388 template <
typename Number>
1389 struct Inverse<2, 1, Number>
1391 constexpr static inline DEAL_II_ALWAYS_INLINE
1392 ::SymmetricTensor<2, 1, Number>
1393 value(const ::SymmetricTensor<2, 1, Number> &t)
1397 tmp[0][0] = 1.0 / t[0][0];
1404 template <
typename Number>
1405 struct Inverse<2, 2, Number>
1407 constexpr static inline DEAL_II_ALWAYS_INLINE
1408 ::SymmetricTensor<2, 2, Number>
1409 value(const ::SymmetricTensor<2, 2, Number> &t)
1419 const Number inv_det_t =
1420 1.0 / (t[idx_00] * t[idx_11] - t[idx_01] * t[idx_01]);
1421 tmp[idx_00] = t[idx_11];
1422 tmp[idx_01] = -t[idx_01];
1423 tmp[idx_11] = t[idx_00];
1431 template <
typename Number>
1432 struct Inverse<2, 3, Number>
1434 constexpr static ::SymmetricTensor<2, 3, Number>
1435 value(const ::SymmetricTensor<2, 3, Number> &t)
1479 const Number inv_det_t =
1480 1.0 / (t[idx_00] * t[idx_11] * t[idx_22] -
1481 t[idx_00] * t[idx_12] * t[idx_12] -
1482 t[idx_01] * t[idx_01] * t[idx_22] +
1483 2.0 * t[idx_01] * t[idx_02] * t[idx_12] -
1484 t[idx_02] * t[idx_02] * t[idx_11]);
1485 tmp[idx_00] = t[idx_11] * t[idx_22] - t[idx_12] * t[idx_12];
1486 tmp[idx_01] = -t[idx_01] * t[idx_22] + t[idx_02] * t[idx_12];
1487 tmp[idx_02] = t[idx_01] * t[idx_12] - t[idx_02] * t[idx_11];
1488 tmp[idx_11] = t[idx_00] * t[idx_22] - t[idx_02] * t[idx_02];
1489 tmp[idx_12] = -t[idx_00] * t[idx_12] + t[idx_01] * t[idx_02];
1490 tmp[idx_22] = t[idx_00] * t[idx_11] - t[idx_01] * t[idx_01];
1498 template <
typename Number>
1499 struct Inverse<4, 1, Number>
1501 constexpr static inline ::SymmetricTensor<4, 1, Number>
1502 value(const ::SymmetricTensor<4, 1, Number> &t)
1505 tmp.
data[0][0] = 1.0 / t.data[0][0];
1511 template <
typename Number>
1512 struct Inverse<4, 2, Number>
1514 constexpr static inline ::SymmetricTensor<4, 2, Number>
1515 value(const ::SymmetricTensor<4, 2, Number> &t)
1541 const Number t4 = t.
data[0][0] * t.data[1][1],
1542 t6 = t.data[0][0] * t.data[1][2],
1543 t8 = t.data[0][1] * t.data[1][0],
1544 t00 = t.data[0][2] * t.data[1][0],
1545 t01 = t.data[0][1] * t.data[2][0],
1546 t04 = t.data[0][2] * t.data[2][0],
1547 t07 = 1.0 / (t4 * t.data[2][2] - t6 * t.data[2][1] -
1548 t8 * t.data[2][2] + t00 * t.data[2][1] +
1549 t01 * t.data[1][2] - t04 * t.data[1][1]);
1551 (t.data[1][1] * t.data[2][2] - t.data[1][2] * t.data[2][1]) * t07;
1553 -(t.data[0][1] * t.data[2][2] - t.data[0][2] * t.data[2][1]) * t07;
1555 -(-t.data[0][1] * t.data[1][2] + t.data[0][2] * t.data[1][1]) * t07;
1557 -(t.data[1][0] * t.data[2][2] - t.data[1][2] * t.data[2][0]) * t07;
1558 tmp.
data[1][1] = (t.data[0][0] * t.data[2][2] - t04) * t07;
1559 tmp.
data[1][2] = -(t6 - t00) * t07;
1561 -(-t.data[1][0] * t.data[2][1] + t.data[1][1] * t.data[2][0]) * t07;
1562 tmp.
data[2][1] = -(t.data[0][0] * t.data[2][1] - t01) * t07;
1563 tmp.
data[2][2] = (t4 - t8) * t07;
1567 tmp.
data[2][0] /= 2;
1568 tmp.
data[2][1] /= 2;
1569 tmp.
data[0][2] /= 2;
1570 tmp.
data[1][2] /= 2;
1571 tmp.
data[2][2] /= 4;
1578 template <
typename Number>
1579 struct Inverse<4, 3, Number>
1581 static ::SymmetricTensor<4, 3, Number>
1582 value(const ::SymmetricTensor<4, 3, Number> &t)
1592 const unsigned int N = 6;
1598 for (
unsigned int i = 0; i < N; ++i)
1600 const Number typical_diagonal_element =
1601 diagonal_sum /
static_cast<double>(N);
1602 (void)typical_diagonal_element;
1605 for (
unsigned int i = 0; i < N; ++i)
1608 for (
unsigned int j = 0; j < N; ++j)
1614 for (
unsigned int i = j + 1; i < N; ++i)
1622 Assert(max > 1.e-16 * typical_diagonal_element,
1623 ExcMessage(
"This tensor seems to be noninvertible"));
1628 for (
unsigned int k = 0; k < N; ++k)
1629 std::swap(tmp.
data[j][k], tmp.
data[r][k]);
1631 std::swap(p[j], p[r]);
1635 const Number hr = 1. / tmp.
data[j][j];
1636 tmp.
data[j][j] = hr;
1637 for (
unsigned int k = 0; k < N; ++k)
1641 for (
unsigned int i = 0; i < N; ++i)
1645 tmp.
data[i][k] -= tmp.
data[i][j] * tmp.
data[j][k] * hr;
1648 for (
unsigned int i = 0; i < N; ++i)
1650 tmp.
data[i][j] *= hr;
1651 tmp.
data[j][i] *= -hr;
1653 tmp.
data[j][j] = hr;
1658 for (
unsigned int i = 0; i < N; ++i)
1660 for (
unsigned int k = 0; k < N; ++k)
1661 hv[p[k]] = tmp.
data[i][k];
1662 for (
unsigned int k = 0; k < N; ++k)
1663 tmp.
data[i][k] = hv[k];
1668 for (
unsigned int i = 3; i < 6; ++i)
1669 for (
unsigned int j = 0; j < 3; ++j)
1670 tmp.
data[i][j] /= 2;
1672 for (
unsigned int i = 0; i < 3; ++i)
1673 for (
unsigned int j = 3; j < 6; ++j)
1674 tmp.
data[i][j] /= 2;
1676 for (
unsigned int i = 3; i < 6; ++i)
1677 for (
unsigned int j = 3; j < 6; ++j)
1678 tmp.
data[i][j] /= 4;
1689template <
int rank_,
int dim,
typename Number>
1694 return internal::SymmetricTensorImplementation::convert_to_tensor(*
this);
1699template <
int rank_,
int dim,
typename Number>
1704 return data == t.
data;
1709template <
int rank_,
int dim,
typename Number>
1714 return data != t.
data;
1719template <
int rank_,
int dim,
typename Number>
1720template <
typename OtherNumber>
1732template <
int rank_,
int dim,
typename Number>
1733template <
typename OtherNumber>
1745template <
int rank_,
int dim,
typename Number>
1746template <
typename OtherNumber>
1757template <
int rank_,
int dim,
typename Number>
1758template <
typename OtherNumber>
1769template <
int rank_,
int dim,
typename Number>
1781template <
int rank_,
int dim,
typename Number>
1790template <
int rank_,
int dim,
typename Number>
1806 template <
int dim,
typename Number,
typename OtherNumber = Number>
1808 typename SymmetricTensorAccessors::
1809 double_contraction_result<2, 2, dim, Number, OtherNumber>::type
1810 perform_double_contraction(
1811 const typename SymmetricTensorAccessors::StorageType<2, dim, Number>::
1812 base_tensor_type &data,
1813 const typename SymmetricTensorAccessors::
1814 StorageType<2, dim, OtherNumber>::base_tensor_type &sdata)
1816 using result_type =
typename SymmetricTensorAccessors::
1817 double_contraction_result<2, 2, dim, Number, OtherNumber>::type;
1822 return data[0] * sdata[0];
1830 result_type
sum = data[dim] * sdata[dim];
1831 for (
unsigned int d = dim + 1;
d < (dim * (dim + 1) / 2); ++
d)
1832 sum += data[d] * sdata[d];
1836 for (
unsigned int d = 0;
d < dim; ++
d)
1837 sum += data[d] * sdata[d];
1848 template <
int dim,
typename Number,
typename OtherNumber = Number>
1850 typename SymmetricTensorAccessors::
1851 double_contraction_result<4, 2, dim, Number, OtherNumber>::type
1852 perform_double_contraction(
1853 const typename SymmetricTensorAccessors::StorageType<4, dim, Number>::
1854 base_tensor_type &data,
1855 const typename SymmetricTensorAccessors::
1856 StorageType<2, dim, OtherNumber>::base_tensor_type &sdata)
1858 using result_type =
typename SymmetricTensorAccessors::
1859 double_contraction_result<4, 2, dim, Number, OtherNumber>::type;
1860 using value_type =
typename SymmetricTensorAccessors::
1861 double_contraction_result<4, 2, dim, Number, OtherNumber>::value_type;
1863 const unsigned int data_dim = SymmetricTensorAccessors::
1864 StorageType<2, dim, value_type>::n_independent_components;
1865 value_type tmp[data_dim]{};
1866 for (
unsigned int i = 0; i < data_dim; ++i)
1868 perform_double_contraction<dim, Number, OtherNumber>(data[i], sdata);
1869 return result_type(tmp);
1878 template <
int dim,
typename Number,
typename OtherNumber = Number>
1880 typename SymmetricTensorAccessors::StorageType<
1883 typename SymmetricTensorAccessors::
1884 double_contraction_result<2, 4, dim, Number, OtherNumber>::value_type>::
1886 perform_double_contraction(
1887 const typename SymmetricTensorAccessors::StorageType<2, dim, Number>::
1888 base_tensor_type &data,
1889 const typename SymmetricTensorAccessors::
1890 StorageType<4, dim, OtherNumber>::base_tensor_type &sdata)
1892 using value_type =
typename SymmetricTensorAccessors::
1893 double_contraction_result<2, 4, dim, Number, OtherNumber>::value_type;
1894 using base_tensor_type =
typename SymmetricTensorAccessors::
1895 StorageType<2, dim, value_type>::base_tensor_type;
1897 base_tensor_type tmp;
1898 for (
unsigned int i = 0; i < tmp.dimension; ++i)
1905 value_type
sum = data[dim] * sdata[dim][i];
1906 for (
unsigned int d = dim + 1;
d < (dim * (dim + 1) / 2); ++
d)
1907 sum += data[d] * sdata[d][i];
1911 for (
unsigned int d = 0;
d < dim; ++
d)
1912 sum += data[d] * sdata[d][i];
1923 template <
int dim,
typename Number,
typename OtherNumber = Number>
1925 typename SymmetricTensorAccessors::StorageType<
1928 typename SymmetricTensorAccessors::
1929 double_contraction_result<4, 4, dim, Number, OtherNumber>::value_type>::
1931 perform_double_contraction(
1932 const typename SymmetricTensorAccessors::StorageType<4, dim, Number>::
1933 base_tensor_type &data,
1934 const typename SymmetricTensorAccessors::
1935 StorageType<4, dim, OtherNumber>::base_tensor_type &sdata)
1937 using value_type =
typename SymmetricTensorAccessors::
1938 double_contraction_result<4, 4, dim, Number, OtherNumber>::value_type;
1939 using base_tensor_type =
typename SymmetricTensorAccessors::
1940 StorageType<4, dim, value_type>::base_tensor_type;
1942 const unsigned int data_dim = SymmetricTensorAccessors::
1943 StorageType<2, dim, value_type>::n_independent_components;
1944 base_tensor_type tmp;
1945 for (
unsigned int i = 0; i < data_dim; ++i)
1946 for (
unsigned int j = 0; j < data_dim; ++j)
1949 for (
unsigned int d = dim;
d < (dim * (dim + 1) / 2); ++
d)
1950 tmp[i][j] += data[i][d] * sdata[d][j];
1951 tmp[i][j] += tmp[i][j];
1954 for (
unsigned int d = 0;
d < dim; ++
d)
1955 tmp[i][j] += data[i][d] * sdata[d][j];
1964template <
int rank_,
int dim,
typename Number>
1965template <
typename OtherNumber>
1967 typename internal::SymmetricTensorAccessors::
1968 double_contraction_result<rank_, 2, dim, Number, OtherNumber>::type
1974 return internal::perform_double_contraction<dim, Number, OtherNumber>(data,
1980template <
int rank_,
int dim,
typename Number>
1981template <
typename OtherNumber>
1983 typename internal::SymmetricTensorAccessors::
1984 double_contraction_result<rank_, 4, dim, Number, OtherNumber>::type
1988 typename internal::SymmetricTensorAccessors::
1989 double_contraction_result<rank_, 4, dim, Number, OtherNumber>::type tmp;
1991 internal::perform_double_contraction<dim, Number, OtherNumber>(data,
2008 namespace SymmetricTensorImplementation
2030 constexpr ::ndarray<unsigned int, 2, 2> table = {
2031 {{{0, 2}}, {{2, 1}}}};
2032 return table[indices[0]][indices[1]];
2036 constexpr ::ndarray<unsigned int, 3, 3> table = {
2037 {{{0, 3, 4}}, {{3, 1, 5}}, {{4, 5, 2}}}};
2038 return table[indices[0]][indices[1]];
2042 constexpr ::ndarray<unsigned int, 4, 4> table = {
2047 return table[indices[0]][indices[1]];
2052 if (indices[0] == indices[1])
2063 for (
unsigned int d = 0;
d < dim; ++
d)
2064 for (
unsigned int e = d + 1;
e < dim; ++
e, ++c)
2065 if ((sorted_indices[0] == d) && (sorted_indices[1] == e))
2081 template <
int dim,
int rank_>
2082 constexpr inline unsigned int
2091 template <
int dim,
typename Number>
2094 typename SymmetricTensorAccessors::
2095 StorageType<2, dim, Number>::base_tensor_type &data)
2103 template <
int dim,
typename Number>
2106 const typename SymmetricTensorAccessors::
2107 StorageType<2, dim, Number>::base_tensor_type &data)
2115 template <
int dim,
typename Number>
2116 constexpr inline Number &
2118 typename SymmetricTensorAccessors::
2119 StorageType<4, dim, Number>::base_tensor_type &data)
2133 constexpr std::size_t base_index[2][2] = {{0, 2}, {2, 1}};
2134 return data[base_index[indices[0]][indices[1]]]
2135 [base_index[indices[2]][indices[3]]];
2144 constexpr std::size_t base_index[3][3] = {{0, 3, 4},
2147 return data[base_index[indices[0]][indices[1]]]
2148 [base_index[indices[2]][indices[3]]];
2163 template <
int dim,
typename Number>
2166 const typename SymmetricTensorAccessors::
2167 StorageType<4, dim, Number>::base_tensor_type &data)
2181 constexpr std::size_t base_index[2][2] = {{0, 2}, {2, 1}};
2182 return data[base_index[indices[0]][indices[1]]]
2183 [base_index[indices[2]][indices[3]]];
2192 constexpr std::size_t base_index[3][3] = {{0, 3, 4},
2195 return data[base_index[indices[0]][indices[1]]]
2196 [base_index[indices[2]][indices[3]]];
2214template <
int rank_,
int dim,
typename Number>
2219 for (
unsigned int r = 0; r < rank; ++r)
2221 return internal::symmetric_tensor_access<dim, Number>(indices, data);
2226template <
int rank_,
int dim,
typename Number>
2231 for (
unsigned int r = 0; r < rank; ++r)
2233 return internal::symmetric_tensor_access<dim, Number>(indices, data);
2240 namespace SymmetricTensorImplementation
2242 template <
int rank_>
2244 get_partially_filled_indices(
const unsigned int row,
2245 const std::integral_constant<int, 2> &)
2251 template <
int rank_>
2253 get_partially_filled_indices(
const unsigned int row,
2254 const std::integral_constant<int, 4> &)
2265template <
int rank_,
int dim,
typename Number>
2267 SymmetricTensorAccessors::Accessor<rank_, dim,
true, rank_ - 1, Number>
2270 return internal::SymmetricTensorAccessors::
2271 Accessor<rank_, dim,
true, rank_ - 1, Number>(
2273 internal::SymmetricTensorImplementation::get_partially_filled_indices<
2274 rank_>(row, std::integral_constant<int, rank_>()));
2279template <
int rank_,
int dim,
typename Number>
2281 SymmetricTensorAccessors::Accessor<rank_, dim,
false, rank_ - 1, Number>
2284 return internal::SymmetricTensorAccessors::
2285 Accessor<rank_, dim,
false, rank_ - 1, Number>(
2287 internal::SymmetricTensorImplementation::get_partially_filled_indices<
2288 rank_>(row, std::integral_constant<int, rank_>()));
2293template <
int rank_,
int dim,
typename Number>
2298 return operator()(indices);
2303template <
int rank_,
int dim,
typename Number>
2308 return operator()(indices);
2313template <
int rank_,
int dim,
typename Number>
2317 return std::addressof(this->access_raw_entry(0));
2322template <
int rank_,
int dim,
typename Number>
2323inline const Number *
2326 return std::addressof(this->access_raw_entry(0));
2331template <
int rank_,
int dim,
typename Number>
2335 return begin_raw() + n_independent_components;
2340template <
int rank_,
int dim,
typename Number>
2341inline const Number *
2344 return begin_raw() + n_independent_components;
2349template <
int rank_,
int dim,
typename Number>
2352 const unsigned int index)
const
2355 if constexpr (rank == 2)
2358 return data[
decltype(data)::unrolled_to_component_indices(index)];
2363template <
int rank_,
int dim,
typename Number>
2368 if constexpr (rank == 2)
2371 return data[
decltype(data)::unrolled_to_component_indices(index)];
2378 template <
int dim,
typename Number>
2380 compute_norm(
const typename SymmetricTensorAccessors::
2381 StorageType<2, dim, Number>::base_tensor_type &data)
2408 for (
unsigned int d = 0;
d < dim; ++
d)
2411 for (
unsigned int d = dim;
d < (dim * dim + dim) / 2; ++
d)
2415 return sqrt(return_value);
2422 template <
int dim,
typename Number>
2424 compute_norm(
const typename SymmetricTensorAccessors::
2425 StorageType<4, dim, Number>::base_tensor_type &data)
2439 const unsigned int n_independent_components = data.dimension;
2441 for (
unsigned int i = 0; i < dim; ++i)
2442 for (
unsigned int j = 0; j < dim; ++j)
2445 for (
unsigned int i = 0; i < dim; ++i)
2446 for (
unsigned int j = dim; j < n_independent_components; ++j)
2449 for (
unsigned int i = dim; i < n_independent_components; ++i)
2450 for (
unsigned int j = 0; j < dim; ++j)
2453 for (
unsigned int i = dim; i < n_independent_components; ++i)
2454 for (
unsigned int j = dim; j < n_independent_components; ++j)
2458 return sqrt(return_value);
2467template <
int rank_,
int dim,
typename Number>
2471 return internal::compute_norm<dim, Number>(data);
2476template <
int rank_,
int dim,
typename Number>
2481 return internal::SymmetricTensorImplementation::component_to_unrolled_index<
2489 namespace SymmetricTensorImplementation
2501 const std::integral_constant<int, 2> &)
2539 for (
unsigned int d = 0, c = dim;
d < dim; ++
d)
2540 for (
unsigned int e = d + 1;
e < dim; ++
e, ++c)
2558 template <
int dim,
int rank_>
2559 constexpr inline std::enable_if_t<rank_ != 2, TableIndices<rank_>>
2561 const std::integral_constant<int, rank_> &)
2570 n_independent_components));
2578template <
int rank_,
int dim,
typename Number>
2581 const unsigned int i)
2583 return internal::SymmetricTensorImplementation::unrolled_to_component_indices<
2584 dim>(i, std::integral_constant<int, rank_>());
2589template <
int rank_,
int dim,
typename Number>
2590template <
class Archive>
2615template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2640template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2660template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2677template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2694template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2711template <
int rank_,
int dim,
typename Number,
typename OtherNumber>
2722template <
int dim,
typename Number>
2738 return (tmp + tmp + t.
data[0] * t.
data[1] * t.
data[2] -