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\}}\)
symengine_tensor_operations.cc
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2016 - 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 at
12 // the top level of the deal.II distribution.
13 //
14 // ---------------------------------------------------------------------
15 
16 
17 #include <deal.II/base/config.h>
18 
19 #ifdef DEAL_II_WITH_SYMENGINE
20 
22 # include <deal.II/base/tensor.h>
23 # include <deal.II/base/utilities.h>
24 
30 
32 
33 namespace Differentiation
34 {
35  namespace SD
36  {
37  // --- Symbolic variable creation ---
38 
39  namespace internal
40  {
41  namespace
42  {
43  template <int rank>
44  std::string
45  make_index_string(const TableIndices<rank> &indices)
46  {
47  std::string out;
48  for (unsigned int i = 0; i < rank; ++i)
49  out += std::to_string(indices[i]);
50  return out;
51  }
52 
53 
54  template <int rank, int dim>
55  struct Symbol_Tensor;
56 
57 
58  template <int rank, int dim>
59  struct Symbol_Tensor
60  {
62  create(const std::string &sym)
63  {
65  for (unsigned int i = 0; i < out.n_independent_components; ++i)
66  {
67  const TableIndices<rank> indices(
69  out[indices] = Expression(sym + std::string("_") +
70  internal::make_index_string(indices));
71  }
72  return out;
73  }
74  };
75 
76 
77  template <int dim>
78  struct Symbol_Tensor<0, dim>
79  {
81  create(const std::string &sym)
82  {
83  return make_symbol(sym);
84  }
85  };
86 
87 
88  template <int rank, int dim>
89  struct Symbol_SymmetricTensor;
90 
91 
92  template <int rank, int dim>
93  struct Symbol_SymmetricTensor
94  {
96  create(const std::string &sym)
97  {
99  for (unsigned int i = 0; i < out.n_independent_components; ++i)
100  {
101  const TableIndices<rank> indices(
103  out[indices] = Expression(sym + std::string("_") +
104  internal::make_index_string(indices));
105  }
106  return out;
107  }
108  };
109 
110 
111  template <int dim>
112  struct Symbol_SymmetricTensor<4, dim>
113  {
115  create(const std::string &sym)
116  {
118  for (unsigned int i = 0;
119  i < SymmetricTensor<2, dim>::n_independent_components;
120  ++i)
121  for (unsigned int j = 0;
122  j < SymmetricTensor<2, dim>::n_independent_components;
123  ++j)
124  {
125  const TableIndices<4> indices =
126  make_rank_4_tensor_indices<dim>(i, j);
127  out[indices] =
128  Expression(sym + std::string("_") +
129  internal::make_index_string(indices));
130  }
131  return out;
132  }
133  };
134 
135 
136  template <int rank, int dim>
137  struct Symbol_Function_Tensor;
138 
139 
140  template <int rank, int dim>
141  struct Symbol_Function_Tensor
142  {
144  create(const std::string & sym,
145  const types::substitution_map &arguments)
146  {
148  const types::symbol_vector args =
149  Utilities::extract_symbols(arguments);
150  for (unsigned int i = 0; i < out.n_independent_components; ++i)
151  {
152  const TableIndices<rank> indices(
154  out[indices] =
155  Expression(sym + std::string("_") +
156  internal::make_index_string(indices),
157  args);
158  }
159  return out;
160  }
161  };
162 
163 
164  template <int dim>
165  struct Symbol_Function_Tensor<0, dim>
166  {
168  create(const std::string & sym,
169  const types::substitution_map &arguments)
170  {
171  return make_symbolic_function(sym, arguments);
172  }
173  };
174 
175 
176  template <int rank, int dim>
177  struct Symbol_Function_SymmetricTensor;
178 
179 
180  template <int rank, int dim>
181  struct Symbol_Function_SymmetricTensor
182  {
184  create(const std::string & sym,
185  const types::substitution_map &arguments)
186  {
188  const types::symbol_vector args =
189  Utilities::extract_symbols(arguments);
190  for (unsigned int i = 0; i < out.n_independent_components; ++i)
191  {
192  const TableIndices<rank> indices(
194  out[indices] =
195  Expression(sym + std::string("_") +
196  internal::make_index_string(indices),
197  args);
198  }
199  return out;
200  }
201  };
202 
203 
204  template <int dim>
205  struct Symbol_Function_SymmetricTensor<4, dim>
206  {
208  create(const std::string & sym,
209  const types::substitution_map &arguments)
210  {
212  const types::symbol_vector args =
213  Utilities::extract_symbols(arguments);
214  for (unsigned int i = 0;
215  i < SymmetricTensor<2, dim>::n_independent_components;
216  ++i)
217  for (unsigned int j = 0;
218  j < SymmetricTensor<2, dim>::n_independent_components;
219  ++j)
220  {
221  const TableIndices<4> indices =
222  make_rank_4_tensor_indices<dim>(i, j);
223  out[indices] =
224  Expression(sym + std::string("_") +
225  internal::make_index_string(indices),
226  args);
227  }
228  return out;
229  }
230  };
231  } // namespace
232  } // namespace internal
233 
234 
235  template <int dim>
237  make_vector_of_symbols(const std::string &sym)
238  {
239  return internal::Symbol_Tensor<1, dim>::create(sym);
240  }
241 
242 
243 # ifndef DOXYGEN
244  template <int dim>
246  make_vector_of_symbolic_functions(const std::string & sym,
247  const types::substitution_map &arguments)
248  {
249  return internal::Symbol_Function_Tensor<1, dim>::create(sym, arguments);
250  }
251 # endif
252 
253 
254  template <int rank, int dim>
256  make_tensor_of_symbols(const std::string &sym)
257  {
258  return internal::Symbol_Tensor<rank, dim>::create(sym);
259  }
260 
261 
262  template <int rank, int dim>
264  make_symmetric_tensor_of_symbols(const std::string &sym)
265  {
266  return internal::Symbol_SymmetricTensor<rank, dim>::create(sym);
267  }
268 
269 
270 # ifndef DOXYGEN
271  template <int rank, int dim>
273  make_tensor_of_symbolic_functions(const std::string & sym,
274  const types::substitution_map &arguments)
275  {
276  return internal::Symbol_Function_Tensor<rank, dim>::create(sym,
277  arguments);
278  }
279 
280 
281  template <int rank, int dim>
284  const std::string & sym,
285  const types::substitution_map &arguments)
286  {
287  return internal::Symbol_Function_SymmetricTensor<rank, dim>::create(
288  sym, arguments);
289  }
290 # endif // DOXYGEN
291 
292  } // namespace SD
293 } // namespace Differentiation
294 
295 /* --- Explicit instantiations --- */
296 
297 # include "symengine_tensor_operations.inst"
298 
300 
301 #endif // DEAL_II_WITH_SYMENGINE
static constexpr unsigned int n_independent_components
Tensor< rank, dim, Expression > make_tensor_of_symbolic_functions(const std::string &symbol, const types::substitution_map &arguments)
static constexpr TableIndices< rank_ > unrolled_to_component_indices(const unsigned int i)
Expression make_symbolic_function(const std::string &symbol, const types::symbol_vector &arguments)
static constexpr TableIndices< rank_ > unrolled_to_component_indices(const unsigned int i)
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:359
std::string to_string(const T &t)
Definition: patterns.h:2360
std::vector< SD::Expression > symbol_vector
SD::types::symbol_vector extract_symbols(const SD::types::substitution_map &substitution_values)
SymmetricTensor< rank, dim, Expression > make_symmetric_tensor_of_symbolic_functions(const std::string &symbol, const types::substitution_map &arguments)
Expression make_symbol(const std::string &symbol)
Definition: tensor.h:450
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:358
Tensor< 1, dim, Expression > make_vector_of_symbols(const std::string &symbol)
SymmetricTensor< rank, dim, Expression > make_symmetric_tensor_of_symbols(const std::string &symbol)
Tensor< 1, dim, Expression > make_vector_of_symbolic_functions(const std::string &symbol, const types::substitution_map &arguments)
static constexpr unsigned int n_independent_components
Definition: tensor.h:476
std::map< SD::Expression, SD::Expression, internal::ExpressionKeyLess > substitution_map
Tensor< rank, dim, Expression > make_tensor_of_symbols(const std::string &symbol)