← Back to branch summary

~chaffra/ffc/main-old

« back to all changes in this revision

Viewing changes to test/regression/references/r_quadrature/NavierStokes.h

  • Committer: Chaffra Affouda
  • Date: 2011-11-30 01:43:26 UTC
  • mfrom: (1675.1.59 work)
  • Revision ID: chaffra@gmail.com-20111130014326-jc5m9ofli3purq4n
merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/regression/references/r_quadrature/NavierStokes.h
1
 
// This code conforms with the UFC specification version 2.0.0
2
 
// and was automatically generated by FFC version 0.9.10.
 
1
// This code conforms with the UFC specification version 2.0.3
 
2
// and was automatically generated by FFC version 1.0-beta2+.
3
3
// 
4
4
// This code was generated with the following parameters:
5
5
// 
149
149
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
150
150
      
151
151
      // Declare helper variables.
152
 
      unsigned int rr = 0;
153
 
      unsigned int ss = 0;
154
152
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
155
153
      
156
154
      // Compute basisvalues.
157
155
      basisvalues[0] = 1.0;
158
156
      basisvalues[1] = tmp0;
159
 
      for (unsigned int r = 0; r < 1; r++)
160
 
      {
161
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
162
 
        ss = r*(r + 1)*(r + 2)/6;
163
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
164
 
      }// end loop over 'r'
165
 
      for (unsigned int r = 0; r < 1; r++)
166
 
      {
167
 
        for (unsigned int s = 0; s < 1 - r; s++)
168
 
        {
169
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
170
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
171
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
172
 
        }// end loop over 's'
173
 
      }// end loop over 'r'
174
 
      for (unsigned int r = 0; r < 2; r++)
175
 
      {
176
 
        for (unsigned int s = 0; s < 2 - r; s++)
177
 
        {
178
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
179
 
          {
180
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
181
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
182
 
          }// end loop over 't'
183
 
        }// end loop over 's'
184
 
      }// end loop over 'r'
 
157
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
158
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
159
      basisvalues[0] *= std::sqrt(0.75);
 
160
      basisvalues[3] *= std::sqrt(1.25);
 
161
      basisvalues[2] *= std::sqrt(2.5);
 
162
      basisvalues[1] *= std::sqrt(7.5);
185
163
      
186
164
      // Table(s) of coefficients.
187
165
      static const double coefficients0[4] = \
201
179
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
202
180
      
203
181
      // Declare helper variables.
204
 
      unsigned int rr = 0;
205
 
      unsigned int ss = 0;
206
182
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
207
183
      
208
184
      // Compute basisvalues.
209
185
      basisvalues[0] = 1.0;
210
186
      basisvalues[1] = tmp0;
211
 
      for (unsigned int r = 0; r < 1; r++)
212
 
      {
213
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
214
 
        ss = r*(r + 1)*(r + 2)/6;
215
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
216
 
      }// end loop over 'r'
217
 
      for (unsigned int r = 0; r < 1; r++)
218
 
      {
219
 
        for (unsigned int s = 0; s < 1 - r; s++)
220
 
        {
221
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
222
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
223
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
224
 
        }// end loop over 's'
225
 
      }// end loop over 'r'
226
 
      for (unsigned int r = 0; r < 2; r++)
227
 
      {
228
 
        for (unsigned int s = 0; s < 2 - r; s++)
229
 
        {
230
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
231
 
          {
232
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
233
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
234
 
          }// end loop over 't'
235
 
        }// end loop over 's'
236
 
      }// end loop over 'r'
 
187
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
188
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
189
      basisvalues[0] *= std::sqrt(0.75);
 
190
      basisvalues[3] *= std::sqrt(1.25);
 
191
      basisvalues[2] *= std::sqrt(2.5);
 
192
      basisvalues[1] *= std::sqrt(7.5);
237
193
      
238
194
      // Table(s) of coefficients.
239
195
      static const double coefficients0[4] = \
253
209
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
254
210
      
255
211
      // Declare helper variables.
256
 
      unsigned int rr = 0;
257
 
      unsigned int ss = 0;
258
212
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
259
213
      
260
214
      // Compute basisvalues.
261
215
      basisvalues[0] = 1.0;
262
216
      basisvalues[1] = tmp0;
263
 
      for (unsigned int r = 0; r < 1; r++)
264
 
      {
265
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
266
 
        ss = r*(r + 1)*(r + 2)/6;
267
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
268
 
      }// end loop over 'r'
269
 
      for (unsigned int r = 0; r < 1; r++)
270
 
      {
271
 
        for (unsigned int s = 0; s < 1 - r; s++)
272
 
        {
273
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
274
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
275
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
276
 
        }// end loop over 's'
277
 
      }// end loop over 'r'
278
 
      for (unsigned int r = 0; r < 2; r++)
279
 
      {
280
 
        for (unsigned int s = 0; s < 2 - r; s++)
281
 
        {
282
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
283
 
          {
284
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
285
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
286
 
          }// end loop over 't'
287
 
        }// end loop over 's'
288
 
      }// end loop over 'r'
 
217
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
218
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
219
      basisvalues[0] *= std::sqrt(0.75);
 
220
      basisvalues[3] *= std::sqrt(1.25);
 
221
      basisvalues[2] *= std::sqrt(2.5);
 
222
      basisvalues[1] *= std::sqrt(7.5);
289
223
      
290
224
      // Table(s) of coefficients.
291
225
      static const double coefficients0[4] = \
305
239
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
306
240
      
307
241
      // Declare helper variables.
308
 
      unsigned int rr = 0;
309
 
      unsigned int ss = 0;
310
242
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
311
243
      
312
244
      // Compute basisvalues.
313
245
      basisvalues[0] = 1.0;
314
246
      basisvalues[1] = tmp0;
315
 
      for (unsigned int r = 0; r < 1; r++)
316
 
      {
317
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
318
 
        ss = r*(r + 1)*(r + 2)/6;
319
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
320
 
      }// end loop over 'r'
321
 
      for (unsigned int r = 0; r < 1; r++)
322
 
      {
323
 
        for (unsigned int s = 0; s < 1 - r; s++)
324
 
        {
325
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
326
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
327
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
328
 
        }// end loop over 's'
329
 
      }// end loop over 'r'
330
 
      for (unsigned int r = 0; r < 2; r++)
331
 
      {
332
 
        for (unsigned int s = 0; s < 2 - r; s++)
333
 
        {
334
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
335
 
          {
336
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
337
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
338
 
          }// end loop over 't'
339
 
        }// end loop over 's'
340
 
      }// end loop over 'r'
 
247
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
248
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
249
      basisvalues[0] *= std::sqrt(0.75);
 
250
      basisvalues[3] *= std::sqrt(1.25);
 
251
      basisvalues[2] *= std::sqrt(2.5);
 
252
      basisvalues[1] *= std::sqrt(7.5);
341
253
      
342
254
      // Table(s) of coefficients.
343
255
      static const double coefficients0[4] = \
500
412
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
501
413
      
502
414
      // Declare helper variables.
503
 
      unsigned int rr = 0;
504
 
      unsigned int ss = 0;
505
415
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
506
416
      
507
417
      // Compute basisvalues.
508
418
      basisvalues[0] = 1.0;
509
419
      basisvalues[1] = tmp0;
510
 
      for (unsigned int r = 0; r < 1; r++)
511
 
      {
512
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
513
 
        ss = r*(r + 1)*(r + 2)/6;
514
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
515
 
      }// end loop over 'r'
516
 
      for (unsigned int r = 0; r < 1; r++)
517
 
      {
518
 
        for (unsigned int s = 0; s < 1 - r; s++)
519
 
        {
520
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
521
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
522
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
523
 
        }// end loop over 's'
524
 
      }// end loop over 'r'
525
 
      for (unsigned int r = 0; r < 2; r++)
526
 
      {
527
 
        for (unsigned int s = 0; s < 2 - r; s++)
528
 
        {
529
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
530
 
          {
531
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
532
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
533
 
          }// end loop over 't'
534
 
        }// end loop over 's'
535
 
      }// end loop over 'r'
 
420
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
421
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
422
      basisvalues[0] *= std::sqrt(0.75);
 
423
      basisvalues[3] *= std::sqrt(1.25);
 
424
      basisvalues[2] *= std::sqrt(2.5);
 
425
      basisvalues[1] *= std::sqrt(7.5);
536
426
      
537
427
      // Table(s) of coefficients.
538
428
      static const double coefficients0[4] = \
694
584
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
695
585
      
696
586
      // Declare helper variables.
697
 
      unsigned int rr = 0;
698
 
      unsigned int ss = 0;
699
587
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
700
588
      
701
589
      // Compute basisvalues.
702
590
      basisvalues[0] = 1.0;
703
591
      basisvalues[1] = tmp0;
704
 
      for (unsigned int r = 0; r < 1; r++)
705
 
      {
706
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
707
 
        ss = r*(r + 1)*(r + 2)/6;
708
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
709
 
      }// end loop over 'r'
710
 
      for (unsigned int r = 0; r < 1; r++)
711
 
      {
712
 
        for (unsigned int s = 0; s < 1 - r; s++)
713
 
        {
714
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
715
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
716
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
717
 
        }// end loop over 's'
718
 
      }// end loop over 'r'
719
 
      for (unsigned int r = 0; r < 2; r++)
720
 
      {
721
 
        for (unsigned int s = 0; s < 2 - r; s++)
722
 
        {
723
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
724
 
          {
725
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
726
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
727
 
          }// end loop over 't'
728
 
        }// end loop over 's'
729
 
      }// end loop over 'r'
 
592
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
593
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
594
      basisvalues[0] *= std::sqrt(0.75);
 
595
      basisvalues[3] *= std::sqrt(1.25);
 
596
      basisvalues[2] *= std::sqrt(2.5);
 
597
      basisvalues[1] *= std::sqrt(7.5);
730
598
      
731
599
      // Table(s) of coefficients.
732
600
      static const double coefficients0[4] = \
888
756
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
889
757
      
890
758
      // Declare helper variables.
891
 
      unsigned int rr = 0;
892
 
      unsigned int ss = 0;
893
759
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
894
760
      
895
761
      // Compute basisvalues.
896
762
      basisvalues[0] = 1.0;
897
763
      basisvalues[1] = tmp0;
898
 
      for (unsigned int r = 0; r < 1; r++)
899
 
      {
900
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
901
 
        ss = r*(r + 1)*(r + 2)/6;
902
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
903
 
      }// end loop over 'r'
904
 
      for (unsigned int r = 0; r < 1; r++)
905
 
      {
906
 
        for (unsigned int s = 0; s < 1 - r; s++)
907
 
        {
908
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
909
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
910
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
911
 
        }// end loop over 's'
912
 
      }// end loop over 'r'
913
 
      for (unsigned int r = 0; r < 2; r++)
914
 
      {
915
 
        for (unsigned int s = 0; s < 2 - r; s++)
916
 
        {
917
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
918
 
          {
919
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
920
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
921
 
          }// end loop over 't'
922
 
        }// end loop over 's'
923
 
      }// end loop over 'r'
 
764
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
765
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
766
      basisvalues[0] *= std::sqrt(0.75);
 
767
      basisvalues[3] *= std::sqrt(1.25);
 
768
      basisvalues[2] *= std::sqrt(2.5);
 
769
      basisvalues[1] *= std::sqrt(7.5);
924
770
      
925
771
      // Table(s) of coefficients.
926
772
      static const double coefficients0[4] = \
1082
928
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1083
929
      
1084
930
      // Declare helper variables.
1085
 
      unsigned int rr = 0;
1086
 
      unsigned int ss = 0;
1087
931
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1088
932
      
1089
933
      // Compute basisvalues.
1090
934
      basisvalues[0] = 1.0;
1091
935
      basisvalues[1] = tmp0;
1092
 
      for (unsigned int r = 0; r < 1; r++)
1093
 
      {
1094
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1095
 
        ss = r*(r + 1)*(r + 2)/6;
1096
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1097
 
      }// end loop over 'r'
1098
 
      for (unsigned int r = 0; r < 1; r++)
1099
 
      {
1100
 
        for (unsigned int s = 0; s < 1 - r; s++)
1101
 
        {
1102
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1103
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1104
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1105
 
        }// end loop over 's'
1106
 
      }// end loop over 'r'
1107
 
      for (unsigned int r = 0; r < 2; r++)
1108
 
      {
1109
 
        for (unsigned int s = 0; s < 2 - r; s++)
1110
 
        {
1111
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
1112
 
          {
1113
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1114
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1115
 
          }// end loop over 't'
1116
 
        }// end loop over 's'
1117
 
      }// end loop over 'r'
 
936
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
937
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
938
      basisvalues[0] *= std::sqrt(0.75);
 
939
      basisvalues[3] *= std::sqrt(1.25);
 
940
      basisvalues[2] *= std::sqrt(2.5);
 
941
      basisvalues[1] *= std::sqrt(7.5);
1118
942
      
1119
943
      // Table(s) of coefficients.
1120
944
      static const double coefficients0[4] = \
1571
1395
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1572
1396
      
1573
1397
      // Declare helper variables.
1574
 
      unsigned int rr = 0;
1575
 
      unsigned int ss = 0;
1576
1398
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1577
1399
      
1578
1400
      // Compute basisvalues.
1579
1401
      basisvalues[0] = 1.0;
1580
1402
      basisvalues[1] = tmp0;
1581
 
      for (unsigned int r = 0; r < 1; r++)
1582
 
      {
1583
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1584
 
        ss = r*(r + 1)*(r + 2)/6;
1585
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1586
 
      }// end loop over 'r'
1587
 
      for (unsigned int r = 0; r < 1; r++)
1588
 
      {
1589
 
        for (unsigned int s = 0; s < 1 - r; s++)
1590
 
        {
1591
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1592
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1593
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1594
 
        }// end loop over 's'
1595
 
      }// end loop over 'r'
1596
 
      for (unsigned int r = 0; r < 2; r++)
1597
 
      {
1598
 
        for (unsigned int s = 0; s < 2 - r; s++)
1599
 
        {
1600
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
1601
 
          {
1602
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1603
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1604
 
          }// end loop over 't'
1605
 
        }// end loop over 's'
1606
 
      }// end loop over 'r'
 
1403
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1404
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1405
      basisvalues[0] *= std::sqrt(0.75);
 
1406
      basisvalues[3] *= std::sqrt(1.25);
 
1407
      basisvalues[2] *= std::sqrt(2.5);
 
1408
      basisvalues[1] *= std::sqrt(7.5);
1607
1409
      
1608
1410
      // Table(s) of coefficients.
1609
1411
      static const double coefficients0[4] = \
1623
1425
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1624
1426
      
1625
1427
      // Declare helper variables.
1626
 
      unsigned int rr = 0;
1627
 
      unsigned int ss = 0;
1628
1428
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1629
1429
      
1630
1430
      // Compute basisvalues.
1631
1431
      basisvalues[0] = 1.0;
1632
1432
      basisvalues[1] = tmp0;
1633
 
      for (unsigned int r = 0; r < 1; r++)
1634
 
      {
1635
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1636
 
        ss = r*(r + 1)*(r + 2)/6;
1637
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1638
 
      }// end loop over 'r'
1639
 
      for (unsigned int r = 0; r < 1; r++)
1640
 
      {
1641
 
        for (unsigned int s = 0; s < 1 - r; s++)
1642
 
        {
1643
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1644
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1645
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1646
 
        }// end loop over 's'
1647
 
      }// end loop over 'r'
1648
 
      for (unsigned int r = 0; r < 2; r++)
1649
 
      {
1650
 
        for (unsigned int s = 0; s < 2 - r; s++)
1651
 
        {
1652
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
1653
 
          {
1654
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1655
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1656
 
          }// end loop over 't'
1657
 
        }// end loop over 's'
1658
 
      }// end loop over 'r'
 
1433
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1434
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1435
      basisvalues[0] *= std::sqrt(0.75);
 
1436
      basisvalues[3] *= std::sqrt(1.25);
 
1437
      basisvalues[2] *= std::sqrt(2.5);
 
1438
      basisvalues[1] *= std::sqrt(7.5);
1659
1439
      
1660
1440
      // Table(s) of coefficients.
1661
1441
      static const double coefficients0[4] = \
1675
1455
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1676
1456
      
1677
1457
      // Declare helper variables.
1678
 
      unsigned int rr = 0;
1679
 
      unsigned int ss = 0;
1680
1458
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1681
1459
      
1682
1460
      // Compute basisvalues.
1683
1461
      basisvalues[0] = 1.0;
1684
1462
      basisvalues[1] = tmp0;
1685
 
      for (unsigned int r = 0; r < 1; r++)
1686
 
      {
1687
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1688
 
        ss = r*(r + 1)*(r + 2)/6;
1689
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1690
 
      }// end loop over 'r'
1691
 
      for (unsigned int r = 0; r < 1; r++)
1692
 
      {
1693
 
        for (unsigned int s = 0; s < 1 - r; s++)
1694
 
        {
1695
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1696
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1697
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1698
 
        }// end loop over 's'
1699
 
      }// end loop over 'r'
1700
 
      for (unsigned int r = 0; r < 2; r++)
1701
 
      {
1702
 
        for (unsigned int s = 0; s < 2 - r; s++)
1703
 
        {
1704
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
1705
 
          {
1706
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1707
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1708
 
          }// end loop over 't'
1709
 
        }// end loop over 's'
1710
 
      }// end loop over 'r'
 
1463
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1464
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1465
      basisvalues[0] *= std::sqrt(0.75);
 
1466
      basisvalues[3] *= std::sqrt(1.25);
 
1467
      basisvalues[2] *= std::sqrt(2.5);
 
1468
      basisvalues[1] *= std::sqrt(7.5);
1711
1469
      
1712
1470
      // Table(s) of coefficients.
1713
1471
      static const double coefficients0[4] = \
1727
1485
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1728
1486
      
1729
1487
      // Declare helper variables.
1730
 
      unsigned int rr = 0;
1731
 
      unsigned int ss = 0;
1732
1488
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1733
1489
      
1734
1490
      // Compute basisvalues.
1735
1491
      basisvalues[0] = 1.0;
1736
1492
      basisvalues[1] = tmp0;
1737
 
      for (unsigned int r = 0; r < 1; r++)
1738
 
      {
1739
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1740
 
        ss = r*(r + 1)*(r + 2)/6;
1741
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1742
 
      }// end loop over 'r'
1743
 
      for (unsigned int r = 0; r < 1; r++)
1744
 
      {
1745
 
        for (unsigned int s = 0; s < 1 - r; s++)
1746
 
        {
1747
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1748
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1749
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1750
 
        }// end loop over 's'
1751
 
      }// end loop over 'r'
1752
 
      for (unsigned int r = 0; r < 2; r++)
1753
 
      {
1754
 
        for (unsigned int s = 0; s < 2 - r; s++)
1755
 
        {
1756
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
1757
 
          {
1758
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1759
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1760
 
          }// end loop over 't'
1761
 
        }// end loop over 's'
1762
 
      }// end loop over 'r'
 
1493
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1494
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1495
      basisvalues[0] *= std::sqrt(0.75);
 
1496
      basisvalues[3] *= std::sqrt(1.25);
 
1497
      basisvalues[2] *= std::sqrt(2.5);
 
1498
      basisvalues[1] *= std::sqrt(7.5);
1763
1499
      
1764
1500
      // Table(s) of coefficients.
1765
1501
      static const double coefficients0[4] = \
1779
1515
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1780
1516
      
1781
1517
      // Declare helper variables.
1782
 
      unsigned int rr = 0;
1783
 
      unsigned int ss = 0;
1784
1518
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1785
1519
      
1786
1520
      // Compute basisvalues.
1787
1521
      basisvalues[0] = 1.0;
1788
1522
      basisvalues[1] = tmp0;
1789
 
      for (unsigned int r = 0; r < 1; r++)
1790
 
      {
1791
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1792
 
        ss = r*(r + 1)*(r + 2)/6;
1793
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1794
 
      }// end loop over 'r'
1795
 
      for (unsigned int r = 0; r < 1; r++)
1796
 
      {
1797
 
        for (unsigned int s = 0; s < 1 - r; s++)
1798
 
        {
1799
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1800
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1801
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1802
 
        }// end loop over 's'
1803
 
      }// end loop over 'r'
1804
 
      for (unsigned int r = 0; r < 2; r++)
1805
 
      {
1806
 
        for (unsigned int s = 0; s < 2 - r; s++)
1807
 
        {
1808
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
1809
 
          {
1810
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1811
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1812
 
          }// end loop over 't'
1813
 
        }// end loop over 's'
1814
 
      }// end loop over 'r'
 
1523
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1524
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1525
      basisvalues[0] *= std::sqrt(0.75);
 
1526
      basisvalues[3] *= std::sqrt(1.25);
 
1527
      basisvalues[2] *= std::sqrt(2.5);
 
1528
      basisvalues[1] *= std::sqrt(7.5);
1815
1529
      
1816
1530
      // Table(s) of coefficients.
1817
1531
      static const double coefficients0[4] = \
1831
1545
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1832
1546
      
1833
1547
      // Declare helper variables.
1834
 
      unsigned int rr = 0;
1835
 
      unsigned int ss = 0;
1836
1548
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1837
1549
      
1838
1550
      // Compute basisvalues.
1839
1551
      basisvalues[0] = 1.0;
1840
1552
      basisvalues[1] = tmp0;
1841
 
      for (unsigned int r = 0; r < 1; r++)
1842
 
      {
1843
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1844
 
        ss = r*(r + 1)*(r + 2)/6;
1845
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1846
 
      }// end loop over 'r'
1847
 
      for (unsigned int r = 0; r < 1; r++)
1848
 
      {
1849
 
        for (unsigned int s = 0; s < 1 - r; s++)
1850
 
        {
1851
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1852
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1853
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1854
 
        }// end loop over 's'
1855
 
      }// end loop over 'r'
1856
 
      for (unsigned int r = 0; r < 2; r++)
1857
 
      {
1858
 
        for (unsigned int s = 0; s < 2 - r; s++)
1859
 
        {
1860
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
1861
 
          {
1862
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1863
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1864
 
          }// end loop over 't'
1865
 
        }// end loop over 's'
1866
 
      }// end loop over 'r'
 
1553
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1554
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1555
      basisvalues[0] *= std::sqrt(0.75);
 
1556
      basisvalues[3] *= std::sqrt(1.25);
 
1557
      basisvalues[2] *= std::sqrt(2.5);
 
1558
      basisvalues[1] *= std::sqrt(7.5);
1867
1559
      
1868
1560
      // Table(s) of coefficients.
1869
1561
      static const double coefficients0[4] = \
1883
1575
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1884
1576
      
1885
1577
      // Declare helper variables.
1886
 
      unsigned int rr = 0;
1887
 
      unsigned int ss = 0;
1888
1578
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1889
1579
      
1890
1580
      // Compute basisvalues.
1891
1581
      basisvalues[0] = 1.0;
1892
1582
      basisvalues[1] = tmp0;
1893
 
      for (unsigned int r = 0; r < 1; r++)
1894
 
      {
1895
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1896
 
        ss = r*(r + 1)*(r + 2)/6;
1897
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1898
 
      }// end loop over 'r'
1899
 
      for (unsigned int r = 0; r < 1; r++)
1900
 
      {
1901
 
        for (unsigned int s = 0; s < 1 - r; s++)
1902
 
        {
1903
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1904
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1905
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1906
 
        }// end loop over 's'
1907
 
      }// end loop over 'r'
1908
 
      for (unsigned int r = 0; r < 2; r++)
1909
 
      {
1910
 
        for (unsigned int s = 0; s < 2 - r; s++)
1911
 
        {
1912
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
1913
 
          {
1914
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1915
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1916
 
          }// end loop over 't'
1917
 
        }// end loop over 's'
1918
 
      }// end loop over 'r'
 
1583
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1584
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1585
      basisvalues[0] *= std::sqrt(0.75);
 
1586
      basisvalues[3] *= std::sqrt(1.25);
 
1587
      basisvalues[2] *= std::sqrt(2.5);
 
1588
      basisvalues[1] *= std::sqrt(7.5);
1919
1589
      
1920
1590
      // Table(s) of coefficients.
1921
1591
      static const double coefficients0[4] = \
1935
1605
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1936
1606
      
1937
1607
      // Declare helper variables.
1938
 
      unsigned int rr = 0;
1939
 
      unsigned int ss = 0;
1940
1608
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1941
1609
      
1942
1610
      // Compute basisvalues.
1943
1611
      basisvalues[0] = 1.0;
1944
1612
      basisvalues[1] = tmp0;
1945
 
      for (unsigned int r = 0; r < 1; r++)
1946
 
      {
1947
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
1948
 
        ss = r*(r + 1)*(r + 2)/6;
1949
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
1950
 
      }// end loop over 'r'
1951
 
      for (unsigned int r = 0; r < 1; r++)
1952
 
      {
1953
 
        for (unsigned int s = 0; s < 1 - r; s++)
1954
 
        {
1955
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
1956
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
1957
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
1958
 
        }// end loop over 's'
1959
 
      }// end loop over 'r'
1960
 
      for (unsigned int r = 0; r < 2; r++)
1961
 
      {
1962
 
        for (unsigned int s = 0; s < 2 - r; s++)
1963
 
        {
1964
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
1965
 
          {
1966
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
1967
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
1968
 
          }// end loop over 't'
1969
 
        }// end loop over 's'
1970
 
      }// end loop over 'r'
 
1613
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1614
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1615
      basisvalues[0] *= std::sqrt(0.75);
 
1616
      basisvalues[3] *= std::sqrt(1.25);
 
1617
      basisvalues[2] *= std::sqrt(2.5);
 
1618
      basisvalues[1] *= std::sqrt(7.5);
1971
1619
      
1972
1620
      // Table(s) of coefficients.
1973
1621
      static const double coefficients0[4] = \
1987
1635
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
1988
1636
      
1989
1637
      // Declare helper variables.
1990
 
      unsigned int rr = 0;
1991
 
      unsigned int ss = 0;
1992
1638
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
1993
1639
      
1994
1640
      // Compute basisvalues.
1995
1641
      basisvalues[0] = 1.0;
1996
1642
      basisvalues[1] = tmp0;
1997
 
      for (unsigned int r = 0; r < 1; r++)
1998
 
      {
1999
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2000
 
        ss = r*(r + 1)*(r + 2)/6;
2001
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2002
 
      }// end loop over 'r'
2003
 
      for (unsigned int r = 0; r < 1; r++)
2004
 
      {
2005
 
        for (unsigned int s = 0; s < 1 - r; s++)
2006
 
        {
2007
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2008
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2009
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2010
 
        }// end loop over 's'
2011
 
      }// end loop over 'r'
2012
 
      for (unsigned int r = 0; r < 2; r++)
2013
 
      {
2014
 
        for (unsigned int s = 0; s < 2 - r; s++)
2015
 
        {
2016
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
2017
 
          {
2018
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2019
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2020
 
          }// end loop over 't'
2021
 
        }// end loop over 's'
2022
 
      }// end loop over 'r'
 
1643
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1644
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1645
      basisvalues[0] *= std::sqrt(0.75);
 
1646
      basisvalues[3] *= std::sqrt(1.25);
 
1647
      basisvalues[2] *= std::sqrt(2.5);
 
1648
      basisvalues[1] *= std::sqrt(7.5);
2023
1649
      
2024
1650
      // Table(s) of coefficients.
2025
1651
      static const double coefficients0[4] = \
2039
1665
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
2040
1666
      
2041
1667
      // Declare helper variables.
2042
 
      unsigned int rr = 0;
2043
 
      unsigned int ss = 0;
2044
1668
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2045
1669
      
2046
1670
      // Compute basisvalues.
2047
1671
      basisvalues[0] = 1.0;
2048
1672
      basisvalues[1] = tmp0;
2049
 
      for (unsigned int r = 0; r < 1; r++)
2050
 
      {
2051
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2052
 
        ss = r*(r + 1)*(r + 2)/6;
2053
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2054
 
      }// end loop over 'r'
2055
 
      for (unsigned int r = 0; r < 1; r++)
2056
 
      {
2057
 
        for (unsigned int s = 0; s < 1 - r; s++)
2058
 
        {
2059
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2060
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2061
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2062
 
        }// end loop over 's'
2063
 
      }// end loop over 'r'
2064
 
      for (unsigned int r = 0; r < 2; r++)
2065
 
      {
2066
 
        for (unsigned int s = 0; s < 2 - r; s++)
2067
 
        {
2068
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
2069
 
          {
2070
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2071
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2072
 
          }// end loop over 't'
2073
 
        }// end loop over 's'
2074
 
      }// end loop over 'r'
 
1673
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1674
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1675
      basisvalues[0] *= std::sqrt(0.75);
 
1676
      basisvalues[3] *= std::sqrt(1.25);
 
1677
      basisvalues[2] *= std::sqrt(2.5);
 
1678
      basisvalues[1] *= std::sqrt(7.5);
2075
1679
      
2076
1680
      // Table(s) of coefficients.
2077
1681
      static const double coefficients0[4] = \
2091
1695
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
2092
1696
      
2093
1697
      // Declare helper variables.
2094
 
      unsigned int rr = 0;
2095
 
      unsigned int ss = 0;
2096
1698
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2097
1699
      
2098
1700
      // Compute basisvalues.
2099
1701
      basisvalues[0] = 1.0;
2100
1702
      basisvalues[1] = tmp0;
2101
 
      for (unsigned int r = 0; r < 1; r++)
2102
 
      {
2103
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2104
 
        ss = r*(r + 1)*(r + 2)/6;
2105
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2106
 
      }// end loop over 'r'
2107
 
      for (unsigned int r = 0; r < 1; r++)
2108
 
      {
2109
 
        for (unsigned int s = 0; s < 1 - r; s++)
2110
 
        {
2111
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2112
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2113
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2114
 
        }// end loop over 's'
2115
 
      }// end loop over 'r'
2116
 
      for (unsigned int r = 0; r < 2; r++)
2117
 
      {
2118
 
        for (unsigned int s = 0; s < 2 - r; s++)
2119
 
        {
2120
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
2121
 
          {
2122
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2123
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2124
 
          }// end loop over 't'
2125
 
        }// end loop over 's'
2126
 
      }// end loop over 'r'
 
1703
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1704
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1705
      basisvalues[0] *= std::sqrt(0.75);
 
1706
      basisvalues[3] *= std::sqrt(1.25);
 
1707
      basisvalues[2] *= std::sqrt(2.5);
 
1708
      basisvalues[1] *= std::sqrt(7.5);
2127
1709
      
2128
1710
      // Table(s) of coefficients.
2129
1711
      static const double coefficients0[4] = \
2143
1725
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
2144
1726
      
2145
1727
      // Declare helper variables.
2146
 
      unsigned int rr = 0;
2147
 
      unsigned int ss = 0;
2148
1728
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2149
1729
      
2150
1730
      // Compute basisvalues.
2151
1731
      basisvalues[0] = 1.0;
2152
1732
      basisvalues[1] = tmp0;
2153
 
      for (unsigned int r = 0; r < 1; r++)
2154
 
      {
2155
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2156
 
        ss = r*(r + 1)*(r + 2)/6;
2157
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2158
 
      }// end loop over 'r'
2159
 
      for (unsigned int r = 0; r < 1; r++)
2160
 
      {
2161
 
        for (unsigned int s = 0; s < 1 - r; s++)
2162
 
        {
2163
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2164
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2165
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2166
 
        }// end loop over 's'
2167
 
      }// end loop over 'r'
2168
 
      for (unsigned int r = 0; r < 2; r++)
2169
 
      {
2170
 
        for (unsigned int s = 0; s < 2 - r; s++)
2171
 
        {
2172
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
2173
 
          {
2174
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2175
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2176
 
          }// end loop over 't'
2177
 
        }// end loop over 's'
2178
 
      }// end loop over 'r'
 
1733
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1734
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1735
      basisvalues[0] *= std::sqrt(0.75);
 
1736
      basisvalues[3] *= std::sqrt(1.25);
 
1737
      basisvalues[2] *= std::sqrt(2.5);
 
1738
      basisvalues[1] *= std::sqrt(7.5);
2179
1739
      
2180
1740
      // Table(s) of coefficients.
2181
1741
      static const double coefficients0[4] = \
2341
1901
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
2342
1902
      
2343
1903
      // Declare helper variables.
2344
 
      unsigned int rr = 0;
2345
 
      unsigned int ss = 0;
2346
1904
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2347
1905
      
2348
1906
      // Compute basisvalues.
2349
1907
      basisvalues[0] = 1.0;
2350
1908
      basisvalues[1] = tmp0;
2351
 
      for (unsigned int r = 0; r < 1; r++)
2352
 
      {
2353
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2354
 
        ss = r*(r + 1)*(r + 2)/6;
2355
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2356
 
      }// end loop over 'r'
2357
 
      for (unsigned int r = 0; r < 1; r++)
2358
 
      {
2359
 
        for (unsigned int s = 0; s < 1 - r; s++)
2360
 
        {
2361
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2362
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2363
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2364
 
        }// end loop over 's'
2365
 
      }// end loop over 'r'
2366
 
      for (unsigned int r = 0; r < 2; r++)
2367
 
      {
2368
 
        for (unsigned int s = 0; s < 2 - r; s++)
2369
 
        {
2370
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
2371
 
          {
2372
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2373
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2374
 
          }// end loop over 't'
2375
 
        }// end loop over 's'
2376
 
      }// end loop over 'r'
 
1909
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
1910
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
1911
      basisvalues[0] *= std::sqrt(0.75);
 
1912
      basisvalues[3] *= std::sqrt(1.25);
 
1913
      basisvalues[2] *= std::sqrt(2.5);
 
1914
      basisvalues[1] *= std::sqrt(7.5);
2377
1915
      
2378
1916
      // Table(s) of coefficients.
2379
1917
      static const double coefficients0[4] = \
2535
2073
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
2536
2074
      
2537
2075
      // Declare helper variables.
2538
 
      unsigned int rr = 0;
2539
 
      unsigned int ss = 0;
2540
2076
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2541
2077
      
2542
2078
      // Compute basisvalues.
2543
2079
      basisvalues[0] = 1.0;
2544
2080
      basisvalues[1] = tmp0;
2545
 
      for (unsigned int r = 0; r < 1; r++)
2546
 
      {
2547
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2548
 
        ss = r*(r + 1)*(r + 2)/6;
2549
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2550
 
      }// end loop over 'r'
2551
 
      for (unsigned int r = 0; r < 1; r++)
2552
 
      {
2553
 
        for (unsigned int s = 0; s < 1 - r; s++)
2554
 
        {
2555
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2556
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2557
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2558
 
        }// end loop over 's'
2559
 
      }// end loop over 'r'
2560
 
      for (unsigned int r = 0; r < 2; r++)
2561
 
      {
2562
 
        for (unsigned int s = 0; s < 2 - r; s++)
2563
 
        {
2564
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
2565
 
          {
2566
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2567
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2568
 
          }// end loop over 't'
2569
 
        }// end loop over 's'
2570
 
      }// end loop over 'r'
 
2081
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
2082
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
2083
      basisvalues[0] *= std::sqrt(0.75);
 
2084
      basisvalues[3] *= std::sqrt(1.25);
 
2085
      basisvalues[2] *= std::sqrt(2.5);
 
2086
      basisvalues[1] *= std::sqrt(7.5);
2571
2087
      
2572
2088
      // Table(s) of coefficients.
2573
2089
      static const double coefficients0[4] = \
2729
2245
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
2730
2246
      
2731
2247
      // Declare helper variables.
2732
 
      unsigned int rr = 0;
2733
 
      unsigned int ss = 0;
2734
2248
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2735
2249
      
2736
2250
      // Compute basisvalues.
2737
2251
      basisvalues[0] = 1.0;
2738
2252
      basisvalues[1] = tmp0;
2739
 
      for (unsigned int r = 0; r < 1; r++)
2740
 
      {
2741
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2742
 
        ss = r*(r + 1)*(r + 2)/6;
2743
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2744
 
      }// end loop over 'r'
2745
 
      for (unsigned int r = 0; r < 1; r++)
2746
 
      {
2747
 
        for (unsigned int s = 0; s < 1 - r; s++)
2748
 
        {
2749
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2750
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2751
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2752
 
        }// end loop over 's'
2753
 
      }// end loop over 'r'
2754
 
      for (unsigned int r = 0; r < 2; r++)
2755
 
      {
2756
 
        for (unsigned int s = 0; s < 2 - r; s++)
2757
 
        {
2758
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
2759
 
          {
2760
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2761
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2762
 
          }// end loop over 't'
2763
 
        }// end loop over 's'
2764
 
      }// end loop over 'r'
 
2253
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
2254
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
2255
      basisvalues[0] *= std::sqrt(0.75);
 
2256
      basisvalues[3] *= std::sqrt(1.25);
 
2257
      basisvalues[2] *= std::sqrt(2.5);
 
2258
      basisvalues[1] *= std::sqrt(7.5);
2765
2259
      
2766
2260
      // Table(s) of coefficients.
2767
2261
      static const double coefficients0[4] = \
2923
2417
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
2924
2418
      
2925
2419
      // Declare helper variables.
2926
 
      unsigned int rr = 0;
2927
 
      unsigned int ss = 0;
2928
2420
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
2929
2421
      
2930
2422
      // Compute basisvalues.
2931
2423
      basisvalues[0] = 1.0;
2932
2424
      basisvalues[1] = tmp0;
2933
 
      for (unsigned int r = 0; r < 1; r++)
2934
 
      {
2935
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
2936
 
        ss = r*(r + 1)*(r + 2)/6;
2937
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
2938
 
      }// end loop over 'r'
2939
 
      for (unsigned int r = 0; r < 1; r++)
2940
 
      {
2941
 
        for (unsigned int s = 0; s < 1 - r; s++)
2942
 
        {
2943
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
2944
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
2945
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
2946
 
        }// end loop over 's'
2947
 
      }// end loop over 'r'
2948
 
      for (unsigned int r = 0; r < 2; r++)
2949
 
      {
2950
 
        for (unsigned int s = 0; s < 2 - r; s++)
2951
 
        {
2952
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
2953
 
          {
2954
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
2955
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
2956
 
          }// end loop over 't'
2957
 
        }// end loop over 's'
2958
 
      }// end loop over 'r'
 
2425
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
2426
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
2427
      basisvalues[0] *= std::sqrt(0.75);
 
2428
      basisvalues[3] *= std::sqrt(1.25);
 
2429
      basisvalues[2] *= std::sqrt(2.5);
 
2430
      basisvalues[1] *= std::sqrt(7.5);
2959
2431
      
2960
2432
      // Table(s) of coefficients.
2961
2433
      static const double coefficients0[4] = \
3117
2589
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
3118
2590
      
3119
2591
      // Declare helper variables.
3120
 
      unsigned int rr = 0;
3121
 
      unsigned int ss = 0;
3122
2592
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
3123
2593
      
3124
2594
      // Compute basisvalues.
3125
2595
      basisvalues[0] = 1.0;
3126
2596
      basisvalues[1] = tmp0;
3127
 
      for (unsigned int r = 0; r < 1; r++)
3128
 
      {
3129
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
3130
 
        ss = r*(r + 1)*(r + 2)/6;
3131
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
3132
 
      }// end loop over 'r'
3133
 
      for (unsigned int r = 0; r < 1; r++)
3134
 
      {
3135
 
        for (unsigned int s = 0; s < 1 - r; s++)
3136
 
        {
3137
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
3138
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3139
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
3140
 
        }// end loop over 's'
3141
 
      }// end loop over 'r'
3142
 
      for (unsigned int r = 0; r < 2; r++)
3143
 
      {
3144
 
        for (unsigned int s = 0; s < 2 - r; s++)
3145
 
        {
3146
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
3147
 
          {
3148
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3149
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
3150
 
          }// end loop over 't'
3151
 
        }// end loop over 's'
3152
 
      }// end loop over 'r'
 
2597
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
2598
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
2599
      basisvalues[0] *= std::sqrt(0.75);
 
2600
      basisvalues[3] *= std::sqrt(1.25);
 
2601
      basisvalues[2] *= std::sqrt(2.5);
 
2602
      basisvalues[1] *= std::sqrt(7.5);
3153
2603
      
3154
2604
      // Table(s) of coefficients.
3155
2605
      static const double coefficients0[4] = \
3311
2761
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
3312
2762
      
3313
2763
      // Declare helper variables.
3314
 
      unsigned int rr = 0;
3315
 
      unsigned int ss = 0;
3316
2764
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
3317
2765
      
3318
2766
      // Compute basisvalues.
3319
2767
      basisvalues[0] = 1.0;
3320
2768
      basisvalues[1] = tmp0;
3321
 
      for (unsigned int r = 0; r < 1; r++)
3322
 
      {
3323
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
3324
 
        ss = r*(r + 1)*(r + 2)/6;
3325
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
3326
 
      }// end loop over 'r'
3327
 
      for (unsigned int r = 0; r < 1; r++)
3328
 
      {
3329
 
        for (unsigned int s = 0; s < 1 - r; s++)
3330
 
        {
3331
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
3332
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3333
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
3334
 
        }// end loop over 's'
3335
 
      }// end loop over 'r'
3336
 
      for (unsigned int r = 0; r < 2; r++)
3337
 
      {
3338
 
        for (unsigned int s = 0; s < 2 - r; s++)
3339
 
        {
3340
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
3341
 
          {
3342
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3343
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
3344
 
          }// end loop over 't'
3345
 
        }// end loop over 's'
3346
 
      }// end loop over 'r'
 
2769
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
2770
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
2771
      basisvalues[0] *= std::sqrt(0.75);
 
2772
      basisvalues[3] *= std::sqrt(1.25);
 
2773
      basisvalues[2] *= std::sqrt(2.5);
 
2774
      basisvalues[1] *= std::sqrt(7.5);
3347
2775
      
3348
2776
      // Table(s) of coefficients.
3349
2777
      static const double coefficients0[4] = \
3505
2933
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
3506
2934
      
3507
2935
      // Declare helper variables.
3508
 
      unsigned int rr = 0;
3509
 
      unsigned int ss = 0;
3510
2936
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
3511
2937
      
3512
2938
      // Compute basisvalues.
3513
2939
      basisvalues[0] = 1.0;
3514
2940
      basisvalues[1] = tmp0;
3515
 
      for (unsigned int r = 0; r < 1; r++)
3516
 
      {
3517
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
3518
 
        ss = r*(r + 1)*(r + 2)/6;
3519
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
3520
 
      }// end loop over 'r'
3521
 
      for (unsigned int r = 0; r < 1; r++)
3522
 
      {
3523
 
        for (unsigned int s = 0; s < 1 - r; s++)
3524
 
        {
3525
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
3526
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3527
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
3528
 
        }// end loop over 's'
3529
 
      }// end loop over 'r'
3530
 
      for (unsigned int r = 0; r < 2; r++)
3531
 
      {
3532
 
        for (unsigned int s = 0; s < 2 - r; s++)
3533
 
        {
3534
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
3535
 
          {
3536
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3537
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
3538
 
          }// end loop over 't'
3539
 
        }// end loop over 's'
3540
 
      }// end loop over 'r'
 
2941
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
2942
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
2943
      basisvalues[0] *= std::sqrt(0.75);
 
2944
      basisvalues[3] *= std::sqrt(1.25);
 
2945
      basisvalues[2] *= std::sqrt(2.5);
 
2946
      basisvalues[1] *= std::sqrt(7.5);
3541
2947
      
3542
2948
      // Table(s) of coefficients.
3543
2949
      static const double coefficients0[4] = \
3699
3105
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
3700
3106
      
3701
3107
      // Declare helper variables.
3702
 
      unsigned int rr = 0;
3703
 
      unsigned int ss = 0;
3704
3108
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
3705
3109
      
3706
3110
      // Compute basisvalues.
3707
3111
      basisvalues[0] = 1.0;
3708
3112
      basisvalues[1] = tmp0;
3709
 
      for (unsigned int r = 0; r < 1; r++)
3710
 
      {
3711
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
3712
 
        ss = r*(r + 1)*(r + 2)/6;
3713
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
3714
 
      }// end loop over 'r'
3715
 
      for (unsigned int r = 0; r < 1; r++)
3716
 
      {
3717
 
        for (unsigned int s = 0; s < 1 - r; s++)
3718
 
        {
3719
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
3720
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3721
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
3722
 
        }// end loop over 's'
3723
 
      }// end loop over 'r'
3724
 
      for (unsigned int r = 0; r < 2; r++)
3725
 
      {
3726
 
        for (unsigned int s = 0; s < 2 - r; s++)
3727
 
        {
3728
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
3729
 
          {
3730
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3731
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
3732
 
          }// end loop over 't'
3733
 
        }// end loop over 's'
3734
 
      }// end loop over 'r'
 
3113
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3114
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3115
      basisvalues[0] *= std::sqrt(0.75);
 
3116
      basisvalues[3] *= std::sqrt(1.25);
 
3117
      basisvalues[2] *= std::sqrt(2.5);
 
3118
      basisvalues[1] *= std::sqrt(7.5);
3735
3119
      
3736
3120
      // Table(s) of coefficients.
3737
3121
      static const double coefficients0[4] = \
3893
3277
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
3894
3278
      
3895
3279
      // Declare helper variables.
3896
 
      unsigned int rr = 0;
3897
 
      unsigned int ss = 0;
3898
3280
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
3899
3281
      
3900
3282
      // Compute basisvalues.
3901
3283
      basisvalues[0] = 1.0;
3902
3284
      basisvalues[1] = tmp0;
3903
 
      for (unsigned int r = 0; r < 1; r++)
3904
 
      {
3905
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
3906
 
        ss = r*(r + 1)*(r + 2)/6;
3907
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
3908
 
      }// end loop over 'r'
3909
 
      for (unsigned int r = 0; r < 1; r++)
3910
 
      {
3911
 
        for (unsigned int s = 0; s < 1 - r; s++)
3912
 
        {
3913
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
3914
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
3915
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
3916
 
        }// end loop over 's'
3917
 
      }// end loop over 'r'
3918
 
      for (unsigned int r = 0; r < 2; r++)
3919
 
      {
3920
 
        for (unsigned int s = 0; s < 2 - r; s++)
3921
 
        {
3922
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
3923
 
          {
3924
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
3925
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
3926
 
          }// end loop over 't'
3927
 
        }// end loop over 's'
3928
 
      }// end loop over 'r'
 
3285
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3286
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3287
      basisvalues[0] *= std::sqrt(0.75);
 
3288
      basisvalues[3] *= std::sqrt(1.25);
 
3289
      basisvalues[2] *= std::sqrt(2.5);
 
3290
      basisvalues[1] *= std::sqrt(7.5);
3929
3291
      
3930
3292
      // Table(s) of coefficients.
3931
3293
      static const double coefficients0[4] = \
4087
3449
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
4088
3450
      
4089
3451
      // Declare helper variables.
4090
 
      unsigned int rr = 0;
4091
 
      unsigned int ss = 0;
4092
3452
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4093
3453
      
4094
3454
      // Compute basisvalues.
4095
3455
      basisvalues[0] = 1.0;
4096
3456
      basisvalues[1] = tmp0;
4097
 
      for (unsigned int r = 0; r < 1; r++)
4098
 
      {
4099
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
4100
 
        ss = r*(r + 1)*(r + 2)/6;
4101
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
4102
 
      }// end loop over 'r'
4103
 
      for (unsigned int r = 0; r < 1; r++)
4104
 
      {
4105
 
        for (unsigned int s = 0; s < 1 - r; s++)
4106
 
        {
4107
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
4108
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4109
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
4110
 
        }// end loop over 's'
4111
 
      }// end loop over 'r'
4112
 
      for (unsigned int r = 0; r < 2; r++)
4113
 
      {
4114
 
        for (unsigned int s = 0; s < 2 - r; s++)
4115
 
        {
4116
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
4117
 
          {
4118
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4119
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
4120
 
          }// end loop over 't'
4121
 
        }// end loop over 's'
4122
 
      }// end loop over 'r'
 
3457
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3458
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3459
      basisvalues[0] *= std::sqrt(0.75);
 
3460
      basisvalues[3] *= std::sqrt(1.25);
 
3461
      basisvalues[2] *= std::sqrt(2.5);
 
3462
      basisvalues[1] *= std::sqrt(7.5);
4123
3463
      
4124
3464
      // Table(s) of coefficients.
4125
3465
      static const double coefficients0[4] = \
4281
3621
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
4282
3622
      
4283
3623
      // Declare helper variables.
4284
 
      unsigned int rr = 0;
4285
 
      unsigned int ss = 0;
4286
3624
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4287
3625
      
4288
3626
      // Compute basisvalues.
4289
3627
      basisvalues[0] = 1.0;
4290
3628
      basisvalues[1] = tmp0;
4291
 
      for (unsigned int r = 0; r < 1; r++)
4292
 
      {
4293
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
4294
 
        ss = r*(r + 1)*(r + 2)/6;
4295
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
4296
 
      }// end loop over 'r'
4297
 
      for (unsigned int r = 0; r < 1; r++)
4298
 
      {
4299
 
        for (unsigned int s = 0; s < 1 - r; s++)
4300
 
        {
4301
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
4302
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4303
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
4304
 
        }// end loop over 's'
4305
 
      }// end loop over 'r'
4306
 
      for (unsigned int r = 0; r < 2; r++)
4307
 
      {
4308
 
        for (unsigned int s = 0; s < 2 - r; s++)
4309
 
        {
4310
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
4311
 
          {
4312
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4313
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
4314
 
          }// end loop over 't'
4315
 
        }// end loop over 's'
4316
 
      }// end loop over 'r'
 
3629
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3630
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3631
      basisvalues[0] *= std::sqrt(0.75);
 
3632
      basisvalues[3] *= std::sqrt(1.25);
 
3633
      basisvalues[2] *= std::sqrt(2.5);
 
3634
      basisvalues[1] *= std::sqrt(7.5);
4317
3635
      
4318
3636
      // Table(s) of coefficients.
4319
3637
      static const double coefficients0[4] = \
4475
3793
      double basisvalues[4] = {0.0, 0.0, 0.0, 0.0};
4476
3794
      
4477
3795
      // Declare helper variables.
4478
 
      unsigned int rr = 0;
4479
 
      unsigned int ss = 0;
4480
3796
      double tmp0 = 0.5*(2.0 + Y + Z + 2.0*X);
4481
3797
      
4482
3798
      // Compute basisvalues.
4483
3799
      basisvalues[0] = 1.0;
4484
3800
      basisvalues[1] = tmp0;
4485
 
      for (unsigned int r = 0; r < 1; r++)
4486
 
      {
4487
 
        rr = (r + 1)*(r + 1 + 1)*(r + 1 + 2)/6 + 1*(1 + 1)/2;
4488
 
        ss = r*(r + 1)*(r + 2)/6;
4489
 
        basisvalues[rr] = basisvalues[ss]*(r*(1.0 + Y) + (2.0 + Z + 3.0*Y)/2.0);
4490
 
      }// end loop over 'r'
4491
 
      for (unsigned int r = 0; r < 1; r++)
4492
 
      {
4493
 
        for (unsigned int s = 0; s < 1 - r; s++)
4494
 
        {
4495
 
          rr = (r + s + 1)*(r + s + 1 + 1)*(r + s + 1 + 2)/6 + (s + 1)*(s + 1 + 1)/2 + 1;
4496
 
          ss = (r + s)*(r + s + 1)*(r + s + 2)/6 + s*(s + 1)/2;
4497
 
          basisvalues[rr] = basisvalues[ss]*(1.0 + r + s + Z*(2.0 + r + s));
4498
 
        }// end loop over 's'
4499
 
      }// end loop over 'r'
4500
 
      for (unsigned int r = 0; r < 2; r++)
4501
 
      {
4502
 
        for (unsigned int s = 0; s < 2 - r; s++)
4503
 
        {
4504
 
          for (unsigned int t = 0; t < 2 - r - s; t++)
4505
 
          {
4506
 
            rr = (r + s + t)*(r + s + t + 1)*(r + s + t + 2)/6 + (s + t)*(s + t + 1)/2 + t;
4507
 
            basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s)*(1.5 + r + s + t));
4508
 
          }// end loop over 't'
4509
 
        }// end loop over 's'
4510
 
      }// end loop over 'r'
 
3801
      basisvalues[2] = 0.5*(2.0 + 3.0*Y + Z)*basisvalues[0];
 
3802
      basisvalues[3] = (2.0*Z + 1.0)*basisvalues[0];
 
3803
      basisvalues[0] *= std::sqrt(0.75);
 
3804
      basisvalues[3] *= std::sqrt(1.25);
 
3805
      basisvalues[2] *= std::sqrt(2.5);
 
3806
      basisvalues[1] *= std::sqrt(7.5);
4511
3807
      
4512
3808
      // Table(s) of coefficients.
4513
3809
      static const double coefficients0[4] = \
5333
4629
  /// Initialize dofmap for mesh (return true iff init_cell() is needed)
5334
4630
  virtual bool init_mesh(const ufc::mesh& m)
5335
4631
  {
5336
 
    _global_dimension = 3.0*m.num_entities[0];
 
4632
    _global_dimension = 3*m.num_entities[0];
5337
4633
    return false;
5338
4634
  }
5339
4635
 
5727
5023
    // Compute circumradius.
5728
5024
    
5729
5025
    
 
5026
    // Facet Area (divide by two because 'det' is scaled by area of reference triangle).
 
5027
    
5730
5028
    // Array of quadrature weights.
5731
5029
    static const double W4[4] = {0.041666667, 0.041666667, 0.041666667, 0.041666667};
5732
5030
    // Quadrature points on the UFC reference element: (0.5854102, 0.1381966, 0.1381966), (0.1381966, 0.5854102, 0.1381966), (0.1381966, 0.1381966, 0.5854102), (0.1381966, 0.1381966, 0.1381966)