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

D	dimension
GRAD_BASE	true to calculate base

Parameters

N	polynomial order
gdim	number of evaluation points
n_alpha	number BB base functions
alpha	BB coefficients
lambda	barycentric coefficients at evaluating points
grad_lambda	gradients of barycentric over spatial coordinates
base	base function
grad_base	vector 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.

                                                  {
  MoFEMFunctionBeginHot;
 
  const int *const alpha0 = alpha;
  const double fN = boost::math::factorial<double>(N);
  constexpr int MAX_ALPHA = 12;
  int max_alpha = *std::max_element(alpha, &alpha[(D + 1) * n_alpha]);
  if(max_alpha > MAX_ALPHA)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "Is assumed maximal order not to be bigger than %d", MAX_ALPHA);
  std::array<double, (D + 1) * (MAX_ALPHA + 1)> pow_alpha;
  std::array<double, (MAX_ALPHA + 1)> factorial_alpha;
  std::array<double, D + 1> terms, diff_terms;
  const double *const grad_lambda0 = grad_lambda;
 
  factorial_alpha[0] = 1;
  if (max_alpha >= 1)
    factorial_alpha[1] = 1;
  if (max_alpha >= 2)
    for (int a = 2; a <= max_alpha; ++a)
      factorial_alpha[a] = factorial_alpha[a - 1] * a;
 
  for (int g = 0; g != gdim; ++g) {
 
    for (int n = 0; n != D + 1; ++n, ++lambda) {
      const size_t shift = (MAX_ALPHA + 1) * n;
      double *pow_alpha_ptr = &pow_alpha[shift];
      *pow_alpha_ptr = 1;
 
      if (max_alpha >= 1) {
        ++pow_alpha_ptr;
        *pow_alpha_ptr = *lambda;
      }
 
      if (max_alpha >= 2)
        for (int a = 2; a <= max_alpha; ++a) {
          const double p = (*pow_alpha_ptr) * (*lambda);
          ++pow_alpha_ptr;
          *pow_alpha_ptr = p;
        }
    }
 
    for (int n0 = 0; n0 != n_alpha; ++n0) {
 
      grad_lambda = grad_lambda0;
 
      double f = factorial_alpha[(*alpha)];
      double *terms_ptr = terms.data();
      double *diff_terms_ptr = diff_terms.data();
      *terms_ptr = pow_alpha[(*alpha)];
      if (GRAD_BASE) {
        if (*alpha > 0)
          *diff_terms_ptr = (*alpha) * pow_alpha[(*alpha) - 1];
        else
          *diff_terms_ptr = 0;
      }
      *base = *terms_ptr;
      ++alpha;
      ++terms_ptr;
      ++diff_terms_ptr;
 
      for (int n1 = 1; n1 < D + 1;
           ++n1, ++alpha, ++terms_ptr, ++diff_terms_ptr) {
        f *= factorial_alpha[(*alpha)];
        const size_t shift = (MAX_ALPHA + 1) * n1;
        *terms_ptr = pow_alpha[shift + (*alpha)];
        if (GRAD_BASE) {
          if (*alpha > 0)
            *diff_terms_ptr = (*alpha) * pow_alpha[shift + (*alpha) - 1];
          else
            *diff_terms_ptr = 0;
        }
        *base *= *terms_ptr;
      }
 
      const double b = fN / f;
      *base *= b;
      ++base;
 
      if (GRAD_BASE) {
        double *terms_ptr = terms.data();
        double *diff_terms_ptr = diff_terms.data();
        double z = *diff_terms_ptr;
        ++terms_ptr;
        ++diff_terms_ptr;
        for (int n2 = 1; n2 != D + 1; ++n2, ++terms_ptr) 
          z *= *terms_ptr;
        
        for (int d = 0; d != D; ++d, ++grad_lambda) 
          grad_base[d] = z * (*grad_lambda);
 
        for (int n1 = 1; n1 < D + 1; ++n1) {
          z = *diff_terms_ptr;
 
          int n2 = 0;
          for (terms_ptr = terms.data(); n2 != n1; ++n2, ++terms_ptr)
            z *= *terms_ptr;
 
          ++n2;
          ++terms_ptr;
          
          for (; n2 < D + 1; ++n2, ++terms_ptr)
            z *= *terms_ptr;
 
          for (int d = 0; d != D; ++d, ++grad_lambda) 
            grad_base[d] += z * (*grad_lambda);
 
          ++diff_terms_ptr;
        }
        for (int d = 0; d != D; ++d)
          grad_base[d] *= b;
        grad_base += D;
      }
 
    }
 
    alpha = alpha0;
  }
 
  MoFEMFunctionReturnHot(0);
}

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.

                       {
  if (grad_base)
    return baseFunctions<1, true>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
                                  base, grad_base);
  else
    return baseFunctions<1, false>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
                                   base, grad_base);
}

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.

                       {
  if (grad_base)
    return baseFunctions<3, true>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
                                  base, grad_base);
  else
    return baseFunctions<3, false>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
                                   base, grad_base);
}

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.

                       {
  if (grad_base)
    return baseFunctions<2, true>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
                                  base, grad_base);
  else
    return baseFunctions<2, false>(N, gdim, n_alpha, alpha, lambda, grad_lambda,
                                   base, grad_base);
}

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

D

dimension

Parameters

N	polynomail order
n_x
n_alpha
alpha
x_k	cartesian coordinates of simplex nodes
x_alpha	BB 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.

                                               {
  FTensor::Index<'i', D> i;
  MoFEMFunctionBeginHot;
 
  auto t_x_alpha = FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3>(
      x_alpha, &x_alpha[1], &x_alpha[2]);
  for (int n0 = 0; n0 != n_alpha; ++n0) {
    t_x_alpha(i) = 0;
    auto t_x_k = FTensor::Tensor1<FTensor::PackPtr<const double *, 3>, 3>(
        x_k, &x_k[1], &x_k[2]);
    for (int n1 = 0; n1 != n_x; ++n1) {
      t_x_alpha(i) += static_cast<double>(*alpha) * t_x_k(i);
      ++t_x_k;
      ++alpha;
    }
    t_x_alpha(i) /= static_cast<double>(N);
    ++t_x_alpha;
  }
 
  MoFEMFunctionReturnHot(0);
}

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.

                                                                {
  return domainPoints<3>(N, n_x, n_alpha, alpha, x_k, x_alpha);
}

generateIndicesEdgeEdge()

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

static

Definition at line 85 of file BernsteinBezier.cpp.

                                                                    {
  return generateIndicesEdgeOnSimplex<1, 0>(N, alpha);
}

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.

                                                                         {
  constexpr int edge_nodes[6][2] = {{0, 1}, {1, 2}, {2, 0},
                                    {0, 3}, {1, 3}, {2, 3}};
  MoFEMFunctionBeginHot;
  std::fill(alpha, &alpha[(D + 1) * NBEDGE_H1(N)], 0);
  for (int n = N - 1; n != 0; --n) {
 
    // + o o o o +
 
    alpha[edge_nodes[Side][0]] = n;
    alpha[edge_nodes[Side][1]] = N - n;
    alpha += D + 1;
  }
  MoFEMFunctionReturnHot(0);
}

generateIndicesEdgeTet() [1/2]

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

static

Definition at line 138 of file BernsteinBezier.cpp.

                                                                     {
  MoFEMFunctionBeginHot;
  CHKERR generateIndicesEdgeOnSimplex<3, 0>(N[0], alpha[0]);
  CHKERR generateIndicesEdgeOnSimplex<3, 1>(N[1], alpha[1]);
  CHKERR generateIndicesEdgeOnSimplex<3, 2>(N[2], alpha[2]);
  CHKERR generateIndicesEdgeOnSimplex<3, 3>(N[3], alpha[3]);
  CHKERR generateIndicesEdgeOnSimplex<3, 4>(N[4], alpha[4]);
  CHKERR generateIndicesEdgeOnSimplex<3, 5>(N[5], alpha[5]);
  MoFEMFunctionReturnHot(0);
}

generateIndicesEdgeTet() [2/2]

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

static

Definition at line 150 of file BernsteinBezier.cpp.

                                                                   {
  switch (side) {
  case 0:
    return generateIndicesEdgeOnSimplex<3, 0>(N, alpha);
  case 1:
    return generateIndicesEdgeOnSimplex<3, 1>(N, alpha);
  case 2:
    return generateIndicesEdgeOnSimplex<3, 2>(N, alpha);
  case 3:
    return generateIndicesEdgeOnSimplex<3, 3>(N, alpha);
  case 4:
    return generateIndicesEdgeOnSimplex<3, 4>(N, alpha);
  case 5:
    return generateIndicesEdgeOnSimplex<3, 5>(N, alpha);
  default:
    CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                      "Wrong side number, on tetrahedron are edges from 0 to 5 "
                      "in generateIndicesEdgeTet");
  }
}

generateIndicesEdgeTri() [1/2]

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

static

Definition at line 99 of file BernsteinBezier.cpp.

                                                                     {
  MoFEMFunctionBeginHot;
  CHKERR generateIndicesEdgeOnSimplex<2, 0>(N[0], alpha[0]);
  CHKERR generateIndicesEdgeOnSimplex<2, 1>(N[1], alpha[1]);
  CHKERR generateIndicesEdgeOnSimplex<2, 2>(N[2], alpha[2]);
  MoFEMFunctionReturnHot(0);
}

generateIndicesEdgeTri() [2/2]

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

static

Definition at line 108 of file BernsteinBezier.cpp.

                                                                   {
  switch (side) {
  case 0:
    return generateIndicesEdgeOnSimplex<2, 0>(N, alpha);
  case 1:
    return generateIndicesEdgeOnSimplex<2, 1>(N, alpha);
  case 2:
    return generateIndicesEdgeOnSimplex<2, 2>(N, alpha);
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Wrong side number, on triangle are edges from 0 to 2");
  }
}

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.

                                                                        {
  MoFEMFunctionBeginHot;
  std::fill(alpha, &alpha[4 * NBVOLUMETET_H1(N)], 0);
  for (int n0 = 1; n0 != N - 1; ++n0) {
    for (int n1 = 1; n1 != N - n0; ++n1) {
      for (int n2 = 1; n2 != N - n0 - n1; ++n2) {
        alpha[0] = n0;
        alpha[1] = n1;
        alpha[2] = n2;
        alpha[3] = N - n0 - n1 - n2;
        alpha += 4;
      }
    }
  }
  MoFEMFunctionReturnHot(0);
}

generateIndicesTetTet()

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

static

Definition at line 201 of file BernsteinBezier.cpp.

                                                                             {
  return generateIndicesTetOnSimplex(N, alpha);
}

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.

                                                                        {
  constexpr int tri_nodes[4][3] = {{0, 1, 3}, {1, 2, 3}, {0, 2, 3}, {0, 1, 2}};
  MoFEMFunctionBeginHot;
  std::fill(alpha, &alpha[(D + 1) * NBFACETRI_H1(N)], 0);
  for (int n0 = 1; n0 != N - 1; ++n0) {
    for (int n1 = 1; n1 != N - n0; ++n1) {
 
      // +
      // + +
      // + o +
      // + o o +
      // + o o o +
      // + + + + + +
 
      alpha[tri_nodes[Side][0]] = n0;
      alpha[tri_nodes[Side][1]] = n1;
      alpha[tri_nodes[Side][2]] = N - n0 - n1;
 
      alpha += D + 1;
    }
  }
  MoFEMFunctionReturnHot(0);
}

generateIndicesTriTet() [1/2]

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

static

Definition at line 173 of file BernsteinBezier.cpp.

                                                                    {
  MoFEMFunctionBeginHot;
  CHKERR generateIndicesTriOnSimplex<3, 0>(N[0], alpha[0]);
  CHKERR generateIndicesTriOnSimplex<3, 1>(N[1], alpha[1]);
  CHKERR generateIndicesTriOnSimplex<3, 2>(N[2], alpha[2]);
  CHKERR generateIndicesTriOnSimplex<3, 3>(N[3], alpha[3]);
  MoFEMFunctionReturnHot(0);
}

generateIndicesTriTet() [2/2]

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

static

Definition at line 183 of file BernsteinBezier.cpp.

                                                                               {
  switch (side) {
  case 0:
    return generateIndicesTriOnSimplex<3, 0>(N, alpha);
  case 1:
    return generateIndicesTriOnSimplex<3, 1>(N, alpha);
  case 2:
    return generateIndicesTriOnSimplex<3, 2>(N, alpha);
  case 3:
    return generateIndicesTriOnSimplex<3, 3>(N, alpha);
  default:
    CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                      "Wrong side number, on tetrahedron are from from 0 to 3 "
                      "in generateIndicesTriTet");
  }
}

generateIndicesTriTri()

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

static

Definition at line 124 of file BernsteinBezier.cpp.

                                                                             {
  return generateIndicesTriOnSimplex<2, 3>(N, alpha);
}

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.

                                                                             {
  MoFEMFunctionBeginHot;
  alpha[(D + 1) * Side + Side] = N;
  MoFEMFunctionReturnHot(0);
}

generateIndicesVertexEdge()

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

static

Definition at line 77 of file BernsteinBezier.cpp.

                                                                      {
  MoFEMFunctionBeginHot;
  CHKERR generateIndicesVertex<1, 0>(N, alpha);
  CHKERR generateIndicesVertex<1, 1>(N, alpha);
  MoFEMFunctionReturnHot(0);
}

generateIndicesVertexTet()

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

static

Definition at line 128 of file BernsteinBezier.cpp.

                                                                     {
  MoFEMFunctionBeginHot;
  CHKERR generateIndicesVertex<3, 0>(N, alpha);
  CHKERR generateIndicesVertex<3, 1>(N, alpha);
  CHKERR generateIndicesVertex<3, 2>(N, alpha);
  CHKERR generateIndicesVertex<3, 3>(N, alpha);
  MoFEMFunctionReturnHot(0);
}

generateIndicesVertexTri()

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

static

Definition at line 90 of file BernsteinBezier.cpp.

                                                                     {
  MoFEMFunctionBeginHot;
  CHKERR generateIndicesVertex<2, 0>(N, alpha);
  CHKERR generateIndicesVertex<2, 1>(N, alpha);
  CHKERR generateIndicesVertex<2, 2>(N, alpha);
  MoFEMFunctionReturnHot(0);
}

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.

                                                              {
  MoFEMFunctionBeginHot;
 
  std::fill(c, &c[n_alpha * n_alpha_diff], 0);
  int abs_diff = diff[0];
  for (int d = 1; d != D + 1; ++d)
    abs_diff += diff[d];
 
  const double b = boost::math::factorial<double>(N) /
                   boost::math::factorial<double>(N - abs_diff);
 
  for (int i = 0; i != n_alpha; ++i) {
    for (int j = 0; j != n_alpha_diff; ++j) {
      int d = 0;
      for (; d != D + 1; ++d)
        if (alpha_diff[(D + 1) * j + d] + diff[d] != alpha[(D + 1) * i + d])
          break;
      if (d == D + 1) {
        c[i * n_alpha_diff + j] = b;
        break;
      }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

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.

                                                              {
  return genrateDerivativeIndices<1>(N, n_alpha, alpha, diff, n_alpha_diff,
                                     alpha_diff, c);
}

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.

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

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.

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

---

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

• src/approximation/BernsteinBezier.hpp
• src/approximation/impl/BernsteinBezier.cpp