35 {
39 int nb_gauss_pts = pts.size2();
40
42 auto &ptr = data.getBBAlphaIndicesSharedPtr(
field_name);
43 if (!ptr)
45 return *ptr;
46 };
47
50 if (!ptr)
52 return *ptr;
53 };
54
56 auto &ptr = data.getBBDiffNSharedPtr(
field_name);
57 if (!ptr)
59 return *ptr;
60 };
61
62 auto get_alpha_by_name_ptr =
63 [](auto &data,
64 const std::string &
field_name) -> boost::shared_ptr<MatrixInt> & {
65 return data.getBBAlphaIndicesSharedPtr(
field_name);
66 };
67
68 auto get_base_by_name_ptr =
69 [](auto &data,
70 const std::string &
field_name) -> boost::shared_ptr<MatrixDouble> & {
72 };
73
74 auto get_diff_base_by_name_ptr =
75 [](auto &data,
76 const std::string &
field_name) -> boost::shared_ptr<MatrixDouble> & {
78 };
79
80 auto get_alpha_by_order_ptr =
81 [](
auto &data,
const size_t o) -> boost::shared_ptr<MatrixInt> & {
82 return data.getBBAlphaIndicesByOrderSharedPtr(
o);
83 };
84
85 auto get_base_by_order_ptr =
86 [](
auto &data,
const size_t o) -> boost::shared_ptr<MatrixDouble> & {
87 return data.getBBNByOrderSharedPtr(
o);
88 };
89
90 auto get_diff_base_by_order_ptr =
91 [](
auto &data,
const size_t o) -> boost::shared_ptr<MatrixDouble> & {
92 return data.getBBDiffNByOrderSharedPtr(
o);
93 };
94
96 auto &vert_get_diff_n = get_diff_base(data.
dataOnEntities[MBVERTEX][0]);
97 vert_get_n.resize(nb_gauss_pts, 3, false);
98 vert_get_diff_n.resize(nb_gauss_pts, 6, false);
99
101 (unsigned int)nb_gauss_pts)
103 "Base functions or nodes has wrong number of integration points "
104 "for base %s",
107
109 vertex_alpha.resize(3, 3, false);
110 vertex_alpha.clear();
111 for (
int n = 0;
n != 3; ++
n)
113
115 1,
lambda.size1(), vertex_alpha.size1(), &vertex_alpha(0, 0),
117 &vert_get_diff_n(0, 0));
118 for (
int n = 0;
n != 3; ++
n) {
119 const int f = boost::math::factorial<double>(
121 for (
int g = 0;
g != nb_gauss_pts; ++
g) {
122 vert_get_n(
g,
n) *=
f;
123 for (
int d = 0;
d != 2; ++
d)
124 vert_get_diff_n(
g, 2 *
n + d) *=
f;
125 }
126 }
127
128
132 "Wrong size of ent data");
133
134 constexpr int edges_nodes[3][2] = {{0, 1}, {1, 2}, {2, 0}};
135 for (int ee = 0; ee != 3; ++ee) {
137
138 if (ent_data.getSense() == 0)
140 "Sense of the edge unknown");
141
142 const int sense = ent_data.getSense();
143 const int order = ent_data.getOrder();
144 const int nb_dofs =
NBEDGE_H1(ent_data.getOrder());
145
146 if (nb_dofs) {
147 if (get_alpha_by_order_ptr(ent_data,
order)) {
149 get_alpha_by_order_ptr(ent_data,
order);
151 get_base_by_order_ptr(ent_data,
order);
152 get_diff_base_by_name_ptr(ent_data,
field_name) =
153 get_diff_base_by_order_ptr(ent_data,
order);
154 } else {
155 auto &get_n = get_base(ent_data);
156 auto &get_diff_n = get_diff_base(ent_data);
157 get_n.resize(nb_gauss_pts, nb_dofs, false);
158 get_diff_n.resize(nb_gauss_pts, 2 * nb_dofs, false);
159
161 edge_alpha.resize(nb_dofs, 3, false);
163 &edge_alpha(0, 0));
164 if (sense == -1) {
165 for (
int i = 0;
i != edge_alpha.size1(); ++
i) {
166 int a = edge_alpha(
i, edges_nodes[ee][0]);
167 edge_alpha(
i, edges_nodes[ee][0]) =
168 edge_alpha(
i, edges_nodes[ee][1]);
169 edge_alpha(
i, edges_nodes[ee][1]) =
a;
170 }
171 }
173 order,
lambda.size1(), edge_alpha.size1(), &edge_alpha(0, 0),
175 &get_diff_n(0, 0));
176
177 get_alpha_by_order_ptr(ent_data,
order) =
179 get_base_by_order_ptr(ent_data,
order) =
181 get_diff_base_by_order_ptr(ent_data,
order) =
182 get_diff_base_by_name_ptr(ent_data,
field_name);
183 }
184 }
185 }
186 } else {
187 for (int ee = 0; ee != 3; ++ee) {
189 ent_data.getBBAlphaIndicesSharedPtr(
field_name).reset();
190 auto &get_n = get_base(ent_data);
191 auto &get_diff_n = get_diff_base(ent_data);
192 get_n.resize(nb_gauss_pts, 0, false);
193 get_diff_n.resize(nb_gauss_pts, 0, false);
194 }
195 }
196
200 "Wrong size ent of ent data");
201
203 const int order = ent_data.getOrder();
205 if (get_alpha_by_order_ptr(ent_data,
order)) {
207 get_alpha_by_order_ptr(ent_data,
order);
209 get_base_by_order_ptr(ent_data,
order);
210 get_diff_base_by_name_ptr(ent_data,
field_name) =
211 get_diff_base_by_order_ptr(ent_data,
order);
212 } else {
213
214 auto &get_n = get_base(ent_data);
215 auto &get_diff_n = get_diff_base(ent_data);
216 get_n.resize(nb_gauss_pts, nb_dofs, false);
217 get_diff_n.resize(nb_gauss_pts, 2 * nb_dofs, false);
218 if (nb_dofs) {
219 auto &tri_alpha = get_alpha(ent_data);
220 tri_alpha.resize(nb_dofs, 3, false);
221
224 order,
lambda.size1(), tri_alpha.size1(), &tri_alpha(0, 0),
226 &get_diff_n(0, 0));
227
228 get_alpha_by_order_ptr(ent_data,
order) =
230 get_base_by_order_ptr(ent_data,
order) =
232 get_diff_base_by_order_ptr(ent_data,
order) =
233 get_diff_base_by_name_ptr(ent_data,
field_name);
234 }
235 }
236 } else {
238 ent_data.getBBAlphaIndicesSharedPtr(
field_name).reset();
239 auto &get_n = get_base(ent_data);
240 auto &get_diff_n = get_diff_base(ent_data);
241 get_n.resize(nb_gauss_pts, 0, false);
242 get_diff_n.resize(nb_gauss_pts, 0, false);
243 }
244
246}
FTensor::Index< 'n', SPACE_DIM > n
FTensor::Index< 'i', SPACE_DIM > i
const Tensor1_Expr< const dTensor0< T, Dim, i >, typename promote< T, double >::V, Dim, i > d(const Tensor0< T * > &a, const Index< i, Dim > index, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz)
UBlasMatrix< double > MatrixDouble
UBlasMatrix< int > MatrixInt
constexpr auto field_name
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 generateIndicesTriTri(const int N, int *alpha)
static MoFEMErrorCode generateIndicesEdgeTri(const int N[], int *alpha[])
const std::string fieldName
Public Member Functions inherited from MoFEM::BaseFunction