v0.15.0
Loading...
Searching...
No Matches
MoFEM::BernsteinBezier Struct Reference

Evaluating BB polynomial. More...

#include "src/approximation/BernsteinBezier.hpp"

Public Member Functions

template<int D, int Side>
MoFEMErrorCode generateIndicesVertex (const int N, int *alpha)
 
template<int D, int Side>
MoFEMErrorCode generateIndicesEdgeOnSimplex (const int N, int *alpha)
 
template<int D, int Side>
MoFEMErrorCode generateIndicesTriOnSimplex (const int N, int *alpha)
 
template<int D>
MoFEMErrorCode genrateDerivativeIndices (const int N, const int n_alpha, const int *alpha, const int *diff, const int n_alpha_diff, const int *alpha_diff, double *c)
 
template<int D>
MoFEMErrorCode domainPoints (const int N, const int n_x, const int n_alpha, const int *alpha, const double *x_k, double *x_alpha)
 
template<int D, bool GRAD_BASE>
MoFEMErrorCode baseFunctions (const int N, const int gdim, const int n_alpha, const int *alpha, const double *lambda, const double *grad_lambda, double *base, double *grad_base)
 

Static Public Member Functions

static MoFEMErrorCode domainPoints3d (const int N, const int n_x, const int n_alpha, const int *alpha, const double *x_k, double *x_alpha)
 Genrate BB points in 3d.
 
Edge BB functions
static MoFEMErrorCode generateIndicesVertexEdge (const int N, int *alpha)
 
static MoFEMErrorCode generateIndicesEdgeEdge (const int N, int *alpha)
 
static MoFEMErrorCode baseFunctionsEdge (const int N, const int gdim, const int n_alpha, const int *alpha, const double *lambda, const double *grad_lambda, double *base, double *grad_base)
 
static MoFEMErrorCode genrateDerivativeIndicesEdges (const int N, const int n_alpha, const int *alpha, const int *diff, const int n_alpha_diff, const int *alpha_diff, double *c)
 
Triangle BB functions
static MoFEMErrorCode generateIndicesVertexTri (const int N, int *alpha)
 
static MoFEMErrorCode generateIndicesEdgeTri (const int N[], int *alpha[])
 
static MoFEMErrorCode generateIndicesEdgeTri (const int side, const int N, int *alpha)
 
static MoFEMErrorCode generateIndicesTriTri (const int N, int *alpha)
 
static MoFEMErrorCode baseFunctionsTri (const int N, const int gdim, const int n_alpha, const int *alpha, const double *lambda, const double *grad_lambda, double *base, double *grad_base)
 
static MoFEMErrorCode genrateDerivativeIndicesTri (const int N, const int n_alpha, const int *alpha, const int *diff, const int n_alpha_diff, const int *alpha_diff, double *c)
 
Tetrahedron BB functions
static MoFEMErrorCode generateIndicesVertexTet (const int N, int *alpha)
 
static MoFEMErrorCode generateIndicesEdgeTet (const int N[], int *alpha[])
 
static MoFEMErrorCode generateIndicesEdgeTet (const int side, const int N, int *alpha)
 
static MoFEMErrorCode generateIndicesTriTet (const int N[], int *alpha[])
 
static MoFEMErrorCode generateIndicesTriTet (const int side, const int N, int *alpha)
 
static MoFEMErrorCode generateIndicesTetTet (const int N, int *alpha)
 
static MoFEMErrorCode baseFunctionsTet (const int N, const int gdim, const int n_alpha, const int *alpha, const double *lambda, const double *grad_lambda, double *base, double *grad_base)
 
static MoFEMErrorCode genrateDerivativeIndicesTet (const int N, const int n_alpha, const int *alpha, const int *diff, const int n_alpha_diff, const int *alpha_diff, double *c)
 

Static Private Member Functions

template<int D, int Side>
static MoFEMErrorCode generateIndicesVertex (const int N, int *alpha)
 Generate BB indices on vertices.
 
template<int D, int Side>
static MoFEMErrorCode generateIndicesEdgeOnSimplex (const int N, int *alpha)
 Genarte BB incices od simplex edges.
 
template<int D, int Side>
static MoFEMErrorCode generateIndicesTriOnSimplex (const int N, int *alpha)
 Generate BB indices on simples triangles.
 
static MoFEMErrorCode generateIndicesTetOnSimplex (const int N, int *alpha)
 Genarte BB indices on simplex.
 
template<int D>
static MoFEMErrorCode genrateDerivativeIndices (const int N, const int n_alpha, const int *alpha, const int *diff, const int n_alpha_diff, const int *alpha_diff, double *c)
 Brief calculate coefficients for directive of base functions.
 
template<int D>
static MoFEMErrorCode domainPoints (const int N, const int n_x, const int n_alpha, const int *alpha, const double *x_k, double *x_alpha)
 Evaluate coordinates of BB points.
 
template<int D, bool GRAD_BASE>
static MoFEMErrorCode baseFunctions (const int N, const int gdim, const int n_alpha, const int *alpha, const double *lambda, const double *grad_lambda, double *base, double *grad_base)
 BB base function.
 

Detailed Description

Evaluating BB polynomial.

Low level class for evaluation of Bernstein-Bezier polynomials and associated tools useful for fast intergartion.

Definition at line 20 of file BernsteinBezier.hpp.

Member Function Documentation

◆ baseFunctions() [1/2]

template<int D, bool GRAD_BASE>
static MoFEMErrorCode MoFEM::BernsteinBezier::baseFunctions ( const int N,
const int gdim,
const int n_alpha,
const int * alpha,
const double * lambda,
const double * grad_lambda,
double * base,
double * grad_base )
inlinestaticprivate

BB base function.

Template Parameters
Ddimension
GRAD_BASEtrue to calculate base
Parameters
Npolynomial order
gdimnumber of evaluation points
n_alphanumber BB base functions
alphaBB coefficients
lambdabarycentric coefficients at evaluating points
grad_lambdagradients of barycentric over spatial coordinates
basebase function
grad_basevector base functions
Returns
MoFEMErrorCode

◆ baseFunctions() [2/2]

template<int D, bool GRAD_BASE>
MoFEMErrorCode MoFEM::BernsteinBezier::baseFunctions ( const int N,
const int gdim,
const int n_alpha,
const int * alpha,
const double * lambda,
const double * grad_lambda,
double * base,
double * grad_base )

Definition at line 292 of file BernsteinBezier.cpp.

295 {
297
298 const int *const alpha0 = alpha;
299 const double fN = boost::math::factorial<double>(N);
300 constexpr int MAX_ALPHA = 12;
301 int max_alpha = *std::max_element(alpha, &alpha[(D + 1) * n_alpha]);
302 if(max_alpha > MAX_ALPHA)
303 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
304 "Is assumed maximal order not to be bigger than %d", MAX_ALPHA);
305 std::array<double, (D + 1) * (MAX_ALPHA + 1)> pow_alpha;
306 std::array<double, (MAX_ALPHA + 1)> factorial_alpha;
307 std::array<double, D + 1> terms, diff_terms;
308 const double *const grad_lambda0 = grad_lambda;
309
310 factorial_alpha[0] = 1;
311 if (max_alpha >= 1)
312 factorial_alpha[1] = 1;
313 if (max_alpha >= 2)
314 for (int a = 2; a <= max_alpha; ++a)
315 factorial_alpha[a] = factorial_alpha[a - 1] * a;
316
317 for (int g = 0; g != gdim; ++g) {
318
319 for (int n = 0; n != D + 1; ++n, ++lambda) {
320 const size_t shift = (MAX_ALPHA + 1) * n;
321 double *pow_alpha_ptr = &pow_alpha[shift];
322 *pow_alpha_ptr = 1;
323
324 if (max_alpha >= 1) {
325 ++pow_alpha_ptr;
326 *pow_alpha_ptr = *lambda;
327 }
328
329 if (max_alpha >= 2)
330 for (int a = 2; a <= max_alpha; ++a) {
331 const double p = (*pow_alpha_ptr) * (*lambda);
332 ++pow_alpha_ptr;
333 *pow_alpha_ptr = p;
334 }
335 }
336
337 for (int n0 = 0; n0 != n_alpha; ++n0) {
338
339 grad_lambda = grad_lambda0;
340
341 double f = factorial_alpha[(*alpha)];
342 double *terms_ptr = terms.data();
343 double *diff_terms_ptr = diff_terms.data();
344 *terms_ptr = pow_alpha[(*alpha)];
345 if (GRAD_BASE) {
346 if (*alpha > 0)
347 *diff_terms_ptr = (*alpha) * pow_alpha[(*alpha) - 1];
348 else
349 *diff_terms_ptr = 0;
350 }
351 *base = *terms_ptr;
352 ++alpha;
353 ++terms_ptr;
354 ++diff_terms_ptr;
355
356 for (int n1 = 1; n1 < D + 1;
357 ++n1, ++alpha, ++terms_ptr, ++diff_terms_ptr) {
358 f *= factorial_alpha[(*alpha)];
359 const size_t shift = (MAX_ALPHA + 1) * n1;
360 *terms_ptr = pow_alpha[shift + (*alpha)];
361 if (GRAD_BASE) {
362 if (*alpha > 0)
363 *diff_terms_ptr = (*alpha) * pow_alpha[shift + (*alpha) - 1];
364 else
365 *diff_terms_ptr = 0;
366 }
367 *base *= *terms_ptr;
368 }
369
370 const double b = fN / f;
371 *base *= b;
372 ++base;
373
374 if (GRAD_BASE) {
375 double *terms_ptr = terms.data();
376 double *diff_terms_ptr = diff_terms.data();
377 double z = *diff_terms_ptr;
378 ++terms_ptr;
379 ++diff_terms_ptr;
380 for (int n2 = 1; n2 != D + 1; ++n2, ++terms_ptr)
381 z *= *terms_ptr;
382
383 for (int d = 0; d != D; ++d, ++grad_lambda)
384 grad_base[d] = z * (*grad_lambda);
385
386 for (int n1 = 1; n1 < D + 1; ++n1) {
387 z = *diff_terms_ptr;
388
389 int n2 = 0;
390 for (terms_ptr = terms.data(); n2 != n1; ++n2, ++terms_ptr)
391 z *= *terms_ptr;
392
393 ++n2;
394 ++terms_ptr;
395
396 for (; n2 < D + 1; ++n2, ++terms_ptr)
397 z *= *terms_ptr;
398
399 for (int d = 0; d != D; ++d, ++grad_lambda)
400 grad_base[d] += z * (*grad_lambda);
401
402 ++diff_terms_ptr;
403 }
404 for (int d = 0; d != D; ++d)
405 grad_base[d] *= b;
406 grad_base += D;
407 }
408
409 }
410
411 alpha = alpha0;
412 }
413
415}
constexpr double a
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
@ MOFEM_DATA_INCONSISTENCY
Definition definitions.h:31
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
static double lambda
double D
const double n
refractive index of diffusive medium
constexpr double g
const int N
Definition speed_test.cpp:3

◆ baseFunctionsEdge()

MoFEMErrorCode BernsteinBezier::baseFunctionsEdge ( const int N,
const int gdim,
const int n_alpha,
const int * alpha,
const double * lambda,
const double * grad_lambda,
double * base,
double * grad_base )
static

Definition at line 417 of file BernsteinBezier.cpp.

420 {
421 if (grad_base)
422 return baseFunctions<1, true>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
423 base, grad_base);
424 else
425 return baseFunctions<1, false>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
426 base, grad_base);
427}
static MoFEMErrorCode baseFunctions(const int N, const int gdim, const int n_alpha, const int *alpha, const double *lambda, const double *grad_lambda, double *base, double *grad_base)
BB base function.

◆ baseFunctionsTet()

MoFEMErrorCode BernsteinBezier::baseFunctionsTet ( const int N,
const int gdim,
const int n_alpha,
const int * alpha,
const double * lambda,
const double * grad_lambda,
double * base,
double * grad_base )
static

Definition at line 441 of file BernsteinBezier.cpp.

444 {
445 if (grad_base)
446 return baseFunctions<3, true>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
447 base, grad_base);
448 else
449 return baseFunctions<3, false>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
450 base, grad_base);
451}

◆ baseFunctionsTri()

MoFEMErrorCode BernsteinBezier::baseFunctionsTri ( const int N,
const int gdim,
const int n_alpha,
const int * alpha,
const double * lambda,
const double * grad_lambda,
double * base,
double * grad_base )
static

Definition at line 429 of file BernsteinBezier.cpp.

432 {
433 if (grad_base)
434 return baseFunctions<2, true>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
435 base, grad_base);
436 else
437 return baseFunctions<2, false>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
438 base, grad_base);
439}

◆ domainPoints() [1/2]

template<int D>
static MoFEMErrorCode MoFEM::BernsteinBezier::domainPoints ( const int N,
const int n_x,
const int n_alpha,
const int * alpha,
const double * x_k,
double * x_alpha )
inlinestaticprivate

Evaluate coordinates of BB points.

Template Parameters
Ddimension
Parameters
Npolynomail order
n_x
n_alpha
alpha
x_kcartesian coordinates of simplex nodes
x_alphaBB points
Returns
MoFEMErrorCode

◆ domainPoints() [2/2]

template<int D>
MoFEMErrorCode MoFEM::BernsteinBezier::domainPoints ( const int N,
const int n_x,
const int n_alpha,
const int * alpha,
const double * x_k,
double * x_alpha )

Definition at line 258 of file BernsteinBezier.cpp.

260 {
261 FTensor::Index<'i', D> i;
263
265 x_alpha, &x_alpha[1], &x_alpha[2]);
266 for (int n0 = 0; n0 != n_alpha; ++n0) {
267 t_x_alpha(i) = 0;
269 x_k, &x_k[1], &x_k[2]);
270 for (int n1 = 0; n1 != n_x; ++n1) {
271 t_x_alpha(i) += static_cast<double>(*alpha) * t_x_k(i);
272 ++t_x_k;
273 ++alpha;
274 }
275 t_x_alpha(i) /= static_cast<double>(N);
276 ++t_x_alpha;
277 }
278
280}
FTensor::Index< 'i', SPACE_DIM > i

◆ domainPoints3d()

MoFEMErrorCode BernsteinBezier::domainPoints3d ( const int N,
const int n_x,
const int n_alpha,
const int * alpha,
const double * x_k,
double * x_alpha )
static

Genrate BB points in 3d.

Parameters
N
n_x
n_alpha
alpha
x_k
x_alpha
Returns
MoFEMErrorCode

Definition at line 282 of file BernsteinBezier.cpp.

286 {
287 return domainPoints<3>(N, n_x, n_alpha, alpha, x_k, x_alpha);
288}
static MoFEMErrorCode domainPoints(const int N, const int n_x, const int n_alpha, const int *alpha, const double *x_k, double *x_alpha)
Evaluate coordinates of BB points.

◆ generateIndicesEdgeEdge()

MoFEMErrorCode BernsteinBezier::generateIndicesEdgeEdge ( const int N,
int * alpha )
static

Definition at line 85 of file BernsteinBezier.cpp.

86 {
88}
static MoFEMErrorCode generateIndicesEdgeOnSimplex(const int N, int *alpha)
Genarte BB incices od simplex edges.

◆ generateIndicesEdgeOnSimplex() [1/2]

template<int D, int Side>
static MoFEMErrorCode MoFEM::BernsteinBezier::generateIndicesEdgeOnSimplex ( const int N,
int * alpha )
inlinestaticprivate

Genarte BB incices od simplex edges.

Template Parameters
D
Side
Parameters
N
alpha
Returns
MoFEMErrorCode

◆ generateIndicesEdgeOnSimplex() [2/2]

template<int D, int Side>
MoFEMErrorCode MoFEM::BernsteinBezier::generateIndicesEdgeOnSimplex ( const int N,
int * alpha )

Definition at line 16 of file BernsteinBezier.cpp.

17 {
18 constexpr int edge_nodes[6][2] = {{0, 1}, {1, 2}, {2, 0},
19 {0, 3}, {1, 3}, {2, 3}};
21 std::fill(alpha, &alpha[(D + 1) * NBEDGE_H1(N)], 0);
22 for (int n = N - 1; n != 0; --n) {
23
24 // + o o o o +
25
26 alpha[edge_nodes[Side][0]] = n;
27 alpha[edge_nodes[Side][1]] = N - n;
28 alpha += D + 1;
29 }
31}
#define NBEDGE_H1(P)
Number of base function on edge for H1 space.

◆ generateIndicesEdgeTet() [1/2]

MoFEMErrorCode BernsteinBezier::generateIndicesEdgeTet ( const int N[],
int * alpha[] )
static

Definition at line 138 of file BernsteinBezier.cpp.

◆ generateIndicesEdgeTet() [2/2]

MoFEMErrorCode BernsteinBezier::generateIndicesEdgeTet ( const int side,
const int N,
int * alpha )
static

Definition at line 150 of file BernsteinBezier.cpp.

152 {
153 switch (side) {
154 case 0:
156 case 1:
158 case 2:
160 case 3:
162 case 4:
164 case 5:
166 default:
168 "Wrong side number, on tetrahedron are edges from 0 to 5 "
169 "in generateIndicesEdgeTet");
170 }
171}
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.

◆ generateIndicesEdgeTri() [1/2]

MoFEMErrorCode BernsteinBezier::generateIndicesEdgeTri ( const int N[],
int * alpha[] )
static

◆ generateIndicesEdgeTri() [2/2]

MoFEMErrorCode BernsteinBezier::generateIndicesEdgeTri ( const int side,
const int N,
int * alpha )
static

Definition at line 108 of file BernsteinBezier.cpp.

110 {
111 switch (side) {
112 case 0:
114 case 1:
116 case 2:
118 default:
119 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
120 "Wrong side number, on triangle are edges from 0 to 2");
121 }
122}

◆ generateIndicesTetOnSimplex()

MoFEMErrorCode BernsteinBezier::generateIndicesTetOnSimplex ( const int N,
int * alpha )
staticprivate

Genarte BB indices on simplex.

\[ \frac{\partial^{|\mathbf{v}|} \phi^n_{\pmb\alpha}}{\partial \pmb\lambda^\mathbf{v}}= \mathbf{c}_{\pmb\alpha\pmb\beta} \phi^{n-|\mathbf{v}|}_{\pmb\beta} \]

Parameters
N
alpha
Returns
MoFEMErrorCode

Definition at line 59 of file BernsteinBezier.cpp.

60 {
62 std::fill(alpha, &alpha[4 * NBVOLUMETET_H1(N)], 0);
63 for (int n0 = 1; n0 != N - 1; ++n0) {
64 for (int n1 = 1; n1 != N - n0; ++n1) {
65 for (int n2 = 1; n2 != N - n0 - n1; ++n2) {
66 alpha[0] = n0;
67 alpha[1] = n1;
68 alpha[2] = n2;
69 alpha[3] = N - n0 - n1 - n2;
70 alpha += 4;
71 }
72 }
73 }
75}
#define NBVOLUMETET_H1(P)
Number of base functions on tetrahedron for H1 space.

◆ generateIndicesTetTet()

MoFEMErrorCode BernsteinBezier::generateIndicesTetTet ( const int N,
int * alpha )
static

Definition at line 201 of file BernsteinBezier.cpp.

201 {
202 return generateIndicesTetOnSimplex(N, alpha);
203}
static MoFEMErrorCode generateIndicesTetOnSimplex(const int N, int *alpha)
Genarte BB indices on simplex.

◆ generateIndicesTriOnSimplex() [1/2]

template<int D, int Side>
static MoFEMErrorCode MoFEM::BernsteinBezier::generateIndicesTriOnSimplex ( const int N,
int * alpha )
inlinestaticprivate

Generate BB indices on simples triangles.

Template Parameters
D
Side
Parameters
N
alpha
Returns
MoFEMErrorCode

◆ generateIndicesTriOnSimplex() [2/2]

template<int D, int Side>
MoFEMErrorCode MoFEM::BernsteinBezier::generateIndicesTriOnSimplex ( const int N,
int * alpha )

Definition at line 34 of file BernsteinBezier.cpp.

35 {
36 constexpr int tri_nodes[4][3] = {{0, 1, 3}, {1, 2, 3}, {0, 2, 3}, {0, 1, 2}};
38 std::fill(alpha, &alpha[(D + 1) * NBFACETRI_H1(N)], 0);
39 for (int n0 = 1; n0 != N - 1; ++n0) {
40 for (int n1 = 1; n1 != N - n0; ++n1) {
41
42 // +
43 // + +
44 // + o +
45 // + o o +
46 // + o o o +
47 // + + + + + +
48
49 alpha[tri_nodes[Side][0]] = n0;
50 alpha[tri_nodes[Side][1]] = n1;
51 alpha[tri_nodes[Side][2]] = N - n0 - n1;
52
53 alpha += D + 1;
54 }
55 }
57}
#define NBFACETRI_H1(P)
Number of base function on triangle for H1 space.

◆ generateIndicesTriTet() [1/2]

MoFEMErrorCode BernsteinBezier::generateIndicesTriTet ( const int N[],
int * alpha[] )
static

Definition at line 173 of file BernsteinBezier.cpp.

174 {
181}
static MoFEMErrorCode generateIndicesTriOnSimplex(const int N, int *alpha)
Generate BB indices on simples triangles.

◆ generateIndicesTriTet() [2/2]

MoFEMErrorCode BernsteinBezier::generateIndicesTriTet ( const int side,
const int N,
int * alpha )
static

Definition at line 183 of file BernsteinBezier.cpp.

184 {
185 switch (side) {
186 case 0:
188 case 1:
190 case 2:
192 case 3:
194 default:
196 "Wrong side number, on tetrahedron are from from 0 to 3 "
197 "in generateIndicesTriTet");
198 }
199}

◆ generateIndicesTriTri()

MoFEMErrorCode BernsteinBezier::generateIndicesTriTri ( const int N,
int * alpha )
static

Definition at line 124 of file BernsteinBezier.cpp.

124 {
126}

◆ generateIndicesVertex() [1/2]

template<int D, int Side>
static MoFEMErrorCode MoFEM::BernsteinBezier::generateIndicesVertex ( const int N,
int * alpha )
inlinestaticprivate

Generate BB indices on vertices.

Template Parameters
D
Side
Parameters
N
alpha
Returns
MoFEMErrorCode

◆ generateIndicesVertex() [2/2]

template<int D, int Side>
MoFEMErrorCode MoFEM::BernsteinBezier::generateIndicesVertex ( const int N,
int * alpha )

Definition at line 9 of file BernsteinBezier.cpp.

9 {
11 alpha[(D + 1) * Side + Side] = N;
13}

◆ generateIndicesVertexEdge()

MoFEMErrorCode BernsteinBezier::generateIndicesVertexEdge ( const int N,
int * alpha )
static

Definition at line 77 of file BernsteinBezier.cpp.

78 {
83}
static MoFEMErrorCode generateIndicesVertex(const int N, int *alpha)
Generate BB indices on vertices.

◆ generateIndicesVertexTet()

MoFEMErrorCode BernsteinBezier::generateIndicesVertexTet ( const int N,
int * alpha )
static

◆ generateIndicesVertexTri()

MoFEMErrorCode BernsteinBezier::generateIndicesVertexTri ( const int N,
int * alpha )
static

◆ genrateDerivativeIndices() [1/2]

template<int D>
static MoFEMErrorCode MoFEM::BernsteinBezier::genrateDerivativeIndices ( const int N,
const int n_alpha,
const int * alpha,
const int * diff,
const int n_alpha_diff,
const int * alpha_diff,
double * c )
staticprivate

Brief calculate coefficients for directive of base functions.

\[ \]

Template Parameters
D
Parameters
N
n_alpha
alpha
diff
n_alpha_diff
alpha_diff
c
Returns
MoFEMErrorCode

◆ genrateDerivativeIndices() [2/2]

template<int D>
MoFEMErrorCode MoFEM::BernsteinBezier::genrateDerivativeIndices ( const int N,
const int n_alpha,
const int * alpha,
const int * diff,
const int n_alpha_diff,
const int * alpha_diff,
double * c )

Definition at line 206 of file BernsteinBezier.cpp.

208 {
210
211 std::fill(c, &c[n_alpha * n_alpha_diff], 0);
212 int abs_diff = diff[0];
213 for (int d = 1; d != D + 1; ++d)
214 abs_diff += diff[d];
215
216 const double b = boost::math::factorial<double>(N) /
217 boost::math::factorial<double>(N - abs_diff);
218
219 for (int i = 0; i != n_alpha; ++i) {
220 for (int j = 0; j != n_alpha_diff; ++j) {
221 int d = 0;
222 for (; d != D + 1; ++d)
223 if (alpha_diff[(D + 1) * j + d] + diff[d] != alpha[(D + 1) * i + d])
224 break;
225 if (d == D + 1) {
226 c[i * n_alpha_diff + j] = b;
227 break;
228 }
229 }
230 }
231
233}
const double c
speed of light (cm/ns)
FTensor::Index< 'j', 3 > j

◆ genrateDerivativeIndicesEdges()

MoFEMErrorCode BernsteinBezier::genrateDerivativeIndicesEdges ( const int N,
const int n_alpha,
const int * alpha,
const int * diff,
const int n_alpha_diff,
const int * alpha_diff,
double * c )
static

Definition at line 235 of file BernsteinBezier.cpp.

237 {
238 return genrateDerivativeIndices<1>(N, n_alpha, alpha, diff, n_alpha_diff,
239 alpha_diff, c);
240}
static MoFEMErrorCode genrateDerivativeIndices(const int N, const int n_alpha, const int *alpha, const int *diff, const int n_alpha_diff, const int *alpha_diff, double *c)
Brief calculate coefficients for directive of base functions.

◆ genrateDerivativeIndicesTet()

MoFEMErrorCode BernsteinBezier::genrateDerivativeIndicesTet ( const int N,
const int n_alpha,
const int * alpha,
const int * diff,
const int n_alpha_diff,
const int * alpha_diff,
double * c )
static

Definition at line 249 of file BernsteinBezier.cpp.

251 {
252 return genrateDerivativeIndices<3>(N, n_alpha, alpha, diff, n_alpha_diff,
253 alpha_diff, c);
254}

◆ genrateDerivativeIndicesTri()

MoFEMErrorCode BernsteinBezier::genrateDerivativeIndicesTri ( const int N,
const int n_alpha,
const int * alpha,
const int * diff,
const int n_alpha_diff,
const int * alpha_diff,
double * c )
static

Definition at line 242 of file BernsteinBezier.cpp.

244 {
245 return genrateDerivativeIndices<2>(N, n_alpha, alpha, diff, n_alpha_diff,
246 alpha_diff, c);
247}

The documentation for this struct was generated from the following files: