← Back to branch summary

~ubuntu-branches/ubuntu/utopic/ffc/utopic

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Johannes Ring
  • Date: 2011-10-26 17:52:20 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20111026175220-ope1dzqv4jn2b8pq
Tags: 1.0-beta2-1
* New upstream release. This release includes some performance
  improvements for evaluating basis functions. It also adds support
  for Bessel functions and error functions.
* debian/control: Bump version numbers for python-ufc, python-fiat,
  python-instant, and python-ufl.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/regression/references/r_auto/FacetIntegrals.h
1
 
// This code conforms with the UFC specification version 2.0.0
2
 
// and was automatically generated by FFC version 1.0-beta.
 
1
// This code conforms with the UFC specification version 2.0.2
 
2
// and was automatically generated by FFC version 1.0-beta+.
3
3
// 
4
4
// This code was generated with the following parameters:
5
5
// 
52
52
  /// Return a string identifying the finite element
53
53
  virtual const char* signature() const
54
54
  {
55
 
    return "FiniteElement('Discontinuous Lagrange', Cell('triangle', Space(2)), 0, None)";
 
55
    return "FiniteElement('Real', Cell('triangle', Space(2)), 0, None)";
56
56
  }
57
57
 
58
58
  /// Return the cell shape
484
484
  /// Return a string identifying the finite element
485
485
  virtual const char* signature() const
486
486
  {
487
 
    return "VectorElement('Discontinuous Lagrange', Cell('triangle', Space(2)), 0, 2, None)";
 
487
    return "VectorElement('Real', Cell('triangle', Space(2)), 0, 2, None)";
488
488
  }
489
489
 
490
490
  /// Return the cell shape
1238
1238
      double basisvalues[3] = {0.0, 0.0, 0.0};
1239
1239
      
1240
1240
      // Declare helper variables.
1241
 
      unsigned int rr = 0;
1242
 
      unsigned int ss = 0;
1243
1241
      double tmp0 = (1.0 + Y + 2.0*X)/2.0;
1244
1242
      
1245
1243
      // Compute basisvalues.
1246
1244
      basisvalues[0] = 1.0;
1247
1245
      basisvalues[1] = tmp0;
1248
 
      for (unsigned int r = 0; r < 1; r++)
1249
 
      {
1250
 
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
1251
 
        ss = r*(r + 1)/2;
1252
 
        basisvalues[rr] = basisvalues[ss]*(0.5 + r + Y*(1.5 + r));
1253
 
      }// end loop over 'r'
1254
 
      for (unsigned int r = 0; r < 2; r++)
1255
 
      {
1256
 
        for (unsigned int s = 0; s < 2 - r; s++)
1257
 
        {
1258
 
          rr = (r + s)*(r + s + 1)/2 + s;
1259
 
          basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s));
1260
 
        }// end loop over 's'
1261
 
      }// end loop over 'r'
 
1246
      basisvalues[2] = basisvalues[0]*(0.5 + 1.5*Y);
 
1247
      basisvalues[0] *= std::sqrt(0.5);
 
1248
      basisvalues[2] *= std::sqrt(1.0);
 
1249
      basisvalues[1] *= std::sqrt(3.0);
1262
1250
      
1263
1251
      // Table(s) of coefficients.
1264
1252
      static const double coefficients0[3] = \
1278
1266
      double basisvalues[3] = {0.0, 0.0, 0.0};
1279
1267
      
1280
1268
      // Declare helper variables.
1281
 
      unsigned int rr = 0;
1282
 
      unsigned int ss = 0;
1283
1269
      double tmp0 = (1.0 + Y + 2.0*X)/2.0;
1284
1270
      
1285
1271
      // Compute basisvalues.
1286
1272
      basisvalues[0] = 1.0;
1287
1273
      basisvalues[1] = tmp0;
1288
 
      for (unsigned int r = 0; r < 1; r++)
1289
 
      {
1290
 
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
1291
 
        ss = r*(r + 1)/2;
1292
 
        basisvalues[rr] = basisvalues[ss]*(0.5 + r + Y*(1.5 + r));
1293
 
      }// end loop over 'r'
1294
 
      for (unsigned int r = 0; r < 2; r++)
1295
 
      {
1296
 
        for (unsigned int s = 0; s < 2 - r; s++)
1297
 
        {
1298
 
          rr = (r + s)*(r + s + 1)/2 + s;
1299
 
          basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s));
1300
 
        }// end loop over 's'
1301
 
      }// end loop over 'r'
 
1274
      basisvalues[2] = basisvalues[0]*(0.5 + 1.5*Y);
 
1275
      basisvalues[0] *= std::sqrt(0.5);
 
1276
      basisvalues[2] *= std::sqrt(1.0);
 
1277
      basisvalues[1] *= std::sqrt(3.0);
1302
1278
      
1303
1279
      // Table(s) of coefficients.
1304
1280
      static const double coefficients0[3] = \
1318
1294
      double basisvalues[3] = {0.0, 0.0, 0.0};
1319
1295
      
1320
1296
      // Declare helper variables.
1321
 
      unsigned int rr = 0;
1322
 
      unsigned int ss = 0;
1323
1297
      double tmp0 = (1.0 + Y + 2.0*X)/2.0;
1324
1298
      
1325
1299
      // Compute basisvalues.
1326
1300
      basisvalues[0] = 1.0;
1327
1301
      basisvalues[1] = tmp0;
1328
 
      for (unsigned int r = 0; r < 1; r++)
1329
 
      {
1330
 
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
1331
 
        ss = r*(r + 1)/2;
1332
 
        basisvalues[rr] = basisvalues[ss]*(0.5 + r + Y*(1.5 + r));
1333
 
      }// end loop over 'r'
1334
 
      for (unsigned int r = 0; r < 2; r++)
1335
 
      {
1336
 
        for (unsigned int s = 0; s < 2 - r; s++)
1337
 
        {
1338
 
          rr = (r + s)*(r + s + 1)/2 + s;
1339
 
          basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s));
1340
 
        }// end loop over 's'
1341
 
      }// end loop over 'r'
 
1302
      basisvalues[2] = basisvalues[0]*(0.5 + 1.5*Y);
 
1303
      basisvalues[0] *= std::sqrt(0.5);
 
1304
      basisvalues[2] *= std::sqrt(1.0);
 
1305
      basisvalues[1] *= std::sqrt(3.0);
1342
1306
      
1343
1307
      // Table(s) of coefficients.
1344
1308
      static const double coefficients0[3] = \
1477
1441
      double basisvalues[3] = {0.0, 0.0, 0.0};
1478
1442
      
1479
1443
      // Declare helper variables.
1480
 
      unsigned int rr = 0;
1481
 
      unsigned int ss = 0;
1482
1444
      double tmp0 = (1.0 + Y + 2.0*X)/2.0;
1483
1445
      
1484
1446
      // Compute basisvalues.
1485
1447
      basisvalues[0] = 1.0;
1486
1448
      basisvalues[1] = tmp0;
1487
 
      for (unsigned int r = 0; r < 1; r++)
1488
 
      {
1489
 
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
1490
 
        ss = r*(r + 1)/2;
1491
 
        basisvalues[rr] = basisvalues[ss]*(0.5 + r + Y*(1.5 + r));
1492
 
      }// end loop over 'r'
1493
 
      for (unsigned int r = 0; r < 2; r++)
1494
 
      {
1495
 
        for (unsigned int s = 0; s < 2 - r; s++)
1496
 
        {
1497
 
          rr = (r + s)*(r + s + 1)/2 + s;
1498
 
          basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s));
1499
 
        }// end loop over 's'
1500
 
      }// end loop over 'r'
 
1449
      basisvalues[2] = basisvalues[0]*(0.5 + 1.5*Y);
 
1450
      basisvalues[0] *= std::sqrt(0.5);
 
1451
      basisvalues[2] *= std::sqrt(1.0);
 
1452
      basisvalues[1] *= std::sqrt(3.0);
1501
1453
      
1502
1454
      // Table(s) of coefficients.
1503
1455
      static const double coefficients0[3] = \
1635
1587
      double basisvalues[3] = {0.0, 0.0, 0.0};
1636
1588
      
1637
1589
      // Declare helper variables.
1638
 
      unsigned int rr = 0;
1639
 
      unsigned int ss = 0;
1640
1590
      double tmp0 = (1.0 + Y + 2.0*X)/2.0;
1641
1591
      
1642
1592
      // Compute basisvalues.
1643
1593
      basisvalues[0] = 1.0;
1644
1594
      basisvalues[1] = tmp0;
1645
 
      for (unsigned int r = 0; r < 1; r++)
1646
 
      {
1647
 
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
1648
 
        ss = r*(r + 1)/2;
1649
 
        basisvalues[rr] = basisvalues[ss]*(0.5 + r + Y*(1.5 + r));
1650
 
      }// end loop over 'r'
1651
 
      for (unsigned int r = 0; r < 2; r++)
1652
 
      {
1653
 
        for (unsigned int s = 0; s < 2 - r; s++)
1654
 
        {
1655
 
          rr = (r + s)*(r + s + 1)/2 + s;
1656
 
          basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s));
1657
 
        }// end loop over 's'
1658
 
      }// end loop over 'r'
 
1595
      basisvalues[2] = basisvalues[0]*(0.5 + 1.5*Y);
 
1596
      basisvalues[0] *= std::sqrt(0.5);
 
1597
      basisvalues[2] *= std::sqrt(1.0);
 
1598
      basisvalues[1] *= std::sqrt(3.0);
1659
1599
      
1660
1600
      // Table(s) of coefficients.
1661
1601
      static const double coefficients0[3] = \
1793
1733
      double basisvalues[3] = {0.0, 0.0, 0.0};
1794
1734
      
1795
1735
      // Declare helper variables.
1796
 
      unsigned int rr = 0;
1797
 
      unsigned int ss = 0;
1798
1736
      double tmp0 = (1.0 + Y + 2.0*X)/2.0;
1799
1737
      
1800
1738
      // Compute basisvalues.
1801
1739
      basisvalues[0] = 1.0;
1802
1740
      basisvalues[1] = tmp0;
1803
 
      for (unsigned int r = 0; r < 1; r++)
1804
 
      {
1805
 
        rr = (r + 1)*(r + 1 + 1)/2 + 1;
1806
 
        ss = r*(r + 1)/2;
1807
 
        basisvalues[rr] = basisvalues[ss]*(0.5 + r + Y*(1.5 + r));
1808
 
      }// end loop over 'r'
1809
 
      for (unsigned int r = 0; r < 2; r++)
1810
 
      {
1811
 
        for (unsigned int s = 0; s < 2 - r; s++)
1812
 
        {
1813
 
          rr = (r + s)*(r + s + 1)/2 + s;
1814
 
          basisvalues[rr] *= std::sqrt((0.5 + r)*(1.0 + r + s));
1815
 
        }// end loop over 's'
1816
 
      }// end loop over 'r'
 
1741
      basisvalues[2] = basisvalues[0]*(0.5 + 1.5*Y);
 
1742
      basisvalues[0] *= std::sqrt(0.5);
 
1743
      basisvalues[2] *= std::sqrt(1.0);
 
1744
      basisvalues[1] *= std::sqrt(3.0);
1817
1745
      
1818
1746
      // Table(s) of coefficients.
1819
1747
      static const double coefficients0[3] = \
2121
2049
  /// Return a string identifying the dofmap
2122
2050
  virtual const char* signature() const
2123
2051
  {
2124
 
    return "FFC dofmap for FiniteElement('Discontinuous Lagrange', Cell('triangle', Space(2)), 0, None)";
 
2052
    return "FFC dofmap for FiniteElement('Real', Cell('triangle', Space(2)), 0, None)";
2125
2053
  }
2126
2054
 
2127
2055
  /// Return true iff mesh entities of topological dimension d are needed
2141
2069
      }
2142
2070
    case 2:
2143
2071
      {
2144
 
        return true;
 
2072
        return false;
2145
2073
        break;
2146
2074
      }
2147
2075
    }
2152
2080
  /// Initialize dofmap for mesh (return true iff init_cell() is needed)
2153
2081
  virtual bool init_mesh(const ufc::mesh& m)
2154
2082
  {
2155
 
    _global_dimension = m.num_entities[2];
 
2083
    _global_dimension = 1;
2156
2084
    return false;
2157
2085
  }
2158
2086
 
2235
2163
                             const ufc::mesh& m,
2236
2164
                             const ufc::cell& c) const
2237
2165
  {
2238
 
    dofs[0] = c.entity_indices[2][0];
 
2166
    dofs[0] = 0;
2239
2167
  }
2240
2168
 
2241
2169
  /// Tabulate the local-to-local mapping from facet dofs to cell dofs
2353
2281
  /// Return a string identifying the dofmap
2354
2282
  virtual const char* signature() const
2355
2283
  {
2356
 
    return "FFC dofmap for VectorElement('Discontinuous Lagrange', Cell('triangle', Space(2)), 0, 2, None)";
 
2284
    return "FFC dofmap for VectorElement('Real', Cell('triangle', Space(2)), 0, 2, None)";
2357
2285
  }
2358
2286
 
2359
2287
  /// Return true iff mesh entities of topological dimension d are needed
2384
2312
  /// Initialize dofmap for mesh (return true iff init_cell() is needed)
2385
2313
  virtual bool init_mesh(const ufc::mesh& m)
2386
2314
  {
2387
 
    _global_dimension = 2.0*m.num_entities[2];
 
2315
    _global_dimension = 2;
2388
2316
    return false;
2389
2317
  }
2390
2318
 
2468
2396
                             const ufc::cell& c) const
2469
2397
  {
2470
2398
    unsigned int offset = 0;
2471
 
    dofs[0] = offset + c.entity_indices[2][0];
2472
 
    offset += m.num_entities[2];
2473
 
    dofs[1] = offset + c.entity_indices[2][0];
2474
 
    offset += m.num_entities[2];
 
2399
    dofs[0] = offset;
 
2400
    offset += 1;
 
2401
    dofs[1] = offset;
 
2402
    offset += 1;
2475
2403
  }
2476
2404
 
2477
2405
  /// Tabulate the local-to-local mapping from facet dofs to cell dofs