Reference documentation for deal.II version GIT ffb4c3937f 2023-03-31 14:25:02+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
derivative_form.h
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2013 - 2021 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.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 #ifndef dealii_derivative_form_h
17 #define dealii_derivative_form_h
18 
19 #include <deal.II/base/config.h>
20 
21 #include <deal.II/base/tensor.h>
22 
24 
57 template <int order, int dim, int spacedim, typename Number = double>
59 {
60 public:
64  DerivativeForm() = default;
65 
70 
78 
83  operator[](const unsigned int i);
84 
89  operator[](const unsigned int i) const;
90 
96 
101  operator=(const Tensor<order, spacedim, Tensor<1, dim, Number>> &);
102 
108 
115 
119  operator Tensor<1, dim, Number>() const;
120 
126  transpose() const;
127 
134  norm() const;
135 
141  Number
142  determinant() const;
143 
154  covariant_form() const;
155 
160  static std::size_t
162 
167  int,
168  << "Invalid DerivativeForm index " << arg1);
169 
170 private:
177 
178 
183 };
184 
185 
186 /*--------------------------- Inline functions -----------------------------*/
187 
188 #ifndef DOXYGEN
189 
190 template <int order, int dim, int spacedim, typename Number>
193 {
194  Assert((dim == spacedim),
195  ExcMessage("Only allowed for forms with dim==spacedim."));
196  if (dim == spacedim)
197  for (unsigned int j = 0; j < dim; ++j)
198  (*this)[j] = T[j];
199 }
200 
201 
202 
203 template <int order, int dim, int spacedim, typename Number>
205  const Tensor<1, spacedim, Tensor<order, dim, Number>> &T)
206 {
207  for (unsigned int j = 0; j < spacedim; ++j)
208  (*this)[j] = T[j];
209 }
210 
211 
212 
213 template <int order, int dim, int spacedim, typename Number>
217 {
218  Assert((dim == spacedim), ExcMessage("Only allowed when dim==spacedim."));
219 
220  if (dim == spacedim)
221  for (unsigned int j = 0; j < dim; ++j)
222  (*this)[j] = ta[j];
223  return *this;
224 }
225 
226 
227 
228 template <int order, int dim, int spacedim, typename Number>
231  const Tensor<order, spacedim, Tensor<1, dim, Number>> &T)
232 {
233  for (unsigned int j = 0; j < spacedim; ++j)
234  (*this)[j] = T[j];
235  return *this;
236 }
237 
238 
239 
240 template <int order, int dim, int spacedim, typename Number>
243  const Tensor<1, dim, Number> &T)
244 {
245  Assert((1 == spacedim) && (order == 1),
246  ExcMessage("Only allowed for spacedim==1 and order==1."));
247 
248  (*this)[0] = T;
249 
250  return *this;
251 }
252 
253 
254 
255 template <int order, int dim, int spacedim, typename Number>
258 {
259  AssertIndexRange(i, spacedim);
260 
261  return tensor[i];
262 }
263 
264 
265 
266 template <int order, int dim, int spacedim, typename Number>
267 inline const Tensor<order, dim, Number> &
269  const unsigned int i) const
270 {
271  AssertIndexRange(i, spacedim);
272 
273  return tensor[i];
274 }
275 
276 
277 
278 template <int order, int dim, int spacedim, typename Number>
280 operator Tensor<1, dim, Number>() const
281 {
282  Assert((1 == spacedim) && (order == 1),
283  ExcMessage("Only allowed for spacedim==1."));
284 
285  return (*this)[0];
286 }
287 
288 
289 
290 template <int order, int dim, int spacedim, typename Number>
292 operator Tensor<order + 1, dim, Number>() const
293 {
294  Assert((dim == spacedim), ExcMessage("Only allowed when dim==spacedim."));
295 
297 
298  if (dim == spacedim)
299  for (unsigned int j = 0; j < dim; ++j)
300  t[j] = (*this)[j];
301 
302  return t;
303 }
304 
305 
306 
307 template <int order, int dim, int spacedim, typename Number>
310 {
311  Assert(order == 1, ExcMessage("Only for rectangular DerivativeForm."));
313 
314  for (unsigned int i = 0; i < spacedim; ++i)
315  for (unsigned int j = 0; j < dim; ++j)
316  tt[j][i] = (*this)[i][j];
317 
318  return tt;
319 }
320 
321 
322 
323 template <int order, int dim, int spacedim, typename Number>
326  const Tensor<2, dim, Number> &T) const
327 {
328  Assert(order == 1, ExcMessage("Only for order == 1."));
330  for (unsigned int i = 0; i < spacedim; ++i)
331  for (unsigned int j = 0; j < dim; ++j)
332  dest[i][j] = (*this)[i] * T[j];
333 
334  return dest;
335 }
336 
337 
338 
339 template <int order, int dim, int spacedim, typename Number>
342 {
343  typename numbers::NumberTraits<Number>::real_type sum_of_squares = 0;
344  for (unsigned int i = 0; i < spacedim; ++i)
345  sum_of_squares += tensor[i].norm_square();
346  return std::sqrt(sum_of_squares);
347 }
348 
349 
350 
351 template <int order, int dim, int spacedim, typename Number>
352 inline Number
354 {
355  Assert(order == 1, ExcMessage("Only for order == 1."));
356  if (dim == spacedim)
357  {
358  const Tensor<2, dim, Number> T =
359  static_cast<Tensor<2, dim, Number>>(*this);
361  }
362  else
363  {
364  Assert(spacedim > dim, ExcMessage("Only for spacedim>dim."));
366  Tensor<2, dim, Number> G; // First fundamental form
367  for (unsigned int i = 0; i < dim; ++i)
368  for (unsigned int j = 0; j < dim; ++j)
369  G[i][j] = DF_t[i] * DF_t[j];
370 
371  return (std::sqrt(::determinant(G)));
372  }
373 }
374 
375 
376 
377 template <int order, int dim, int spacedim, typename Number>
380 {
381  if (dim == spacedim)
382  {
383  const Tensor<2, dim, Number> DF_t =
384  ::transpose(invert(static_cast<Tensor<2, dim, Number>>(*this)));
386  }
387  else
388  {
390  Tensor<2, dim, Number> G; // First fundamental form
391  for (unsigned int i = 0; i < dim; ++i)
392  for (unsigned int j = 0; j < dim; ++j)
393  G[i][j] = DF_t[i] * DF_t[j];
394 
395  return (this->times_T_t(invert(G)));
396  }
397 }
398 
399 
400 template <int order, int dim, int spacedim, typename Number>
401 inline std::size_t
403 {
405 }
406 
407 #endif // DOXYGEN
408 
409 
410 
432 template <int spacedim, int dim, typename Number1, typename Number2>
435  const Tensor<1, dim, Number2> & d_x)
436 {
438  for (unsigned int i = 0; i < spacedim; ++i)
439  dest[i] = grad_F[i] * d_x;
440  return dest;
441 }
442 
443 
444 
453 // rank=2
454 template <int spacedim, int dim, typename Number1, typename Number2>
455 inline DerivativeForm<1,
456  spacedim,
457  dim,
460  const Tensor<2, dim, Number2> & D_X)
461 {
463  dest;
464  for (unsigned int i = 0; i < dim; ++i)
465  dest[i] = apply_transformation(grad_F, D_X[i]);
466 
467  return dest;
468 }
469 
470 
471 
482 // rank=2
483 template <int dim, typename Number1, typename Number2>
486  const Tensor<2, dim, Number2> & D_X)
487 {
489  for (unsigned int i = 0; i < dim; ++i)
490  dest[i] = apply_transformation(grad_F, D_X[i]);
491 
492  return dest;
493 }
494 
495 
496 
504 template <int spacedim,
505  int dim,
506  int n_components,
507  typename Number1,
508  typename Number2>
509 inline Tensor<1,
510  n_components,
514  const Tensor<1, n_components, Tensor<1, dim, Number2>> &D_X)
515 {
516  Tensor<1,
517  n_components,
519  dest;
520  for (unsigned int i = 0; i < n_components; ++i)
521  dest[i] = apply_transformation(grad_F, D_X[i]);
522 
523  return dest;
524 }
525 
526 
527 
543 template <int spacedim, int dim, typename Number1, typename Number2>
547 {
549 
550  for (unsigned int i = 0; i < spacedim; ++i)
551  dest[i] = apply_transformation(DF1, DF2[i]);
552 
553  return dest;
554 }
555 
556 
557 
564 template <int dim, int spacedim, typename Number>
567 {
569  tt = DF.transpose();
570  return tt;
571 }
572 
573 
575 
576 #endif
static std::size_t memory_consumption()
DerivativeForm & operator=(const Tensor< order, spacedim, Tensor< 1, dim, Number >> &)
DerivativeForm(const Tensor< 1, spacedim, Tensor< order, dim, Number >> &)
Tensor< 2, dim, typename ProductType< Number1, Number2 >::type > apply_transformation(const DerivativeForm< 1, dim, dim, Number1 > &grad_F, const Tensor< 2, dim, Number2 > &D_X)
Tensor< order, dim, Number > tensor[spacedim]
DerivativeForm & operator=(const Tensor< 1, dim, Number > &)
Number determinant() const
DerivativeForm< 1, dim, spacedim, Number > times_T_t(const Tensor< 2, dim, Number > &T) const
DerivativeForm< 1, spacedim, dim, Number > transpose(const DerivativeForm< 1, dim, spacedim, Number > &DF)
DerivativeForm< 1, spacedim, dim, typename ProductType< Number1, Number2 >::type > apply_transformation(const DerivativeForm< 1, dim, spacedim, Number1 > &grad_F, const Tensor< 2, dim, Number2 > &D_X)
const Tensor< order, dim, Number > & operator[](const unsigned int i) const
DerivativeForm()=default
Tensor< 1, spacedim, typename ProductType< Number1, Number2 >::type > apply_transformation(const DerivativeForm< 1, dim, spacedim, Number1 > &grad_F, const Tensor< 1, dim, Number2 > &d_x)
DerivativeForm< 1, dim, spacedim, Number > covariant_form() const
DerivativeForm & operator=(const Tensor< order+1, dim, Number > &)
DerivativeForm< 1, spacedim, dim, Number > transpose() const
Tensor< 1, n_components, Tensor< 1, spacedim, typename ProductType< Number1, Number2 >::type > > apply_transformation(const DerivativeForm< 1, dim, spacedim, Number1 > &grad_F, const Tensor< 1, n_components, Tensor< 1, dim, Number2 >> &D_X)
Tensor< 2, spacedim, typename ProductType< Number1, Number2 >::type > apply_transformation(const DerivativeForm< 1, dim, spacedim, Number1 > &DF1, const DerivativeForm< 1, dim, spacedim, Number2 > &DF2)
numbers::NumberTraits< Number >::real_type norm() const
DerivativeForm(const Tensor< order+1, dim, Number > &)
Tensor< order, dim, Number > & operator[](const unsigned int i)
constexpr DEAL_II_HOST Number determinant(const SymmetricTensor< 2, dim, Number > &)
constexpr DEAL_II_HOST SymmetricTensor< 2, dim, Number > invert(const SymmetricTensor< 2, dim, Number > &t)
Definition: tensor.h:516
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:474
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:475
#define Assert(cond, exc)
Definition: exceptions.h:1586
static ::ExceptionBase & ExcInvalidTensorIndex(int arg1)
#define AssertIndexRange(index, range)
Definition: exceptions.h:1827
#define DeclException1(Exception1, type1, outsequence)
Definition: exceptions.h:510
static ::ExceptionBase & ExcMessage(std::string arg1)
static const char T
::VectorizedArray< Number, width > sqrt(const ::VectorizedArray< Number, width > &)
typename internal::ProductTypeImpl< typename std::decay< T >::type, typename std::decay< U >::type >::type type
constexpr DEAL_II_HOST Number determinant(const SymmetricTensor< 2, dim, Number > &)