v0.14.0
Loading...
Searching...
No Matches
base_functions.c
Go to the documentation of this file.
1/** \file base_functions.c
2
3*/
4
5#include <cblas.h>
6#include <petscsys.h>
7#include <phg-quadrule/quad.h>
8
9#include <definitions.h>
10
11#include <base_functions.h>
12
13static PetscErrorCode ierr;
14
15PetscErrorCode Legendre_polynomials(int p, double s, double *diff_s, double *L,
16 double *diffL, const int dim) {
17 MoFEMFunctionBeginHot;
18#ifndef NDEBUG
19 if (dim < 1)
20 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "dim < 1");
21 if (dim > 3)
22 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "dim > 3");
23 if (p < 0)
24 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "p < 0");
25#endif // NDEBUG
26
27 L[0] = 1;
28 if (diffL != NULL) {
29 for (int d = 0; d != dim; ++d) {
30 diffL[d * (p + 1) + 0] = 0;
31 }
32 }
33 if (p == 0)
34 MoFEMFunctionReturnHot(0);
35
36 L[1] = s;
37 if (diffL != NULL) {
38#ifndef NDEBUG
39 if (diff_s == NULL) {
40 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "diff_s == NULL");
41 }
42#endif // NDEBUG
43 for (int d = 0; d != dim; ++d) {
44 diffL[d * (p + 1) + 1] = diff_s[d];
45 }
46 }
47 if (p == 1)
48 MoFEMFunctionReturnHot(0);
49
50 int l = 1;
51 for (; l < p; l++) {
52 double A = ((2 * (double)l + 1) / ((double)l + 1));
53 double B = ((double)l / ((double)l + 1));
54 L[l + 1] = A * s * L[l] - B * L[l - 1];
55 if (diffL != NULL) {
56 for (int d = 0; d != dim; ++d) {
57 diffL[d * (p + 1) + l + 1] =
58 A * (diff_s[d] * L[l] + s * diffL[d * (p + 1) + l]) -
59 B * diffL[d * (p + 1) + l - 1];
60 }
61 }
62 }
63
64 MoFEMFunctionReturnHot(0);
65}
66
67PetscErrorCode Jacobi_polynomials(int p, double alpha, double x, double t,
68 double *diff_x, double *diff_t, double *L,
69 double *diffL, const int dim) {
70 MoFEMFunctionBeginHot;
71#ifndef NDEBUG
72 if (dim < 1)
73 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "dim < 1");
74 if (dim > 3)
75 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "dim > 3");
76 if (p < 0)
77 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "p < 0");
78#endif // NDEBUG
79 L[0] = 1;
80 if (diffL != NULL) {
81 diffL[0 * (p + 1) + 0] = 0;
82 if (dim >= 2) {
83 diffL[1 * (p + 1) + 0] = 0;
84 if (dim == 3) {
85 diffL[2 * (p + 1) + 0] = 0;
86 }
87 }
88 }
89 if (p == 0)
90 MoFEMFunctionReturnHot(0);
91 L[1] = 2 * x - t + alpha * x;
92 if (diffL != NULL) {
93#ifndef NDEBUG
94 if (diff_x == NULL) {
95 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "diff_s == NULL");
96 }
97#endif // NDEBUG
98 double d_t = (diff_t) ? diff_t[0] : 0;
99 diffL[0 * (p + 1) + 1] = (2 + alpha) * diff_x[0] - d_t;
100 if (dim >= 2) {
101 double d_t = (diff_t) ? diff_t[1] : 0;
102 diffL[1 * (p + 1) + 1] = (2 + alpha) * diff_x[1] - d_t;
103 if (dim == 3) {
104 double d_t = (diff_t) ? diff_t[2] : 0;
105 diffL[2 * (p + 1) + 1] = (2 + alpha) * diff_x[2] - d_t;
106 }
107 }
108 }
109 if (p == 1)
110 MoFEMFunctionReturnHot(0);
111 int l = 1;
112 for (; l < p; l++) {
113 int lp1 = l + 1;
114 double a = 2 * lp1 * (lp1 + alpha) * (2 * lp1 + alpha - 2);
115 double b = 2 * lp1 + alpha - 1;
116 double c = (2 * lp1 + alpha) * (2 * lp1 + alpha - 2);
117 double d = 2 * (lp1 + alpha - 1) * (lp1 - 1) * (2 * lp1 + alpha);
118 double A = b * (c * (2 * x - t) + alpha * alpha * t) / a;
119 double B = d * t * t / a;
120 L[lp1] = A * L[l] - B * L[l - 1];
121 if (diffL != NULL) {
122 double d_t = (diff_t) ? diff_t[0] : 0;
123 double diffA = b * (c * (2 * diff_x[0] - d_t) + alpha * alpha * d_t) / a;
124 double diffB = d * 2 * t * d_t / a;
125 diffL[0 * (p + 1) + lp1] = A * diffL[0 * (p + 1) + l] -
126 B * diffL[0 * (p + 1) + l - 1] + diffA * L[l] -
127 diffB * L[l - 1];
128 if (dim >= 2) {
129 double d_t = (diff_t) ? diff_t[1] : 0;
130 double diffA =
131 b * (c * (2 * diff_x[1] - d_t) + alpha * alpha * d_t) / a;
132 double diffB = d * 2 * t * d_t / a;
133 diffL[1 * (p + 1) + lp1] = A * diffL[1 * (p + 1) + l] -
134 B * diffL[1 * (p + 1) + l - 1] +
135 diffA * L[l] - diffB * L[l - 1];
136 if (dim == 3) {
137 double d_t = (diff_t) ? diff_t[2] : 0;
138 double diffA =
139 b * (c * (2 * diff_x[2] - d_t) + alpha * alpha * d_t) / a;
140 double diffB = d * 2 * t * d_t / a;
141 diffL[2 * (p + 1) + lp1] = A * diffL[2 * (p + 1) + l] -
142 B * diffL[2 * (p + 1) + l - 1] +
143 diffA * L[l] - diffB * L[l - 1];
144 }
145 }
146 }
147 }
148 MoFEMFunctionReturnHot(0);
149}
150
151PetscErrorCode IntegratedJacobi_polynomials(int p, double alpha, double x,
152 double t, double *diff_x,
153 double *diff_t, double *L,
154 double *diffL, const int dim) {
155 MoFEMFunctionBeginHot;
156#ifndef NDEBUG
157 if (dim < 1)
158 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "dim < 1");
159 if (dim > 3)
160 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "dim > 3");
161 if (p < 1)
162 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "p < 1");
163#endif // NDEBUG
164 L[0] = x;
165 if (diffL != NULL) {
166 int d = 0;
167 for (; d != dim; ++d) {
168 diffL[d * p + 0] = diff_x[d];
169 }
170 }
171 if (p == 0)
172 MoFEMFunctionReturnHot(0);
173 double jacobi[(p + 1)];
174 double diff_jacobi[(p + 1) * dim];
175 ierr = Jacobi_polynomials(p, alpha, x, t, diff_x, diff_t, jacobi, diff_jacobi,
176 dim);
177 CHKERRQ(ierr);
178 int l = 1;
179 for (; l < p; l++) {
180 int i = l + 1;
181 const double a = (i + alpha) / ((2 * i + alpha - 1) * (2 * i + alpha));
182 const double b = alpha / ((2 * i + alpha - 2) * (2 * i + alpha));
183 const double c = (i - 1) / ((2 * i + alpha - 2) * (2 * i + alpha - 1));
184 L[l] = a * jacobi[i] + b * t * jacobi[i - 1] - c * t * t * jacobi[i - 2];
185 if (diffL != NULL) {
186 int dd = 0;
187 for (; dd != dim; ++dd) {
188 diffL[dd * p + l] = a * diff_jacobi[dd * (p + 1) + i] +
189 b * (t * diff_jacobi[dd * (p + 1) + i - 1] +
190 diff_t[dd] * jacobi[i - 1]) -
191 c * (t * t * diff_jacobi[dd * (p + 1) + i - 2] +
192 2 * t * diff_t[dd] * jacobi[i - 2]);
193 }
194 }
195 }
196 MoFEMFunctionReturnHot(0);
197}
198
199PetscErrorCode Lobatto_polynomials(int p, double s, double *diff_s, double *L,
200 double *diffL, const int dim) {
201
202 MoFEMFunctionBeginHot;
203#ifndef NDEBUG
204 if (dim < 1)
205 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "dim < 1");
206 if (dim > 3)
207 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "dim > 3");
208 if (p < 2)
209 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "p < 2");
210#endif // NDEBUG
211 double l[p + 1];
212 ierr = Legendre_polynomials(p, s, NULL, l, NULL, 1);
213 CHKERRQ(ierr);
214
215 L[0] = 1;
216 if (diffL != NULL) {
217 for (int d = 0; d != dim; ++d) {
218 diffL[d * (p + 1) + 0] = 0;
219 }
220 }
221 L[1] = s;
222 if (diffL != NULL) {
223#ifndef NDEBUG
224 if (diff_s == NULL) {
225 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "diff_s == NULL");
226 }
227#endif // NDEBUG
228 for (int d = 0; d != dim; ++d) {
229 diffL[d * (p + 1) + 1] = diff_s[d];
230 }
231 }
232
233 // Integrated Legendre
234 for (int k = 2; k <= p; k++) {
235 const double factor = 2 * (2 * k - 1);
236 L[k] = 1.0 / factor * (l[k] - l[k - 2]);
237 }
238
239 if (diffL != NULL) {
240 for (int k = 2; k <= p; k++) {
241 double a = l[k - 1] / 2.;
242 for (int d = 0; d != dim; ++d) {
243 diffL[d * (p + 1) + k] = a * diff_s[d];
244 }
245 }
246 }
247 MoFEMFunctionReturnHot(0);
248}
249
250static double f_phi0(double x) { return LOBATTO_PHI0(x); }
251static double f_phi1(double x) { return LOBATTO_PHI1(x); }
252static double f_phi2(double x) { return LOBATTO_PHI2(x); }
253static double f_phi3(double x) { return LOBATTO_PHI3(x); }
254static double f_phi4(double x) { return LOBATTO_PHI4(x); }
255static double f_phi5(double x) { return LOBATTO_PHI5(x); }
256static double f_phi6(double x) { return LOBATTO_PHI6(x); }
257static double f_phi7(double x) { return LOBATTO_PHI7(x); }
258static double f_phi8(double x) { return LOBATTO_PHI8(x); }
259static double f_phi9(double x) { return LOBATTO_PHI9(x); }
260
261static double (*f_phi[])(double x) = {f_phi0, f_phi1, f_phi2, f_phi3, f_phi4,
262 f_phi5, f_phi6, f_phi7, f_phi8, f_phi9};
263
264static double f_phi0x(double x) { return LOBATTO_PHI0X(x); }
265static double f_phi1x(double x) { return LOBATTO_PHI1X(x); }
266static double f_phi2x(double x) { return LOBATTO_PHI2X(x); }
267static double f_phi3x(double x) { return LOBATTO_PHI3X(x); }
268static double f_phi4x(double x) { return LOBATTO_PHI4X(x); }
269static double f_phi5x(double x) { return LOBATTO_PHI5X(x); }
270static double f_phi6x(double x) { return LOBATTO_PHI6X(x); }
271static double f_phi7x(double x) { return LOBATTO_PHI7X(x); }
272static double f_phi8x(double x) { return LOBATTO_PHI8X(x); }
273static double f_phi9x(double x) { return LOBATTO_PHI9X(x); }
274
275static double (*f_phix[])(double x) = {f_phi0x, f_phi1x, f_phi2x, f_phi3x,
276 f_phi4x, f_phi5x, f_phi6x, f_phi7x,
277 f_phi8x, f_phi9x};
278
279// /// Legendre polynomials
280// #define Legendre0(x) (1.0)
281// #define Legendre1(x) (x)
282// #define Legendre2(x) (1.0 / 2.0 * (3 * (x) * (x) - 1))
283// #define Legendre3(x) (1.0 / 2.0 * (5 * (x) * (x) - 3) * (x))
284// #define Legendre4(x) (1.0 / 8.0 * ((35 * (x) * (x) - 30) * (x) * (x) + 3))
285// #define Legendre5(x) (1.0 / 8.0 * ((63 * (x) * (x) - 70) * (x) * (x) + 15) *
286// (x)) #define Legendre6(x) (1.0 / 16.0 * (((231 * (x) * (x) - 315) * (x) * (x)
287// + 105) * (x) * (x) - 5)) #define Legendre7(x) (1.0 / 16.0 * (((429 * (x) *
288// (x) - 693) * (x) * (x) + 315) * (x) * (x) - 35) * (x)) #define Legendre8(x)
289// (1.0 / 128.0 * ((((6435 * (x) * (x) - 12012) * (x) * (x) + 6930) * (x) * (x)
290// - 1260) * (x) * (x) + 35)) #define Legendre9(x) (1.0 / 128.0 * ((((12155 *
291// (x) * (x) - 25740) * (x) * (x) + 18018) * (x) * (x) - 4620) * (x) * (x) +
292// 315) * (x)) #define Legendre10(x) (1.0 / 256.0 * (((((46189 * (x) * (x) -
293// 109395) * (x) * (x) + 90090) * (x) * (x) - 30030) * (x) * (x) + 3465) * (x) *
294// (x) - 63))
295//
296// /// derivatives of Legendre polynomials
297// #define Legendre0x(x) (0.0)
298// #define Legendre1x(x) (1.0)
299// #define Legendre2x(x) (3.0 * (x))
300// #define Legendre3x(x) (15.0 / 2.0 * (x) * (x) - 3.0 / 2.0)
301// #define Legendre4x(x) (5.0 / 2.0 * (x) * (7.0 * (x) * (x) - 3.0))
302// #define Legendre5x(x) ((315.0 / 8.0 * (x) * (x) - 105.0 / 4.0) * (x) * (x)
303// + 15.0 / 8.0) #define Legendre6x(x) (21.0 / 8.0 * (x) * ((33.0 * (x) * (x)
304// - 30.0) * (x) * (x) + 5.0)) #define Legendre7x(x) (((3003.0 / 16.0 * (x) *
305// (x) - 3465.0 / 16.0) * (x) * (x) + 945.0 / 16.0) * (x) * (x) - 35.0 / 16.0)
306// #define Legendre8x(x) (9.0 / 16.0 * (x) * (((715.0 * (x) * (x) - 1001.0) *
307// (x) * (x) + 385.0) * (x) * (x) - 35.0)) #define Legendre9x(x) ((((109395.0 /
308// 128.0 * (x) * (x) - 45045.0 / 32.0) * (x) * (x) + 45045.0 / 64.0) * (x) * (x)
309// - 3465.0 / 32.0) * (x) * (x) + 315.0 / 128.0) #define Legendre10x(x) (2.0 /
310// 256.0 * (x) * ((((230945.0 * (x) * (x) - 437580.0) * (x) * (x) + 270270.0) *
311// (x) * (x) - 60060.0) * (x) * (x) + 3465.0))
312//
313// /// first two Lobatto shape functions
314// #define l0(x) ((1.0 - (x)) * 0.5)
315// #define l1(x) ((1.0 + (x)) * 0.5)
316//
317// #define l0l1(x) ((1.0 - (x)*(x)) * 0.25)
318//
319// /// other Lobatto shape functions
320// #define l2(x) (phi0(x) * l0l1(x))
321// #define l3(x) (phi1(x) * l0l1(x))
322// #define l4(x) (phi2(x) * l0l1(x))
323// #define l5(x) (phi3(x) * l0l1(x))
324// #define l6(x) (phi4(x) * l0l1(x))
325// #define l7(x) (phi5(x) * l0l1(x))
326// #define l8(x) (phi6(x) * l0l1(x))
327// #define l9(x) (phi7(x) * l0l1(x))
328// #define l10(x) (phi8(x) * l0l1(x))
329// #define l11(x) (phi9(x) * l0l1(x))
330//
331// /// derivatives of Lobatto functions
332// #define dl0(x) (-0.5)
333// #define dl1(x) (0.5)
334// #define dl2(x) (sqrt(3.0/2.0) * Legendre1(x))
335// #define dl3(x) (sqrt(5.0/2.0) * Legendre2(x))
336// #define dl4(x) (sqrt(7.0/2.0) * Legendre3(x))
337// #define dl5(x) (sqrt(9.0/2.0) * Legendre4(x))
338// #define dl6(x) (sqrt(11.0/2.0) * Legendre5(x))
339// #define dl7(x) (sqrt(13.0/2.0) * Legendre6(x))
340// #define dl8(x) (sqrt(15.0/2.0) * Legendre7(x))
341// #define dl9(x) (sqrt(17.0/2.0) * Legendre8(x))
342// #define dl10(x) (sqrt(19.0/2.0) * Legendre9(x))
343// #define dl11(x) (sqrt(21.0/2.0) * Legendre10(x))
344
345PetscErrorCode LobattoKernel_polynomials(int p, double s, double *diff_s,
346 double *L, double *diffL,
347 const int dim) {
348 MoFEMFunctionBeginHot;
349#ifndef NDEBUG
350 if (dim < 1)
351 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "dim < 1");
352 if (dim > 3)
353 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "dim > 3");
354 if (p < 0)
355 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "p < 0");
356 if (p > 9)
357 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
358 "Polynomial beyond order 9 is not implemented");
359#endif // NDEBUG
360 if (L) {
361 int l = 0;
362 for (; l != p + 1; l++) {
363 L[l] = f_phi[l](s);
364 }
365 }
366 if (diffL != NULL) {
367#ifndef NDEBUG
368 if (diff_s == NULL) {
369 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA, "diff_s == NULL");
370 }
371#endif // NDEBUG
372 int l = 0;
373 for (; l != p + 1; l++) {
374 double a = f_phix[l](s);
375 diffL[0 * (p + 1) + l] = diff_s[0] * a;
376 if (dim >= 2) {
377 diffL[1 * (p + 1) + l] = diff_s[1] * a;
378 if (dim == 3) {
379 diffL[2 * (p + 1) + l] = diff_s[2] * a;
380 }
381 }
382 }
383 }
384 MoFEMFunctionReturnHot(0);
385}
L
static Index< 'L', 3 > L
Definition: BasicFeTools.hpp:95
p
static Index< 'p', 3 > p
Definition: BasicFeTools.hpp:90
a
constexpr double a
Definition: approx_sphere.cpp:30
f_phi4
static double f_phi4(double x)
Definition: base_functions.c:254
f_phi1
static double f_phi1(double x)
Definition: base_functions.c:251
f_phi0
static double f_phi0(double x)
Definition: base_functions.c:250
f_phi8x
static double f_phi8x(double x)
Definition: base_functions.c:272
IntegratedJacobi_polynomials
PetscErrorCode IntegratedJacobi_polynomials(int p, double alpha, double x, double t, double *diff_x, double *diff_t, double *L, double *diffL, const int dim)
Calculate integrated Jacobi approximation basis.
Definition: base_functions.c:151
f_phi
static double(* f_phi[])(double x)
Definition: base_functions.c:261
f_phi7
static double f_phi7(double x)
Definition: base_functions.c:257
f_phi0x
static double f_phi0x(double x)
Definition: base_functions.c:264
f_phi4x
static double f_phi4x(double x)
Definition: base_functions.c:268
ierr
static PetscErrorCode ierr
Definition: base_functions.c:13
f_phi8
static double f_phi8(double x)
Definition: base_functions.c:258
f_phix
static double(* f_phix[])(double x)
Definition: base_functions.c:275
Jacobi_polynomials
PetscErrorCode Jacobi_polynomials(int p, double alpha, double x, double t, double *diff_x, double *diff_t, double *L, double *diffL, const int dim)
Calculate Jacobi approximation basis.
Definition: base_functions.c:67
f_phi2x
static double f_phi2x(double x)
Definition: base_functions.c:266
f_phi1x
static double f_phi1x(double x)
Definition: base_functions.c:265
f_phi9x
static double f_phi9x(double x)
Definition: base_functions.c:273
f_phi5
static double f_phi5(double x)
Definition: base_functions.c:255
f_phi7x
static double f_phi7x(double x)
Definition: base_functions.c:271
f_phi3x
static double f_phi3x(double x)
Definition: base_functions.c:267
f_phi3
static double f_phi3(double x)
Definition: base_functions.c:253
f_phi5x
static double f_phi5x(double x)
Definition: base_functions.c:269
f_phi6x
static double f_phi6x(double x)
Definition: base_functions.c:270
f_phi9
static double f_phi9(double x)
Definition: base_functions.c:259
f_phi2
static double f_phi2(double x)
Definition: base_functions.c:252
f_phi6
static double f_phi6(double x)
Definition: base_functions.c:256
base_functions.h
LOBATTO_PHI2
#define LOBATTO_PHI2(x)
Definition: base_functions.h:128
LOBATTO_PHI5
#define LOBATTO_PHI5(x)
Definition: base_functions.h:135
LOBATTO_PHI8
#define LOBATTO_PHI8(x)
Definition: base_functions.h:144
LOBATTO_PHI3
#define LOBATTO_PHI3(x)
Definition: base_functions.h:130
LOBATTO_PHI7X
#define LOBATTO_PHI7X(x)
Definition: base_functions.h:172
LOBATTO_PHI0X
#define LOBATTO_PHI0X(x)
Derivatives of kernel functions for Lobbatto base.
Definition: base_functions.h:157
LOBATTO_PHI2X
#define LOBATTO_PHI2X(x)
Definition: base_functions.h:159
LOBATTO_PHI5X
#define LOBATTO_PHI5X(x)
Definition: base_functions.h:166
LOBATTO_PHI0
#define LOBATTO_PHI0(x)
Definitions taken from Hermes2d code.
Definition: base_functions.h:126
LOBATTO_PHI1
#define LOBATTO_PHI1(x)
Definition: base_functions.h:127
LOBATTO_PHI9X
#define LOBATTO_PHI9X(x)
Definition: base_functions.h:179
LOBATTO_PHI4
#define LOBATTO_PHI4(x)
Definition: base_functions.h:132
LOBATTO_PHI8X
#define LOBATTO_PHI8X(x)
Definition: base_functions.h:175
LOBATTO_PHI7
#define LOBATTO_PHI7(x)
Definition: base_functions.h:141
LOBATTO_PHI6
#define LOBATTO_PHI6(x)
Definition: base_functions.h:138
LOBATTO_PHI1X
#define LOBATTO_PHI1X(x)
Definition: base_functions.h:158
LOBATTO_PHI9
#define LOBATTO_PHI9(x)
Definition: base_functions.h:149
LOBATTO_PHI4X
#define LOBATTO_PHI4X(x)
Definition: base_functions.h:163
LOBATTO_PHI6X
#define LOBATTO_PHI6X(x)
Definition: base_functions.h:169
LOBATTO_PHI3X
#define LOBATTO_PHI3X(x)
Definition: base_functions.h:161
definitions.h
useful compiler directives and definitions
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
MOFEM_INVALID_DATA
@ MOFEM_INVALID_DATA
Definition: definitions.h:36
MOFEM_NOT_IMPLEMENTED
@ MOFEM_NOT_IMPLEMENTED
Definition: definitions.h:32
MoFEMFunctionBeginHot
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:440
dim
const int dim
Definition: elec_phys_2D.cpp:12
Legendre_polynomials
PetscErrorCode Legendre_polynomials(int p, double s, double *diff_s, double *L, double *diffL, const int dim)
Calculate Legendre approximation basis.
Definition: base_functions.c:15
Lobatto_polynomials
PetscErrorCode Lobatto_polynomials(int p, double s, double *diff_s, double *L, double *diffL, const int dim)
Calculate Lobatto base functions .
Definition: base_functions.c:199
LobattoKernel_polynomials
PetscErrorCode LobattoKernel_polynomials(int p, double s, double *diff_s, double *L, double *diffL, const int dim)
Calculate Kernel Lobatto base functions.
Definition: base_functions.c:345
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
c
const double c
speed of light (cm/ns)
Definition: initial_diffusion.cpp:39
l
FTensor::Index< 'l', 3 > l
Definition: matrix_function.cpp:21
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20
A
constexpr AssemblyType A
Definition: operators_tests.cpp:30
t
constexpr double t
plate stiffness
Definition: plate.cpp:59
Generated by Doxygen 1.9.5 and hosted at University of Glasgow