Reference documentation for deal.II version 9.2.0
\(\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 - 2020 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 
23 DEAL_II_NAMESPACE_OPEN
24 
59 template <int order, int dim, int spacedim, typename Number = double>
60 class DerivativeForm
61 {
62 public:
66  DerivativeForm() = default;
67 
71  DerivativeForm(const Tensor<order + 1, dim, Number> &);
72 
76  Tensor<order, dim, Number> &operator[](const unsigned int i);
77 
81  const Tensor<order, dim, Number> &operator[](const unsigned int i) const;
82 
86  DerivativeForm &
87  operator=(const Tensor<order + 1, dim, Number> &);
88 
92  DerivativeForm &
93  operator=(const Tensor<1, dim, Number> &);
94 
100  operator Tensor<order + 1, dim, Number>() const;
101 
105  operator Tensor<1, dim, Number>() const;
106 
111  DerivativeForm<1, spacedim, dim, Number>
112  transpose() const;
113 
119  typename numbers::NumberTraits<Number>::real_type
120  norm() const;
121 
127  Number
128  determinant() const;
129 
139  DerivativeForm<1, dim, spacedim, Number>
140  covariant_form() const;
141 
146  static std::size_t
147  memory_consumption();
148 
152  DeclException1(ExcInvalidTensorIndex,
153  int,
154  << "Invalid DerivativeForm index " << arg1);
155 
156 private:
161  DerivativeForm<1, dim, spacedim, Number>
162  times_T_t(const Tensor<2, dim, Number> &T) const;
163 
164 
168  Tensor<order, dim, Number> tensor[spacedim];
169 };
170 
171 
172 /*--------------------------- Inline functions -----------------------------*/
173 
174 #ifndef DOXYGEN
175 
176 template <int order, int dim, int spacedim, typename Number>
177 inline DerivativeForm<order, dim, spacedim, Number>::DerivativeForm(
178  const Tensor<order + 1, dim, Number> &T)
179 {
180  Assert((dim == spacedim),
181  ExcMessage("Only allowed for forms with dim==spacedim."));
182  if (dim == spacedim)
183  for (unsigned int j = 0; j < dim; ++j)
184  (*this)[j] = T[j];
185 }
186 
187 
188 
189 template <int order, int dim, int spacedim, typename Number>
190 inline DerivativeForm<order, dim, spacedim, Number> &
191 DerivativeForm<order, dim, spacedim, Number>::
192 operator=(const Tensor<order + 1, dim, Number> &ta)
193 {
194  Assert((dim == spacedim), ExcMessage("Only allowed when dim==spacedim."));
195 
196  if (dim == spacedim)
197  for (unsigned int j = 0; j < dim; ++j)
198  (*this)[j] = ta[j];
199  return *this;
200 }
201 
202 
203 
204 template <int order, int dim, int spacedim, typename Number>
205 inline DerivativeForm<order, dim, spacedim, Number> &
206 DerivativeForm<order, dim, spacedim, Number>::
207 operator=(const Tensor<1, dim, Number> &T)
208 {
209  Assert((1 == spacedim) && (order == 1),
210  ExcMessage("Only allowed for spacedim==1 and order==1."));
211 
212  (*this)[0] = T;
213 
214  return *this;
215 }
216 
217 
218 
219 template <int order, int dim, int spacedim, typename Number>
220 inline Tensor<order, dim, Number> &
221  DerivativeForm<order, dim, spacedim, Number>::operator[](const unsigned int i)
222 {
223  AssertIndexRange(i, spacedim);
224 
225  return tensor[i];
226 }
227 
228 
229 
230 template <int order, int dim, int spacedim, typename Number>
231 inline const Tensor<order, dim, Number> &
232  DerivativeForm<order, dim, spacedim, Number>::
233  operator[](const unsigned int i) const
234 {
235  AssertIndexRange(i, spacedim);
236 
237  return tensor[i];
238 }
239 
240 
241 
242 template <int order, int dim, int spacedim, typename Number>
243 inline DerivativeForm<order, dim, spacedim, Number>::
244 operator Tensor<1, dim, Number>() const
245 {
246  Assert((1 == spacedim) && (order == 1),
247  ExcMessage("Only allowed for spacedim==1."));
248 
249  return (*this)[0];
250 }
251 
252 
253 
254 template <int order, int dim, int spacedim, typename Number>
255 inline DerivativeForm<order, dim, spacedim, Number>::
256 operator Tensor<order + 1, dim, Number>() const
257 {
258  Assert((dim == spacedim), ExcMessage("Only allowed when dim==spacedim."));
259 
260  Tensor<order + 1, dim, Number> t;
261 
262  if (dim == spacedim)
263  for (unsigned int j = 0; j < dim; ++j)
264  t[j] = (*this)[j];
265 
266  return t;
267 }
268 
269 
270 
271 template <int order, int dim, int spacedim, typename Number>
272 inline DerivativeForm<1, spacedim, dim, Number>
273 DerivativeForm<order, dim, spacedim, Number>::transpose() const
274 {
275  Assert(order == 1, ExcMessage("Only for rectangular DerivativeForm."));
276  DerivativeForm<1, spacedim, dim, Number> tt;
277 
278  for (unsigned int i = 0; i < spacedim; ++i)
279  for (unsigned int j = 0; j < dim; ++j)
280  tt[j][i] = (*this)[i][j];
281 
282  return tt;
283 }
284 
285 
286 
287 template <int order, int dim, int spacedim, typename Number>
288 inline DerivativeForm<1, dim, spacedim, Number>
289 DerivativeForm<order, dim, spacedim, Number>::times_T_t(
290  const Tensor<2, dim, Number> &T) const
291 {
292  Assert(order == 1, ExcMessage("Only for order == 1."));
293  DerivativeForm<1, dim, spacedim, Number> dest;
294  for (unsigned int i = 0; i < spacedim; ++i)
295  for (unsigned int j = 0; j < dim; ++j)
296  dest[i][j] = (*this)[i] * T[j];
297 
298  return dest;
299 }
300 
301 
302 
303 template <int order, int dim, int spacedim, typename Number>
304 inline typename numbers::NumberTraits<Number>::real_type
305 DerivativeForm<order, dim, spacedim, Number>::norm() const
306 {
307  typename numbers::NumberTraits<Number>::real_type sum_of_squares = 0;
308  for (unsigned int i = 0; i < spacedim; ++i)
309  sum_of_squares += tensor[i].norm_square();
310  return std::sqrt(sum_of_squares);
311 }
312 
313 
314 
315 template <int order, int dim, int spacedim, typename Number>
316 inline Number
317 DerivativeForm<order, dim, spacedim, Number>::determinant() const
318 {
319  Assert(order == 1, ExcMessage("Only for order == 1."));
320  if (dim == spacedim)
321  {
322  const Tensor<2, dim, Number> T =
323  static_cast<Tensor<2, dim, Number>>(*this);
324  return ::determinant(T);
325  }
326  else
327  {
328  Assert(spacedim > dim, ExcMessage("Only for spacedim>dim."));
329  const DerivativeForm<1, spacedim, dim, Number> DF_t = this->transpose();
330  Tensor<2, dim, Number> G; // First fundamental form
331  for (unsigned int i = 0; i < dim; ++i)
332  for (unsigned int j = 0; j < dim; ++j)
333  G[i][j] = DF_t[i] * DF_t[j];
334 
335  return (std::sqrt(::determinant(G)));
336  }
337 }
338 
339 
340 
341 template <int order, int dim, int spacedim, typename Number>
342 inline DerivativeForm<1, dim, spacedim, Number>
343 DerivativeForm<order, dim, spacedim, Number>::covariant_form() const
344 {
345  if (dim == spacedim)
346  {
347  const Tensor<2, dim, Number> DF_t =
348  ::transpose(invert(static_cast<Tensor<2, dim, Number>>(*this)));
349  return DerivativeForm<1, dim, spacedim, Number>(DF_t);
350  }
351  else
352  {
353  const DerivativeForm<1, spacedim, dim, Number> DF_t = this->transpose();
354  Tensor<2, dim, Number> G; // First fundamental form
355  for (unsigned int i = 0; i < dim; ++i)
356  for (unsigned int j = 0; j < dim; ++j)
357  G[i][j] = DF_t[i] * DF_t[j];
358 
359  return (this->times_T_t(invert(G)));
360  }
361 }
362 
363 
364 template <int order, int dim, int spacedim, typename Number>
365 inline std::size_t
366 DerivativeForm<order, dim, spacedim, Number>::memory_consumption()
367 {
368  return sizeof(DerivativeForm<order, dim, spacedim, Number>);
369 }
370 
371 #endif // DOXYGEN
372 
373 
374 
397 template <int spacedim, int dim, typename Number>
398 inline Tensor<1, spacedim, Number>
399 apply_transformation(const DerivativeForm<1, dim, spacedim, Number> &grad_F,
400  const Tensor<1, dim, Number> & d_x)
401 {
402  Tensor<1, spacedim, Number> dest;
403  for (unsigned int i = 0; i < spacedim; ++i)
404  dest[i] = grad_F[i] * d_x;
405  return dest;
406 }
407 
408 
409 
418 // rank=2
419 template <int spacedim, int dim, typename Number>
420 inline DerivativeForm<1, spacedim, dim, Number>
421 apply_transformation(const DerivativeForm<1, dim, spacedim, Number> &grad_F,
422  const Tensor<2, dim, Number> & D_X)
423 {
424  DerivativeForm<1, spacedim, dim, Number> dest;
425  for (unsigned int i = 0; i < dim; ++i)
426  dest[i] = apply_transformation(grad_F, D_X[i]);
427 
428  return dest;
429 }
430 
447 template <int spacedim, int dim, typename Number>
448 inline Tensor<2, spacedim, Number>
449 apply_transformation(const DerivativeForm<1, dim, spacedim, Number> &DF1,
450  const DerivativeForm<1, dim, spacedim, Number> &DF2)
451 {
452  Tensor<2, spacedim, Number> dest;
453 
454  for (unsigned int i = 0; i < spacedim; ++i)
455  dest[i] = apply_transformation(DF1, DF2[i]);
456 
457  return dest;
458 }
459 
460 
468 template <int dim, int spacedim, typename Number>
469 inline DerivativeForm<1, spacedim, dim, Number>
470 transpose(const DerivativeForm<1, dim, spacedim, Number> &DF)
471 {
472  DerivativeForm<1, spacedim, dim, Number> tt;
473  tt = DF.transpose();
474  return tt;
475 }
476 
477 
478 DEAL_II_NAMESPACE_CLOSE
479 
480 #endif
DerivativeForm::transpose
DerivativeForm< 1, spacedim, dim, Number > transpose() const
DerivativeForm::norm
numbers::NumberTraits< Number >::real_type norm() const
determinant
constexpr Number determinant(const SymmetricTensor< 2, dim, Number > &)
Definition: symmetric_tensor.h:2645
DerivativeForm::apply_transformation
Tensor< 1, spacedim, Number > apply_transformation(const DerivativeForm< 1, dim, spacedim, Number > &grad_F, const Tensor< 1, dim, Number > &d_x)
Definition: derivative_form.h:399
AssertIndexRange
#define AssertIndexRange(index, range)
Definition: exceptions.h:1649
SymmetricTensor::invert
constexpr SymmetricTensor< 2, dim, Number > invert(const SymmetricTensor< 2, dim, Number > &t)
Definition: symmetric_tensor.h:3467
DerivativeForm::memory_consumption
static std::size_t memory_consumption()
DerivativeForm::tensor
Tensor< order, dim, Number > tensor[spacedim]
Definition: derivative_form.h:168
DerivativeForm
Definition: derivative_form.h:60
LAPACKSupport::T
static const char T
Definition: lapack_support.h:163
tensor.h
StandardExceptions::ExcMessage
static ::ExceptionBase & ExcMessage(std::string arg1)
DerivativeForm::determinant
Number determinant() const
Tensor
Definition: tensor.h:450
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:358
DerivativeForm::DerivativeForm
DerivativeForm()=default
DeclException1
#define DeclException1(Exception1, type1, outsequence)
Definition: exceptions.h:518
numbers::NumberTraits::real_type
number real_type
Definition: numbers.h:437
DerivativeForm::times_T_t
DerivativeForm< 1, dim, spacedim, Number > times_T_t(const Tensor< 2, dim, Number > &T) const
std::sqrt
inline ::VectorizedArray< Number, width > sqrt(const ::VectorizedArray< Number, width > &x)
Definition: vectorization.h:5412
Assert
#define Assert(cond, exc)
Definition: exceptions.h:1419
SymmetricTensor::determinant
constexpr Number determinant(const SymmetricTensor< 2, dim, Number > &t)
Definition: symmetric_tensor.h:2645
DerivativeForm::covariant_form
DerivativeForm< 1, dim, spacedim, Number > covariant_form() const
DerivativeForm::operator=
DerivativeForm & operator=(const Tensor< order+1, dim, Number > &)
DerivativeForm::ExcInvalidTensorIndex
static ::ExceptionBase & ExcInvalidTensorIndex(int arg1)
config.h
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:359
DerivativeForm::transpose
DerivativeForm< 1, spacedim, dim, Number > transpose(const DerivativeForm< 1, dim, spacedim, Number > &DF)
Definition: derivative_form.h:470
DerivativeForm::operator[]
Tensor< order, dim, Number > & operator[](const unsigned int i)
Generated by   doxygen 1.8.17