~ubuntu-branches/ubuntu/raring/ffc/raring

« back to all changes in this revision

Viewing changes to test/regression/references/FacetIntegrals.h

  • Committer: Bazaar Package Importer
  • Author(s): Johannes Ring
  • Date: 2010-07-01 19:54:32 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20100701195432-xz3gw5nprdj79jcb
Tags: 0.9.3-1
* New upstream release.
* debian/control:
  - Minor fix in Vcs fields.
  - Bump Standards-Version to 3.9.0 (no changes needed).
  - Update version for python-ufc, python-fiat, and python-ufl in
    Depends field.
* Switch to dpkg-source 3.0 (quilt) format.
* Update debian/copyright and debian/copyright_hints.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
// This code conforms with the UFC specification version 1.4
2
 
// and was automatically generated by FFC version 0.9.2.
 
1
// This code conforms with the UFC specification version 1.4.1
 
2
// and was automatically generated by FFC version 0.9.3.
3
3
// 
4
4
// This code was generated with the following parameters:
5
5
// 
96
96
    // Reset values.
97
97
    *values = 0.00000000;
98
98
    
99
 
    // Map degree of freedom to element degree of freedom
100
 
    const unsigned int dof = i;
101
 
    
102
99
    // Array of basisvalues.
103
100
    double basisvalues[1] = {0.00000000};
104
101
    
108
105
    basisvalues[0] = 1.00000000;
109
106
    
110
107
    // Table(s) of coefficients.
111
 
    static const double coefficients0[1][1] = \
112
 
    {{1.00000000}};
 
108
    static const double coefficients0[1] = \
 
109
    {1.00000000};
113
110
    
114
111
    // Compute value(s).
115
112
    for (unsigned int r = 0; r < 1; r++)
116
113
    {
117
 
      *values += coefficients0[dof][r]*basisvalues[r];
 
114
      *values += coefficients0[r]*basisvalues[r];
118
115
    }// end loop over 'r'
119
116
  }
120
117
 
220
217
      values[r] = 0.00000000;
221
218
    }// end loop over 'r'
222
219
    
223
 
    // Map degree of freedom to element degree of freedom
224
 
    const unsigned int dof = i;
225
220
    
226
221
    // Array of basisvalues.
227
222
    double basisvalues[1] = {0.00000000};
232
227
    basisvalues[0] = 1.00000000;
233
228
    
234
229
    // Table(s) of coefficients.
235
 
    static const double coefficients0[1][1] = \
236
 
    {{1.00000000}};
 
230
    static const double coefficients0[1] = \
 
231
    {1.00000000};
237
232
    
238
233
    // Tables of derivatives of the polynomial base (transpose).
239
234
    static const double dmats0[1][1] = \
322
317
      {
323
318
        for (unsigned int t = 0; t < 1; t++)
324
319
        {
325
 
          derivatives[r] += coefficients0[dof][s]*dmats[s][t]*basisvalues[t];
 
320
          derivatives[r] += coefficients0[s]*dmats[s][t]*basisvalues[t];
326
321
        }// end loop over 't'
327
322
      }// end loop over 's'
328
323
    }// end loop over 'r'
508
503
    // Reset values.
509
504
    values[0] = 0.00000000;
510
505
    values[1] = 0.00000000;
511
 
    if (0 <= i && i <= 0)
512
 
    {
513
 
      // Map degree of freedom to element degree of freedom
514
 
      const unsigned int dof = i;
515
 
      
516
 
      // Array of basisvalues.
517
 
      double basisvalues[1] = {0.00000000};
518
 
      
519
 
      // Declare helper variables.
520
 
      
521
 
      // Compute basisvalues.
522
 
      basisvalues[0] = 1.00000000;
523
 
      
524
 
      // Table(s) of coefficients.
525
 
      static const double coefficients0[1][1] = \
526
 
      {{1.00000000}};
527
 
      
528
 
      // Compute value(s).
529
 
      for (unsigned int r = 0; r < 1; r++)
530
 
      {
531
 
        values[0] += coefficients0[dof][r]*basisvalues[r];
532
 
      }// end loop over 'r'
533
 
    }
534
 
    
535
 
    if (1 <= i && i <= 1)
536
 
    {
537
 
      // Map degree of freedom to element degree of freedom
538
 
      const unsigned int dof = i - 1;
539
 
      
540
 
      // Array of basisvalues.
541
 
      double basisvalues[1] = {0.00000000};
542
 
      
543
 
      // Declare helper variables.
544
 
      
545
 
      // Compute basisvalues.
546
 
      basisvalues[0] = 1.00000000;
547
 
      
548
 
      // Table(s) of coefficients.
549
 
      static const double coefficients0[1][1] = \
550
 
      {{1.00000000}};
551
 
      
552
 
      // Compute value(s).
553
 
      for (unsigned int r = 0; r < 1; r++)
554
 
      {
555
 
        values[1] += coefficients0[dof][r]*basisvalues[r];
556
 
      }// end loop over 'r'
 
506
    switch (i)
 
507
    {
 
508
    case 0:
 
509
      {
 
510
        
 
511
      // Array of basisvalues.
 
512
      double basisvalues[1] = {0.00000000};
 
513
      
 
514
      // Declare helper variables.
 
515
      
 
516
      // Compute basisvalues.
 
517
      basisvalues[0] = 1.00000000;
 
518
      
 
519
      // Table(s) of coefficients.
 
520
      static const double coefficients0[1] = \
 
521
      {1.00000000};
 
522
      
 
523
      // Compute value(s).
 
524
      for (unsigned int r = 0; r < 1; r++)
 
525
      {
 
526
        values[0] += coefficients0[r]*basisvalues[r];
 
527
      }// end loop over 'r'
 
528
        break;
 
529
      }
 
530
    case 1:
 
531
      {
 
532
        
 
533
      // Array of basisvalues.
 
534
      double basisvalues[1] = {0.00000000};
 
535
      
 
536
      // Declare helper variables.
 
537
      
 
538
      // Compute basisvalues.
 
539
      basisvalues[0] = 1.00000000;
 
540
      
 
541
      // Table(s) of coefficients.
 
542
      static const double coefficients0[1] = \
 
543
      {1.00000000};
 
544
      
 
545
      // Compute value(s).
 
546
      for (unsigned int r = 0; r < 1; r++)
 
547
      {
 
548
        values[1] += coefficients0[r]*basisvalues[r];
 
549
      }// end loop over 'r'
 
550
        break;
 
551
      }
557
552
    }
558
553
    
559
554
  }
670
665
      values[r] = 0.00000000;
671
666
    }// end loop over 'r'
672
667
    
673
 
    if (0 <= i && i <= 0)
 
668
    switch (i)
674
669
    {
675
 
      // Map degree of freedom to element degree of freedom
676
 
      const unsigned int dof = i;
677
 
      
 
670
    case 0:
 
671
      {
 
672
        
678
673
      // Array of basisvalues.
679
674
      double basisvalues[1] = {0.00000000};
680
675
      
684
679
      basisvalues[0] = 1.00000000;
685
680
      
686
681
      // Table(s) of coefficients.
687
 
      static const double coefficients0[1][1] = \
688
 
      {{1.00000000}};
 
682
      static const double coefficients0[1] = \
 
683
      {1.00000000};
689
684
      
690
685
      // Tables of derivatives of the polynomial base (transpose).
691
686
      static const double dmats0[1][1] = \
774
769
        {
775
770
          for (unsigned int t = 0; t < 1; t++)
776
771
          {
777
 
            derivatives[r] += coefficients0[dof][s]*dmats[s][t]*basisvalues[t];
 
772
            derivatives[r] += coefficients0[s]*dmats[s][t]*basisvalues[t];
778
773
          }// end loop over 't'
779
774
        }// end loop over 's'
780
775
      }// end loop over 'r'
802
797
        delete [] transform[r];
803
798
      }// end loop over 'r'
804
799
      delete [] transform;
805
 
    }
806
 
    
807
 
    if (1 <= i && i <= 1)
808
 
    {
809
 
      // Map degree of freedom to element degree of freedom
810
 
      const unsigned int dof = i - 1;
811
 
      
 
800
        break;
 
801
      }
 
802
    case 1:
 
803
      {
 
804
        
812
805
      // Array of basisvalues.
813
806
      double basisvalues[1] = {0.00000000};
814
807
      
818
811
      basisvalues[0] = 1.00000000;
819
812
      
820
813
      // Table(s) of coefficients.
821
 
      static const double coefficients0[1][1] = \
822
 
      {{1.00000000}};
 
814
      static const double coefficients0[1] = \
 
815
      {1.00000000};
823
816
      
824
817
      // Tables of derivatives of the polynomial base (transpose).
825
818
      static const double dmats0[1][1] = \
908
901
        {
909
902
          for (unsigned int t = 0; t < 1; t++)
910
903
          {
911
 
            derivatives[r] += coefficients0[dof][s]*dmats[s][t]*basisvalues[t];
 
904
            derivatives[r] += coefficients0[s]*dmats[s][t]*basisvalues[t];
912
905
          }// end loop over 't'
913
906
        }// end loop over 's'
914
907
      }// end loop over 'r'
936
929
        delete [] transform[r];
937
930
      }// end loop over 'r'
938
931
      delete [] transform;
 
932
        break;
 
933
      }
939
934
    }
940
935
    
941
936
  }
1150
1145
    
1151
1146
    // Reset values.
1152
1147
    *values = 0.00000000;
1153
 
    
1154
 
    // Map degree of freedom to element degree of freedom
1155
 
    const unsigned int dof = i;
1156
 
    
1157
 
    // Array of basisvalues.
1158
 
    double basisvalues[3] = {0.00000000, 0.00000000, 0.00000000};
1159
 
    
1160
 
    // Declare helper variables.
1161
 
    unsigned int rr = 0;
1162
 
    unsigned int ss = 0;
1163
 
    double tmp0 = (1.00000000 + Y + 2.00000000*X)/2.00000000;
1164
 
    
1165
 
    // Compute basisvalues.
1166
 
    basisvalues[0] = 1.00000000;
1167
 
    basisvalues[1] = tmp0;
1168
 
    for (unsigned int r = 0; r < 1; r++)
1169
 
    {
1170
 
      rr = (r + 1)*(r + 1 + 1)/2 + 1;
1171
 
      ss = r*(r + 1)/2;
1172
 
      basisvalues[rr] = basisvalues[ss]*(0.50000000 + r + Y*(1.50000000 + r));
1173
 
    }// end loop over 'r'
1174
 
    for (unsigned int r = 0; r < 2; r++)
1175
 
    {
1176
 
      for (unsigned int s = 0; s < 2 - r; s++)
1177
 
      {
1178
 
        rr = (r + s)*(r + s + 1)/2 + s;
1179
 
        basisvalues[rr] *= std::sqrt((0.50000000 + r)*(1.00000000 + r + s));
1180
 
      }// end loop over 's'
1181
 
    }// end loop over 'r'
1182
 
    
1183
 
    // Table(s) of coefficients.
1184
 
    static const double coefficients0[3][3] = \
1185
 
    {{0.47140452, -0.28867513, -0.16666667},
1186
 
    {0.47140452, 0.28867513, -0.16666667},
1187
 
    {0.47140452, 0.00000000, 0.33333333}};
1188
 
    
1189
 
    // Compute value(s).
1190
 
    for (unsigned int r = 0; r < 3; r++)
1191
 
    {
1192
 
      *values += coefficients0[dof][r]*basisvalues[r];
1193
 
    }// end loop over 'r'
 
1148
    switch (i)
 
1149
    {
 
1150
    case 0:
 
1151
      {
 
1152
        
 
1153
      // Array of basisvalues.
 
1154
      double basisvalues[3] = {0.00000000, 0.00000000, 0.00000000};
 
1155
      
 
1156
      // Declare helper variables.
 
1157
      unsigned int rr = 0;
 
1158
      unsigned int ss = 0;
 
1159
      double tmp0 = (1.00000000 + Y + 2.00000000*X)/2.00000000;
 
1160
      
 
1161
      // Compute basisvalues.
 
1162
      basisvalues[0] = 1.00000000;
 
1163
      basisvalues[1] = tmp0;
 
1164
      for (unsigned int r = 0; r < 1; r++)
 
1165
      {
 
1166
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
 
1167
        ss = r*(r + 1)/2;
 
1168
        basisvalues[rr] = basisvalues[ss]*(0.50000000 + r + Y*(1.50000000 + r));
 
1169
      }// end loop over 'r'
 
1170
      for (unsigned int r = 0; r < 2; r++)
 
1171
      {
 
1172
        for (unsigned int s = 0; s < 2 - r; s++)
 
1173
        {
 
1174
          rr = (r + s)*(r + s + 1)/2 + s;
 
1175
          basisvalues[rr] *= std::sqrt((0.50000000 + r)*(1.00000000 + r + s));
 
1176
        }// end loop over 's'
 
1177
      }// end loop over 'r'
 
1178
      
 
1179
      // Table(s) of coefficients.
 
1180
      static const double coefficients0[3] = \
 
1181
      {0.47140452, -0.28867513, -0.16666667};
 
1182
      
 
1183
      // Compute value(s).
 
1184
      for (unsigned int r = 0; r < 3; r++)
 
1185
      {
 
1186
        *values += coefficients0[r]*basisvalues[r];
 
1187
      }// end loop over 'r'
 
1188
        break;
 
1189
      }
 
1190
    case 1:
 
1191
      {
 
1192
        
 
1193
      // Array of basisvalues.
 
1194
      double basisvalues[3] = {0.00000000, 0.00000000, 0.00000000};
 
1195
      
 
1196
      // Declare helper variables.
 
1197
      unsigned int rr = 0;
 
1198
      unsigned int ss = 0;
 
1199
      double tmp0 = (1.00000000 + Y + 2.00000000*X)/2.00000000;
 
1200
      
 
1201
      // Compute basisvalues.
 
1202
      basisvalues[0] = 1.00000000;
 
1203
      basisvalues[1] = tmp0;
 
1204
      for (unsigned int r = 0; r < 1; r++)
 
1205
      {
 
1206
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
 
1207
        ss = r*(r + 1)/2;
 
1208
        basisvalues[rr] = basisvalues[ss]*(0.50000000 + r + Y*(1.50000000 + r));
 
1209
      }// end loop over 'r'
 
1210
      for (unsigned int r = 0; r < 2; r++)
 
1211
      {
 
1212
        for (unsigned int s = 0; s < 2 - r; s++)
 
1213
        {
 
1214
          rr = (r + s)*(r + s + 1)/2 + s;
 
1215
          basisvalues[rr] *= std::sqrt((0.50000000 + r)*(1.00000000 + r + s));
 
1216
        }// end loop over 's'
 
1217
      }// end loop over 'r'
 
1218
      
 
1219
      // Table(s) of coefficients.
 
1220
      static const double coefficients0[3] = \
 
1221
      {0.47140452, 0.28867513, -0.16666667};
 
1222
      
 
1223
      // Compute value(s).
 
1224
      for (unsigned int r = 0; r < 3; r++)
 
1225
      {
 
1226
        *values += coefficients0[r]*basisvalues[r];
 
1227
      }// end loop over 'r'
 
1228
        break;
 
1229
      }
 
1230
    case 2:
 
1231
      {
 
1232
        
 
1233
      // Array of basisvalues.
 
1234
      double basisvalues[3] = {0.00000000, 0.00000000, 0.00000000};
 
1235
      
 
1236
      // Declare helper variables.
 
1237
      unsigned int rr = 0;
 
1238
      unsigned int ss = 0;
 
1239
      double tmp0 = (1.00000000 + Y + 2.00000000*X)/2.00000000;
 
1240
      
 
1241
      // Compute basisvalues.
 
1242
      basisvalues[0] = 1.00000000;
 
1243
      basisvalues[1] = tmp0;
 
1244
      for (unsigned int r = 0; r < 1; r++)
 
1245
      {
 
1246
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
 
1247
        ss = r*(r + 1)/2;
 
1248
        basisvalues[rr] = basisvalues[ss]*(0.50000000 + r + Y*(1.50000000 + r));
 
1249
      }// end loop over 'r'
 
1250
      for (unsigned int r = 0; r < 2; r++)
 
1251
      {
 
1252
        for (unsigned int s = 0; s < 2 - r; s++)
 
1253
        {
 
1254
          rr = (r + s)*(r + s + 1)/2 + s;
 
1255
          basisvalues[rr] *= std::sqrt((0.50000000 + r)*(1.00000000 + r + s));
 
1256
        }// end loop over 's'
 
1257
      }// end loop over 'r'
 
1258
      
 
1259
      // Table(s) of coefficients.
 
1260
      static const double coefficients0[3] = \
 
1261
      {0.47140452, 0.00000000, 0.33333333};
 
1262
      
 
1263
      // Compute value(s).
 
1264
      for (unsigned int r = 0; r < 3; r++)
 
1265
      {
 
1266
        *values += coefficients0[r]*basisvalues[r];
 
1267
      }// end loop over 'r'
 
1268
        break;
 
1269
      }
 
1270
    }
 
1271
    
1194
1272
  }
1195
1273
 
1196
1274
  /// Evaluate all basis functions at given point in cell
1306
1384
      values[r] = 0.00000000;
1307
1385
    }// end loop over 'r'
1308
1386
    
1309
 
    // Map degree of freedom to element degree of freedom
1310
 
    const unsigned int dof = i;
1311
 
    
1312
 
    // Array of basisvalues.
1313
 
    double basisvalues[3] = {0.00000000, 0.00000000, 0.00000000};
1314
 
    
1315
 
    // Declare helper variables.
1316
 
    unsigned int rr = 0;
1317
 
    unsigned int ss = 0;
1318
 
    double tmp0 = (1.00000000 + Y + 2.00000000*X)/2.00000000;
1319
 
    
1320
 
    // Compute basisvalues.
1321
 
    basisvalues[0] = 1.00000000;
1322
 
    basisvalues[1] = tmp0;
1323
 
    for (unsigned int r = 0; r < 1; r++)
1324
 
    {
1325
 
      rr = (r + 1)*(r + 1 + 1)/2 + 1;
1326
 
      ss = r*(r + 1)/2;
1327
 
      basisvalues[rr] = basisvalues[ss]*(0.50000000 + r + Y*(1.50000000 + r));
1328
 
    }// end loop over 'r'
1329
 
    for (unsigned int r = 0; r < 2; r++)
1330
 
    {
1331
 
      for (unsigned int s = 0; s < 2 - r; s++)
1332
 
      {
1333
 
        rr = (r + s)*(r + s + 1)/2 + s;
1334
 
        basisvalues[rr] *= std::sqrt((0.50000000 + r)*(1.00000000 + r + s));
1335
 
      }// end loop over 's'
1336
 
    }// end loop over 'r'
1337
 
    
1338
 
    // Table(s) of coefficients.
1339
 
    static const double coefficients0[3][3] = \
1340
 
    {{0.47140452, -0.28867513, -0.16666667},
1341
 
    {0.47140452, 0.28867513, -0.16666667},
1342
 
    {0.47140452, 0.00000000, 0.33333333}};
1343
 
    
1344
 
    // Tables of derivatives of the polynomial base (transpose).
1345
 
    static const double dmats0[3][3] = \
1346
 
    {{0.00000000, 0.00000000, 0.00000000},
1347
 
    {4.89897949, 0.00000000, 0.00000000},
1348
 
    {0.00000000, 0.00000000, 0.00000000}};
1349
 
    
1350
 
    static const double dmats1[3][3] = \
1351
 
    {{0.00000000, 0.00000000, 0.00000000},
1352
 
    {2.44948974, 0.00000000, 0.00000000},
1353
 
    {4.24264069, 0.00000000, 0.00000000}};
1354
 
    
1355
 
    // Compute reference derivatives.
1356
 
    // Declare pointer to array of derivatives on FIAT element.
1357
 
    double *derivatives = new double[num_derivatives];
1358
 
    for (unsigned int r = 0; r < num_derivatives; r++)
1359
 
    {
1360
 
      derivatives[r] = 0.00000000;
1361
 
    }// end loop over 'r'
1362
 
    
1363
 
    // Declare derivative matrix (of polynomial basis).
1364
 
    double dmats[3][3] = \
1365
 
    {{1.00000000, 0.00000000, 0.00000000},
1366
 
    {0.00000000, 1.00000000, 0.00000000},
1367
 
    {0.00000000, 0.00000000, 1.00000000}};
1368
 
    
1369
 
    // Declare (auxiliary) derivative matrix (of polynomial basis).
1370
 
    double dmats_old[3][3] = \
1371
 
    {{1.00000000, 0.00000000, 0.00000000},
1372
 
    {0.00000000, 1.00000000, 0.00000000},
1373
 
    {0.00000000, 0.00000000, 1.00000000}};
1374
 
    
1375
 
    // Loop possible derivatives.
1376
 
    for (unsigned int r = 0; r < num_derivatives; r++)
1377
 
    {
1378
 
      // Resetting dmats values to compute next derivative.
1379
 
      for (unsigned int t = 0; t < 3; t++)
1380
 
      {
1381
 
        for (unsigned int u = 0; u < 3; u++)
1382
 
        {
1383
 
          dmats[t][u] = 0.00000000;
1384
 
          if (t == u)
1385
 
          {
1386
 
          dmats[t][u] = 1.00000000;
1387
 
          }
1388
 
          
1389
 
        }// end loop over 'u'
1390
 
      }// end loop over 't'
1391
 
      
1392
 
      // Looping derivative order to generate dmats.
1393
 
      for (unsigned int s = 0; s < n; s++)
1394
 
      {
1395
 
        // Updating dmats_old with new values and resetting dmats.
1396
 
        for (unsigned int t = 0; t < 3; t++)
1397
 
        {
1398
 
          for (unsigned int u = 0; u < 3; u++)
1399
 
          {
1400
 
            dmats_old[t][u] = dmats[t][u];
1401
 
            dmats[t][u] = 0.00000000;
1402
 
          }// end loop over 'u'
1403
 
        }// end loop over 't'
1404
 
        
1405
 
        // Update dmats using an inner product.
1406
 
        if (combinations[r][s] == 0)
1407
 
        {
1408
 
        for (unsigned int t = 0; t < 3; t++)
1409
 
        {
1410
 
          for (unsigned int u = 0; u < 3; u++)
1411
 
          {
1412
 
            for (unsigned int tu = 0; tu < 3; tu++)
1413
 
            {
1414
 
              dmats[t][u] += dmats0[t][tu]*dmats_old[tu][u];
1415
 
            }// end loop over 'tu'
1416
 
          }// end loop over 'u'
1417
 
        }// end loop over 't'
1418
 
        }
1419
 
        
1420
 
        if (combinations[r][s] == 1)
1421
 
        {
1422
 
        for (unsigned int t = 0; t < 3; t++)
1423
 
        {
1424
 
          for (unsigned int u = 0; u < 3; u++)
1425
 
          {
1426
 
            for (unsigned int tu = 0; tu < 3; tu++)
1427
 
            {
1428
 
              dmats[t][u] += dmats1[t][tu]*dmats_old[tu][u];
1429
 
            }// end loop over 'tu'
1430
 
          }// end loop over 'u'
1431
 
        }// end loop over 't'
1432
 
        }
1433
 
        
1434
 
      }// end loop over 's'
1435
 
      for (unsigned int s = 0; s < 3; s++)
1436
 
      {
1437
 
        for (unsigned int t = 0; t < 3; t++)
1438
 
        {
1439
 
          derivatives[r] += coefficients0[dof][s]*dmats[s][t]*basisvalues[t];
1440
 
        }// end loop over 't'
1441
 
      }// end loop over 's'
1442
 
    }// end loop over 'r'
1443
 
    
1444
 
    // Transform derivatives back to physical element
1445
 
    for (unsigned int r = 0; r < num_derivatives; r++)
1446
 
    {
1447
 
      for (unsigned int s = 0; s < num_derivatives; s++)
1448
 
      {
1449
 
        values[r] += transform[r][s]*derivatives[s];
1450
 
      }// end loop over 's'
1451
 
    }// end loop over 'r'
1452
 
    
1453
 
    // Delete pointer to array of derivatives on FIAT element
1454
 
    delete [] derivatives;
1455
 
    
1456
 
    // Delete pointer to array of combinations of derivatives and transform
1457
 
    for (unsigned int r = 0; r < num_derivatives; r++)
1458
 
    {
1459
 
      delete [] combinations[r];
1460
 
    }// end loop over 'r'
1461
 
    delete [] combinations;
1462
 
    for (unsigned int r = 0; r < num_derivatives; r++)
1463
 
    {
1464
 
      delete [] transform[r];
1465
 
    }// end loop over 'r'
1466
 
    delete [] transform;
 
1387
    switch (i)
 
1388
    {
 
1389
    case 0:
 
1390
      {
 
1391
        
 
1392
      // Array of basisvalues.
 
1393
      double basisvalues[3] = {0.00000000, 0.00000000, 0.00000000};
 
1394
      
 
1395
      // Declare helper variables.
 
1396
      unsigned int rr = 0;
 
1397
      unsigned int ss = 0;
 
1398
      double tmp0 = (1.00000000 + Y + 2.00000000*X)/2.00000000;
 
1399
      
 
1400
      // Compute basisvalues.
 
1401
      basisvalues[0] = 1.00000000;
 
1402
      basisvalues[1] = tmp0;
 
1403
      for (unsigned int r = 0; r < 1; r++)
 
1404
      {
 
1405
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
 
1406
        ss = r*(r + 1)/2;
 
1407
        basisvalues[rr] = basisvalues[ss]*(0.50000000 + r + Y*(1.50000000 + r));
 
1408
      }// end loop over 'r'
 
1409
      for (unsigned int r = 0; r < 2; r++)
 
1410
      {
 
1411
        for (unsigned int s = 0; s < 2 - r; s++)
 
1412
        {
 
1413
          rr = (r + s)*(r + s + 1)/2 + s;
 
1414
          basisvalues[rr] *= std::sqrt((0.50000000 + r)*(1.00000000 + r + s));
 
1415
        }// end loop over 's'
 
1416
      }// end loop over 'r'
 
1417
      
 
1418
      // Table(s) of coefficients.
 
1419
      static const double coefficients0[3] = \
 
1420
      {0.47140452, -0.28867513, -0.16666667};
 
1421
      
 
1422
      // Tables of derivatives of the polynomial base (transpose).
 
1423
      static const double dmats0[3][3] = \
 
1424
      {{0.00000000, 0.00000000, 0.00000000},
 
1425
      {4.89897949, 0.00000000, 0.00000000},
 
1426
      {0.00000000, 0.00000000, 0.00000000}};
 
1427
      
 
1428
      static const double dmats1[3][3] = \
 
1429
      {{0.00000000, 0.00000000, 0.00000000},
 
1430
      {2.44948974, 0.00000000, 0.00000000},
 
1431
      {4.24264069, 0.00000000, 0.00000000}};
 
1432
      
 
1433
      // Compute reference derivatives.
 
1434
      // Declare pointer to array of derivatives on FIAT element.
 
1435
      double *derivatives = new double[num_derivatives];
 
1436
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1437
      {
 
1438
        derivatives[r] = 0.00000000;
 
1439
      }// end loop over 'r'
 
1440
      
 
1441
      // Declare derivative matrix (of polynomial basis).
 
1442
      double dmats[3][3] = \
 
1443
      {{1.00000000, 0.00000000, 0.00000000},
 
1444
      {0.00000000, 1.00000000, 0.00000000},
 
1445
      {0.00000000, 0.00000000, 1.00000000}};
 
1446
      
 
1447
      // Declare (auxiliary) derivative matrix (of polynomial basis).
 
1448
      double dmats_old[3][3] = \
 
1449
      {{1.00000000, 0.00000000, 0.00000000},
 
1450
      {0.00000000, 1.00000000, 0.00000000},
 
1451
      {0.00000000, 0.00000000, 1.00000000}};
 
1452
      
 
1453
      // Loop possible derivatives.
 
1454
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1455
      {
 
1456
        // Resetting dmats values to compute next derivative.
 
1457
        for (unsigned int t = 0; t < 3; t++)
 
1458
        {
 
1459
          for (unsigned int u = 0; u < 3; u++)
 
1460
          {
 
1461
            dmats[t][u] = 0.00000000;
 
1462
            if (t == u)
 
1463
            {
 
1464
            dmats[t][u] = 1.00000000;
 
1465
            }
 
1466
            
 
1467
          }// end loop over 'u'
 
1468
        }// end loop over 't'
 
1469
        
 
1470
        // Looping derivative order to generate dmats.
 
1471
        for (unsigned int s = 0; s < n; s++)
 
1472
        {
 
1473
          // Updating dmats_old with new values and resetting dmats.
 
1474
          for (unsigned int t = 0; t < 3; t++)
 
1475
          {
 
1476
            for (unsigned int u = 0; u < 3; u++)
 
1477
            {
 
1478
              dmats_old[t][u] = dmats[t][u];
 
1479
              dmats[t][u] = 0.00000000;
 
1480
            }// end loop over 'u'
 
1481
          }// end loop over 't'
 
1482
          
 
1483
          // Update dmats using an inner product.
 
1484
          if (combinations[r][s] == 0)
 
1485
          {
 
1486
          for (unsigned int t = 0; t < 3; t++)
 
1487
          {
 
1488
            for (unsigned int u = 0; u < 3; u++)
 
1489
            {
 
1490
              for (unsigned int tu = 0; tu < 3; tu++)
 
1491
              {
 
1492
                dmats[t][u] += dmats0[t][tu]*dmats_old[tu][u];
 
1493
              }// end loop over 'tu'
 
1494
            }// end loop over 'u'
 
1495
          }// end loop over 't'
 
1496
          }
 
1497
          
 
1498
          if (combinations[r][s] == 1)
 
1499
          {
 
1500
          for (unsigned int t = 0; t < 3; t++)
 
1501
          {
 
1502
            for (unsigned int u = 0; u < 3; u++)
 
1503
            {
 
1504
              for (unsigned int tu = 0; tu < 3; tu++)
 
1505
              {
 
1506
                dmats[t][u] += dmats1[t][tu]*dmats_old[tu][u];
 
1507
              }// end loop over 'tu'
 
1508
            }// end loop over 'u'
 
1509
          }// end loop over 't'
 
1510
          }
 
1511
          
 
1512
        }// end loop over 's'
 
1513
        for (unsigned int s = 0; s < 3; s++)
 
1514
        {
 
1515
          for (unsigned int t = 0; t < 3; t++)
 
1516
          {
 
1517
            derivatives[r] += coefficients0[s]*dmats[s][t]*basisvalues[t];
 
1518
          }// end loop over 't'
 
1519
        }// end loop over 's'
 
1520
      }// end loop over 'r'
 
1521
      
 
1522
      // Transform derivatives back to physical element
 
1523
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1524
      {
 
1525
        for (unsigned int s = 0; s < num_derivatives; s++)
 
1526
        {
 
1527
          values[r] += transform[r][s]*derivatives[s];
 
1528
        }// end loop over 's'
 
1529
      }// end loop over 'r'
 
1530
      
 
1531
      // Delete pointer to array of derivatives on FIAT element
 
1532
      delete [] derivatives;
 
1533
      
 
1534
      // Delete pointer to array of combinations of derivatives and transform
 
1535
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1536
      {
 
1537
        delete [] combinations[r];
 
1538
      }// end loop over 'r'
 
1539
      delete [] combinations;
 
1540
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1541
      {
 
1542
        delete [] transform[r];
 
1543
      }// end loop over 'r'
 
1544
      delete [] transform;
 
1545
        break;
 
1546
      }
 
1547
    case 1:
 
1548
      {
 
1549
        
 
1550
      // Array of basisvalues.
 
1551
      double basisvalues[3] = {0.00000000, 0.00000000, 0.00000000};
 
1552
      
 
1553
      // Declare helper variables.
 
1554
      unsigned int rr = 0;
 
1555
      unsigned int ss = 0;
 
1556
      double tmp0 = (1.00000000 + Y + 2.00000000*X)/2.00000000;
 
1557
      
 
1558
      // Compute basisvalues.
 
1559
      basisvalues[0] = 1.00000000;
 
1560
      basisvalues[1] = tmp0;
 
1561
      for (unsigned int r = 0; r < 1; r++)
 
1562
      {
 
1563
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
 
1564
        ss = r*(r + 1)/2;
 
1565
        basisvalues[rr] = basisvalues[ss]*(0.50000000 + r + Y*(1.50000000 + r));
 
1566
      }// end loop over 'r'
 
1567
      for (unsigned int r = 0; r < 2; r++)
 
1568
      {
 
1569
        for (unsigned int s = 0; s < 2 - r; s++)
 
1570
        {
 
1571
          rr = (r + s)*(r + s + 1)/2 + s;
 
1572
          basisvalues[rr] *= std::sqrt((0.50000000 + r)*(1.00000000 + r + s));
 
1573
        }// end loop over 's'
 
1574
      }// end loop over 'r'
 
1575
      
 
1576
      // Table(s) of coefficients.
 
1577
      static const double coefficients0[3] = \
 
1578
      {0.47140452, 0.28867513, -0.16666667};
 
1579
      
 
1580
      // Tables of derivatives of the polynomial base (transpose).
 
1581
      static const double dmats0[3][3] = \
 
1582
      {{0.00000000, 0.00000000, 0.00000000},
 
1583
      {4.89897949, 0.00000000, 0.00000000},
 
1584
      {0.00000000, 0.00000000, 0.00000000}};
 
1585
      
 
1586
      static const double dmats1[3][3] = \
 
1587
      {{0.00000000, 0.00000000, 0.00000000},
 
1588
      {2.44948974, 0.00000000, 0.00000000},
 
1589
      {4.24264069, 0.00000000, 0.00000000}};
 
1590
      
 
1591
      // Compute reference derivatives.
 
1592
      // Declare pointer to array of derivatives on FIAT element.
 
1593
      double *derivatives = new double[num_derivatives];
 
1594
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1595
      {
 
1596
        derivatives[r] = 0.00000000;
 
1597
      }// end loop over 'r'
 
1598
      
 
1599
      // Declare derivative matrix (of polynomial basis).
 
1600
      double dmats[3][3] = \
 
1601
      {{1.00000000, 0.00000000, 0.00000000},
 
1602
      {0.00000000, 1.00000000, 0.00000000},
 
1603
      {0.00000000, 0.00000000, 1.00000000}};
 
1604
      
 
1605
      // Declare (auxiliary) derivative matrix (of polynomial basis).
 
1606
      double dmats_old[3][3] = \
 
1607
      {{1.00000000, 0.00000000, 0.00000000},
 
1608
      {0.00000000, 1.00000000, 0.00000000},
 
1609
      {0.00000000, 0.00000000, 1.00000000}};
 
1610
      
 
1611
      // Loop possible derivatives.
 
1612
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1613
      {
 
1614
        // Resetting dmats values to compute next derivative.
 
1615
        for (unsigned int t = 0; t < 3; t++)
 
1616
        {
 
1617
          for (unsigned int u = 0; u < 3; u++)
 
1618
          {
 
1619
            dmats[t][u] = 0.00000000;
 
1620
            if (t == u)
 
1621
            {
 
1622
            dmats[t][u] = 1.00000000;
 
1623
            }
 
1624
            
 
1625
          }// end loop over 'u'
 
1626
        }// end loop over 't'
 
1627
        
 
1628
        // Looping derivative order to generate dmats.
 
1629
        for (unsigned int s = 0; s < n; s++)
 
1630
        {
 
1631
          // Updating dmats_old with new values and resetting dmats.
 
1632
          for (unsigned int t = 0; t < 3; t++)
 
1633
          {
 
1634
            for (unsigned int u = 0; u < 3; u++)
 
1635
            {
 
1636
              dmats_old[t][u] = dmats[t][u];
 
1637
              dmats[t][u] = 0.00000000;
 
1638
            }// end loop over 'u'
 
1639
          }// end loop over 't'
 
1640
          
 
1641
          // Update dmats using an inner product.
 
1642
          if (combinations[r][s] == 0)
 
1643
          {
 
1644
          for (unsigned int t = 0; t < 3; t++)
 
1645
          {
 
1646
            for (unsigned int u = 0; u < 3; u++)
 
1647
            {
 
1648
              for (unsigned int tu = 0; tu < 3; tu++)
 
1649
              {
 
1650
                dmats[t][u] += dmats0[t][tu]*dmats_old[tu][u];
 
1651
              }// end loop over 'tu'
 
1652
            }// end loop over 'u'
 
1653
          }// end loop over 't'
 
1654
          }
 
1655
          
 
1656
          if (combinations[r][s] == 1)
 
1657
          {
 
1658
          for (unsigned int t = 0; t < 3; t++)
 
1659
          {
 
1660
            for (unsigned int u = 0; u < 3; u++)
 
1661
            {
 
1662
              for (unsigned int tu = 0; tu < 3; tu++)
 
1663
              {
 
1664
                dmats[t][u] += dmats1[t][tu]*dmats_old[tu][u];
 
1665
              }// end loop over 'tu'
 
1666
            }// end loop over 'u'
 
1667
          }// end loop over 't'
 
1668
          }
 
1669
          
 
1670
        }// end loop over 's'
 
1671
        for (unsigned int s = 0; s < 3; s++)
 
1672
        {
 
1673
          for (unsigned int t = 0; t < 3; t++)
 
1674
          {
 
1675
            derivatives[r] += coefficients0[s]*dmats[s][t]*basisvalues[t];
 
1676
          }// end loop over 't'
 
1677
        }// end loop over 's'
 
1678
      }// end loop over 'r'
 
1679
      
 
1680
      // Transform derivatives back to physical element
 
1681
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1682
      {
 
1683
        for (unsigned int s = 0; s < num_derivatives; s++)
 
1684
        {
 
1685
          values[r] += transform[r][s]*derivatives[s];
 
1686
        }// end loop over 's'
 
1687
      }// end loop over 'r'
 
1688
      
 
1689
      // Delete pointer to array of derivatives on FIAT element
 
1690
      delete [] derivatives;
 
1691
      
 
1692
      // Delete pointer to array of combinations of derivatives and transform
 
1693
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1694
      {
 
1695
        delete [] combinations[r];
 
1696
      }// end loop over 'r'
 
1697
      delete [] combinations;
 
1698
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1699
      {
 
1700
        delete [] transform[r];
 
1701
      }// end loop over 'r'
 
1702
      delete [] transform;
 
1703
        break;
 
1704
      }
 
1705
    case 2:
 
1706
      {
 
1707
        
 
1708
      // Array of basisvalues.
 
1709
      double basisvalues[3] = {0.00000000, 0.00000000, 0.00000000};
 
1710
      
 
1711
      // Declare helper variables.
 
1712
      unsigned int rr = 0;
 
1713
      unsigned int ss = 0;
 
1714
      double tmp0 = (1.00000000 + Y + 2.00000000*X)/2.00000000;
 
1715
      
 
1716
      // Compute basisvalues.
 
1717
      basisvalues[0] = 1.00000000;
 
1718
      basisvalues[1] = tmp0;
 
1719
      for (unsigned int r = 0; r < 1; r++)
 
1720
      {
 
1721
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
 
1722
        ss = r*(r + 1)/2;
 
1723
        basisvalues[rr] = basisvalues[ss]*(0.50000000 + r + Y*(1.50000000 + r));
 
1724
      }// end loop over 'r'
 
1725
      for (unsigned int r = 0; r < 2; r++)
 
1726
      {
 
1727
        for (unsigned int s = 0; s < 2 - r; s++)
 
1728
        {
 
1729
          rr = (r + s)*(r + s + 1)/2 + s;
 
1730
          basisvalues[rr] *= std::sqrt((0.50000000 + r)*(1.00000000 + r + s));
 
1731
        }// end loop over 's'
 
1732
      }// end loop over 'r'
 
1733
      
 
1734
      // Table(s) of coefficients.
 
1735
      static const double coefficients0[3] = \
 
1736
      {0.47140452, 0.00000000, 0.33333333};
 
1737
      
 
1738
      // Tables of derivatives of the polynomial base (transpose).
 
1739
      static const double dmats0[3][3] = \
 
1740
      {{0.00000000, 0.00000000, 0.00000000},
 
1741
      {4.89897949, 0.00000000, 0.00000000},
 
1742
      {0.00000000, 0.00000000, 0.00000000}};
 
1743
      
 
1744
      static const double dmats1[3][3] = \
 
1745
      {{0.00000000, 0.00000000, 0.00000000},
 
1746
      {2.44948974, 0.00000000, 0.00000000},
 
1747
      {4.24264069, 0.00000000, 0.00000000}};
 
1748
      
 
1749
      // Compute reference derivatives.
 
1750
      // Declare pointer to array of derivatives on FIAT element.
 
1751
      double *derivatives = new double[num_derivatives];
 
1752
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1753
      {
 
1754
        derivatives[r] = 0.00000000;
 
1755
      }// end loop over 'r'
 
1756
      
 
1757
      // Declare derivative matrix (of polynomial basis).
 
1758
      double dmats[3][3] = \
 
1759
      {{1.00000000, 0.00000000, 0.00000000},
 
1760
      {0.00000000, 1.00000000, 0.00000000},
 
1761
      {0.00000000, 0.00000000, 1.00000000}};
 
1762
      
 
1763
      // Declare (auxiliary) derivative matrix (of polynomial basis).
 
1764
      double dmats_old[3][3] = \
 
1765
      {{1.00000000, 0.00000000, 0.00000000},
 
1766
      {0.00000000, 1.00000000, 0.00000000},
 
1767
      {0.00000000, 0.00000000, 1.00000000}};
 
1768
      
 
1769
      // Loop possible derivatives.
 
1770
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1771
      {
 
1772
        // Resetting dmats values to compute next derivative.
 
1773
        for (unsigned int t = 0; t < 3; t++)
 
1774
        {
 
1775
          for (unsigned int u = 0; u < 3; u++)
 
1776
          {
 
1777
            dmats[t][u] = 0.00000000;
 
1778
            if (t == u)
 
1779
            {
 
1780
            dmats[t][u] = 1.00000000;
 
1781
            }
 
1782
            
 
1783
          }// end loop over 'u'
 
1784
        }// end loop over 't'
 
1785
        
 
1786
        // Looping derivative order to generate dmats.
 
1787
        for (unsigned int s = 0; s < n; s++)
 
1788
        {
 
1789
          // Updating dmats_old with new values and resetting dmats.
 
1790
          for (unsigned int t = 0; t < 3; t++)
 
1791
          {
 
1792
            for (unsigned int u = 0; u < 3; u++)
 
1793
            {
 
1794
              dmats_old[t][u] = dmats[t][u];
 
1795
              dmats[t][u] = 0.00000000;
 
1796
            }// end loop over 'u'
 
1797
          }// end loop over 't'
 
1798
          
 
1799
          // Update dmats using an inner product.
 
1800
          if (combinations[r][s] == 0)
 
1801
          {
 
1802
          for (unsigned int t = 0; t < 3; t++)
 
1803
          {
 
1804
            for (unsigned int u = 0; u < 3; u++)
 
1805
            {
 
1806
              for (unsigned int tu = 0; tu < 3; tu++)
 
1807
              {
 
1808
                dmats[t][u] += dmats0[t][tu]*dmats_old[tu][u];
 
1809
              }// end loop over 'tu'
 
1810
            }// end loop over 'u'
 
1811
          }// end loop over 't'
 
1812
          }
 
1813
          
 
1814
          if (combinations[r][s] == 1)
 
1815
          {
 
1816
          for (unsigned int t = 0; t < 3; t++)
 
1817
          {
 
1818
            for (unsigned int u = 0; u < 3; u++)
 
1819
            {
 
1820
              for (unsigned int tu = 0; tu < 3; tu++)
 
1821
              {
 
1822
                dmats[t][u] += dmats1[t][tu]*dmats_old[tu][u];
 
1823
              }// end loop over 'tu'
 
1824
            }// end loop over 'u'
 
1825
          }// end loop over 't'
 
1826
          }
 
1827
          
 
1828
        }// end loop over 's'
 
1829
        for (unsigned int s = 0; s < 3; s++)
 
1830
        {
 
1831
          for (unsigned int t = 0; t < 3; t++)
 
1832
          {
 
1833
            derivatives[r] += coefficients0[s]*dmats[s][t]*basisvalues[t];
 
1834
          }// end loop over 't'
 
1835
        }// end loop over 's'
 
1836
      }// end loop over 'r'
 
1837
      
 
1838
      // Transform derivatives back to physical element
 
1839
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1840
      {
 
1841
        for (unsigned int s = 0; s < num_derivatives; s++)
 
1842
        {
 
1843
          values[r] += transform[r][s]*derivatives[s];
 
1844
        }// end loop over 's'
 
1845
      }// end loop over 'r'
 
1846
      
 
1847
      // Delete pointer to array of derivatives on FIAT element
 
1848
      delete [] derivatives;
 
1849
      
 
1850
      // Delete pointer to array of combinations of derivatives and transform
 
1851
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1852
      {
 
1853
        delete [] combinations[r];
 
1854
      }// end loop over 'r'
 
1855
      delete [] combinations;
 
1856
      for (unsigned int r = 0; r < num_derivatives; r++)
 
1857
      {
 
1858
        delete [] transform[r];
 
1859
      }// end loop over 'r'
 
1860
      delete [] transform;
 
1861
        break;
 
1862
      }
 
1863
    }
 
1864
    
1467
1865
  }
1468
1866
 
1469
1867
  /// Evaluate order n derivatives of all basis functions at given point in cell