97 {
99
102 const int nb_gauss_pts = pts.size2();
103
105 auto &ptr = data.getBBAlphaIndicesSharedPtr(
field_name);
106 if (!ptr)
108 return *ptr;
109 };
110
113 if (!ptr)
115 return *ptr;
116 };
117
119 auto &ptr = data.getBBDiffNSharedPtr(
field_name);
120 if (!ptr)
122 return *ptr;
123 };
124
128 "Wrong size ent of ent data");
131
132 if (vert_ent_data.getN(
NOBASE).size1() != (
unsigned int)nb_gauss_pts)
134 "Base functions or nodes has wrong number of integration points "
135 "for base %s",
138
139
140
141
142 auto &node_order = vert_ent_data.getBBNodeOrder();
143 if (node_order.size() != 2)
145 "Wrong number of vertex orders for BB base: %d",
146 static_cast<int>(node_order.size()));
148 const int edge_order = edge_has_h1 ? edge_ent_data.getOrder() : 0;
149 const int order = std::max({node_order[0], node_order[1], edge_order});
152 "Bernstein-Bezier H1 base requires approximation order >= 1");
153 if (
static_cast<size_t>(
order) >=
156 "Bernstein-Bezier order %d exceeds the supported maximum %d",
order,
157 static_cast<int>(
159 1);
160 for (
int n = 0;
n != 2; ++
n)
161 if (node_order[
n] < 1)
163 "Bernstein-Bezier H1 base requires vertex order between 1 and "
164 "the element order %d; vertex %d has order %d",
168 "Bernstein-Bezier base in H1 space requires uniform approximation "
169 "order on the element: edge has order %d, element order is %d. "
170 "BB functions are not hierarchical, so mixed degrees do not span "
171 "a complete polynomial space. Set one order for the whole H1 "
172 "field (L2 fields are not restricted).",
174
175 auto &vert_get_n = get_base(vert_ent_data);
176 auto &vert_get_diff_n = get_diff_base(vert_ent_data);
177 vert_get_n.resize(nb_gauss_pts, 2, false);
178 vert_get_diff_n.resize(nb_gauss_pts, 2, false);
179 vert_get_n.clear();
180 vert_get_diff_n.clear();
181
182 auto &vertex_alpha = get_alpha(vert_ent_data);
183 vertex_alpha.resize(2, 2, false);
184 vertex_alpha(0, 0) = node_order[0];
185 vertex_alpha(0, 1) = 0;
186 vertex_alpha(1, 0) = 0;
187 vertex_alpha(1, 1) = node_order[1];
188
190 1, nb_gauss_pts, vertex_alpha.size1(), &vertex_alpha(0, 0), &
lambda(0, 0),
192 &vert_get_diff_n(0, 0));
193 std::array<double, 2>
f = {boost::math::factorial<double>(node_order[0]),
194 boost::math::factorial<double>(node_order[1])};
195
196 for (
int g = 0;
g != nb_gauss_pts; ++
g)
197 for (
int n = 0;
n != 2; ++
n) {
198 vert_get_n(
g,
n) *=
f[
n];
199 vert_get_diff_n(
g,
n) *=
f[
n];
200 }
201
202
203
204 const int nb_dofs = edge_has_h1 ?
NBEDGE_H1(edge_order) : 0;
205 auto &edge_get_n = get_base(edge_ent_data);
206 auto &edge_get_diff_n = get_diff_base(edge_ent_data);
207 edge_get_n.resize(nb_gauss_pts, nb_dofs, false);
208 edge_get_diff_n.resize(nb_gauss_pts, nb_dofs, false);
209
210 if (nb_dofs) {
211 auto &edge_alpha = get_alpha(edge_ent_data);
212 edge_alpha.resize(nb_dofs, 2, false);
214 &edge_alpha(0, 0));
216 edge_order, nb_gauss_pts, edge_alpha.size1(), &edge_alpha(0, 0),
218 &edge_get_diff_n(0, 0));
219 } else {
220 edge_ent_data.getBBAlphaIndicesSharedPtr(
field_name).reset();
221 }
222
224}
const double n
refractive index of diffusive medium
UBlasMatrix< double > MatrixDouble
UBlasMatrix< int > MatrixInt
constexpr auto field_name
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 generateIndicesEdgeEdge(const int N, int *alpha)
const std::string fieldName
static constexpr size_t MaxBernsteinBezierOrder
std::array< std::bitset< LASTSPACE >, MBMAXTYPE > spacesOnEntities
spaces on entity types
Public Member Functions inherited from MoFEM::BaseFunction