← Back to branch summary

~chaffra/ffc/main-old

« back to all changes in this revision

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

  • Committer: Chaffra Affouda
  • Date: 2013-02-09 20:05:08 UTC
  • mfrom: (1675.1.133 scratch)
  • Revision ID: chaffra@gmail.com-20130209200508-lu6y6baofchfwp1z
merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/regression/references/r_quadrature/Heat.h
1
 
// This code conforms with the UFC specification version 2.0.5
2
 
// and was automatically generated by FFC version 1.0.0+.
 
1
// This code conforms with the UFC specification version 2.1.0+
 
2
// and was automatically generated by FFC version 1.1.0+.
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('Real', Cell('triangle', Space(2)), 0, None)";
 
55
    return "FiniteElement('Real', Domain(Cell('triangle', 2), 'triangle_multiverse', 2, 2), 0, None)";
56
56
  }
57
57
 
58
58
  /// Return the cell shape
62
62
  }
63
63
 
64
64
  /// Return the topological dimension of the cell shape
65
 
  virtual unsigned int topological_dimension() const
 
65
  virtual std::size_t topological_dimension() const
66
66
  {
67
67
    return 2;
68
68
  }
69
69
 
70
70
  /// Return the geometric dimension of the cell shape
71
 
  virtual unsigned int geometric_dimension() const
 
71
  virtual std::size_t geometric_dimension() const
72
72
  {
73
73
    return 2;
74
74
  }
75
75
 
76
76
  /// Return the dimension of the finite element function space
77
 
  virtual unsigned int space_dimension() const
 
77
  virtual std::size_t space_dimension() const
78
78
  {
79
79
    return 1;
80
80
  }
81
81
 
82
82
  /// Return the rank of the value space
83
 
  virtual unsigned int value_rank() const
 
83
  virtual std::size_t value_rank() const
84
84
  {
85
85
    return 0;
86
86
  }
87
87
 
88
88
  /// Return the dimension of the value space for axis i
89
 
  virtual unsigned int value_dimension(unsigned int i) const
 
89
  virtual std::size_t value_dimension(std::size_t i) const
90
90
  {
91
91
    return 1;
92
92
  }
93
93
 
94
94
  /// Evaluate basis function i at given point in cell
95
 
  virtual void evaluate_basis(unsigned int i,
 
95
  virtual void evaluate_basis(std::size_t i,
96
96
                              double* values,
97
97
                              const double* coordinates,
98
98
                              const ufc::cell& c) const
141
141
  }
142
142
 
143
143
  /// Evaluate order n derivatives of basis function i at given point in cell
144
 
  virtual void evaluate_basis_derivatives(unsigned int i,
145
 
                                          unsigned int n,
 
144
  virtual void evaluate_basis_derivatives(std::size_t i,
 
145
                                          std::size_t n,
146
146
                                          double* values,
147
147
                                          const double* coordinates,
148
148
                                          const ufc::cell& c) const
157
157
    const double J_11 = x[2][1] - x[0][1];
158
158
    
159
159
    // Compute determinant of Jacobian
160
 
    double detJ = J_00*J_11 - J_01*J_10;
 
160
    const double detJ = J_00*J_11 - J_01*J_10;
161
161
    
162
162
    // Compute inverse of Jacobian
163
163
    const double K_00 =  J_11 / detJ;
364
364
  }
365
365
 
366
366
  /// Evaluate order n derivatives of all basis functions at given point in cell
367
 
  virtual void evaluate_basis_derivatives_all(unsigned int n,
 
367
  virtual void evaluate_basis_derivatives_all(std::size_t n,
368
368
                                              double* values,
369
369
                                              const double* coordinates,
370
370
                                              const ufc::cell& c) const
374
374
  }
375
375
 
376
376
  /// Evaluate linear functional for dof i on the function f
377
 
  virtual double evaluate_dof(unsigned int i,
 
377
  virtual double evaluate_dof(std::size_t i,
378
378
                              const ufc::function& f,
379
379
                              const ufc::cell& c) const
380
380
  {
444
444
  }
445
445
 
446
446
  /// Return the number of sub elements (for a mixed element)
447
 
  virtual unsigned int num_sub_elements() const
 
447
  virtual std::size_t num_sub_elements() const
448
448
  {
449
449
    return 0;
450
450
  }
451
451
 
452
452
  /// Create a new finite element for sub element i (for a mixed element)
453
 
  virtual ufc::finite_element* create_sub_element(unsigned int i) const
 
453
  virtual ufc::finite_element* create_sub_element(std::size_t i) const
454
454
  {
455
455
    return 0;
456
456
  }
484
484
  /// Return a string identifying the finite element
485
485
  virtual const char* signature() const
486
486
  {
487
 
    return "FiniteElement('Lagrange', Cell('triangle', Space(2)), 1, None)";
 
487
    return "FiniteElement('Lagrange', Domain(Cell('triangle', 2), 'triangle_multiverse', 2, 2), 1, None)";
488
488
  }
489
489
 
490
490
  /// Return the cell shape
494
494
  }
495
495
 
496
496
  /// Return the topological dimension of the cell shape
497
 
  virtual unsigned int topological_dimension() const
 
497
  virtual std::size_t topological_dimension() const
498
498
  {
499
499
    return 2;
500
500
  }
501
501
 
502
502
  /// Return the geometric dimension of the cell shape
503
 
  virtual unsigned int geometric_dimension() const
 
503
  virtual std::size_t geometric_dimension() const
504
504
  {
505
505
    return 2;
506
506
  }
507
507
 
508
508
  /// Return the dimension of the finite element function space
509
 
  virtual unsigned int space_dimension() const
 
509
  virtual std::size_t space_dimension() const
510
510
  {
511
511
    return 3;
512
512
  }
513
513
 
514
514
  /// Return the rank of the value space
515
 
  virtual unsigned int value_rank() const
 
515
  virtual std::size_t value_rank() const
516
516
  {
517
517
    return 0;
518
518
  }
519
519
 
520
520
  /// Return the dimension of the value space for axis i
521
 
  virtual unsigned int value_dimension(unsigned int i) const
 
521
  virtual std::size_t value_dimension(std::size_t i) const
522
522
  {
523
523
    return 1;
524
524
  }
525
525
 
526
526
  /// Evaluate basis function i at given point in cell
527
 
  virtual void evaluate_basis(unsigned int i,
 
527
  virtual void evaluate_basis(std::size_t i,
528
528
                              double* values,
529
529
                              const double* coordinates,
530
530
                              const ufc::cell& c) const
539
539
    const double J_11 = x[2][1] - x[0][1];
540
540
    
541
541
    // Compute determinant of Jacobian
542
 
    double detJ = J_00*J_11 - J_01*J_10;
 
542
    const double detJ = J_00*J_11 - J_01*J_10;
543
543
    
544
544
    // Compute inverse of Jacobian
545
545
    
660
660
  }
661
661
 
662
662
  /// Evaluate order n derivatives of basis function i at given point in cell
663
 
  virtual void evaluate_basis_derivatives(unsigned int i,
664
 
                                          unsigned int n,
 
663
  virtual void evaluate_basis_derivatives(std::size_t i,
 
664
                                          std::size_t n,
665
665
                                          double* values,
666
666
                                          const double* coordinates,
667
667
                                          const ufc::cell& c) const
676
676
    const double J_11 = x[2][1] - x[0][1];
677
677
    
678
678
    // Compute determinant of Jacobian
679
 
    double detJ = J_00*J_11 - J_01*J_10;
 
679
    const double detJ = J_00*J_11 - J_01*J_10;
680
680
    
681
681
    // Compute inverse of Jacobian
682
682
    const double K_00 =  J_11 / detJ;
1201
1201
  }
1202
1202
 
1203
1203
  /// Evaluate order n derivatives of all basis functions at given point in cell
1204
 
  virtual void evaluate_basis_derivatives_all(unsigned int n,
 
1204
  virtual void evaluate_basis_derivatives_all(std::size_t n,
1205
1205
                                              double* values,
1206
1206
                                              const double* coordinates,
1207
1207
                                              const ufc::cell& c) const
1235
1235
  }
1236
1236
 
1237
1237
  /// Evaluate linear functional for dof i on the function f
1238
 
  virtual double evaluate_dof(unsigned int i,
 
1238
  virtual double evaluate_dof(std::size_t i,
1239
1239
                              const ufc::function& f,
1240
1240
                              const ufc::cell& c) const
1241
1241
  {
1329
1329
  }
1330
1330
 
1331
1331
  /// Return the number of sub elements (for a mixed element)
1332
 
  virtual unsigned int num_sub_elements() const
 
1332
  virtual std::size_t num_sub_elements() const
1333
1333
  {
1334
1334
    return 0;
1335
1335
  }
1336
1336
 
1337
1337
  /// Create a new finite element for sub element i (for a mixed element)
1338
 
  virtual ufc::finite_element* create_sub_element(unsigned int i) const
 
1338
  virtual ufc::finite_element* create_sub_element(std::size_t i) const
1339
1339
  {
1340
1340
    return 0;
1341
1341
  }
1353
1353
 
1354
1354
class heat_dofmap_0: public ufc::dofmap
1355
1355
{
1356
 
private:
1357
 
 
1358
 
  unsigned int _global_dimension;
1359
1356
public:
1360
1357
 
1361
1358
  /// Constructor
1362
1359
  heat_dofmap_0() : ufc::dofmap()
1363
1360
  {
1364
 
    _global_dimension = 0;
 
1361
    // Do nothing
1365
1362
  }
1366
1363
 
1367
1364
  /// Destructor
1373
1370
  /// Return a string identifying the dofmap
1374
1371
  virtual const char* signature() const
1375
1372
  {
1376
 
    return "FFC dofmap for FiniteElement('Real', Cell('triangle', Space(2)), 0, None)";
 
1373
    return "FFC dofmap for FiniteElement('Real', Domain(Cell('triangle', 2), 'triangle_multiverse', 2, 2), 0, None)";
1377
1374
  }
1378
1375
 
1379
1376
  /// Return true iff mesh entities of topological dimension d are needed
1380
 
  virtual bool needs_mesh_entities(unsigned int d) const
 
1377
  virtual bool needs_mesh_entities(std::size_t d) const
1381
1378
  {
1382
1379
    switch (d)
1383
1380
    {
1401
1398
    return false;
1402
1399
  }
1403
1400
 
1404
 
  /// Initialize dofmap for mesh (return true iff init_cell() is needed)
1405
 
  virtual bool init_mesh(const ufc::mesh& m)
1406
 
  {
1407
 
    _global_dimension = 1;
1408
 
    return false;
1409
 
  }
1410
 
 
1411
 
  /// Initialize dofmap for given cell
1412
 
  virtual void init_cell(const ufc::mesh& m,
1413
 
                         const ufc::cell& c)
1414
 
  {
1415
 
    // Do nothing
1416
 
  }
1417
 
 
1418
 
  /// Finish initialization of dofmap for cells
1419
 
  virtual void init_cell_finalize()
1420
 
  {
1421
 
    // Do nothing
1422
 
  }
1423
 
 
1424
1401
  /// Return the topological dimension of the associated cell shape
1425
 
  virtual unsigned int topological_dimension() const
 
1402
  virtual std::size_t topological_dimension() const
1426
1403
  {
1427
1404
    return 2;
1428
1405
  }
1429
1406
 
1430
1407
  /// Return the geometric dimension of the associated cell shape
1431
 
  virtual unsigned int geometric_dimension() const
 
1408
  virtual std::size_t geometric_dimension() const
1432
1409
  {
1433
1410
    return 2;
1434
1411
  }
1435
1412
 
1436
1413
  /// Return the dimension of the global finite element function space
1437
 
  virtual unsigned int global_dimension() const
 
1414
  virtual std::size_t global_dimension(const std::vector<std::size_t>&
 
1415
                                       num_global_entities) const
1438
1416
  {
1439
 
    return _global_dimension;
 
1417
    return 1;
1440
1418
  }
1441
1419
 
1442
1420
  /// Return the dimension of the local finite element function space for a cell
1443
 
  virtual unsigned int local_dimension(const ufc::cell& c) const
 
1421
  virtual std::size_t local_dimension(const ufc::cell& c) const
1444
1422
  {
1445
1423
    return 1;
1446
1424
  }
1447
1425
 
1448
1426
  /// Return the maximum dimension of the local finite element function space
1449
 
  virtual unsigned int max_local_dimension() const
 
1427
  virtual std::size_t max_local_dimension() const
1450
1428
  {
1451
1429
    return 1;
1452
1430
  }
1453
1431
 
1454
1432
  /// Return the number of dofs on each cell facet
1455
 
  virtual unsigned int num_facet_dofs() const
 
1433
  virtual std::size_t num_facet_dofs() const
1456
1434
  {
1457
1435
    return 0;
1458
1436
  }
1459
1437
 
1460
1438
  /// Return the number of dofs associated with each cell entity of dimension d
1461
 
  virtual unsigned int num_entity_dofs(unsigned int d) const
 
1439
  virtual std::size_t num_entity_dofs(std::size_t d) const
1462
1440
  {
1463
1441
    switch (d)
1464
1442
    {
1483
1461
  }
1484
1462
 
1485
1463
  /// Tabulate the local-to-global mapping of dofs on a cell
1486
 
  virtual void tabulate_dofs(unsigned int* dofs,
1487
 
                             const ufc::mesh& m,
 
1464
  virtual void tabulate_dofs(std::size_t* dofs,
 
1465
                             const std::vector<std::size_t>& num_global_entities,
1488
1466
                             const ufc::cell& c) const
1489
1467
  {
1490
1468
    dofs[0] = 0;
1491
1469
  }
1492
1470
 
1493
1471
  /// Tabulate the local-to-local mapping from facet dofs to cell dofs
1494
 
  virtual void tabulate_facet_dofs(unsigned int* dofs,
1495
 
                                   unsigned int facet) const
 
1472
  virtual void tabulate_facet_dofs(std::size_t* dofs,
 
1473
                                   std::size_t facet) const
1496
1474
  {
1497
1475
    switch (facet)
1498
1476
    {
1516
1494
  }
1517
1495
 
1518
1496
  /// Tabulate the local-to-local mapping of dofs on entity (d, i)
1519
 
  virtual void tabulate_entity_dofs(unsigned int* dofs,
1520
 
                                    unsigned int d, unsigned int i) const
 
1497
  virtual void tabulate_entity_dofs(std::size_t* dofs,
 
1498
                                    std::size_t d, std::size_t i) const
1521
1499
  {
1522
1500
    if (d > 2)
1523
1501
    {
1561
1539
  }
1562
1540
 
1563
1541
  /// Return the number of sub dofmaps (for a mixed element)
1564
 
  virtual unsigned int num_sub_dofmaps() const
 
1542
  virtual std::size_t num_sub_dofmaps() const
1565
1543
  {
1566
1544
    return 0;
1567
1545
  }
1568
1546
 
1569
1547
  /// Create a new dofmap for sub dofmap i (for a mixed element)
1570
 
  virtual ufc::dofmap* create_sub_dofmap(unsigned int i) const
 
1548
  virtual ufc::dofmap* create_sub_dofmap(std::size_t i) const
1571
1549
  {
1572
1550
    return 0;
1573
1551
  }
1585
1563
 
1586
1564
class heat_dofmap_1: public ufc::dofmap
1587
1565
{
1588
 
private:
1589
 
 
1590
 
  unsigned int _global_dimension;
1591
1566
public:
1592
1567
 
1593
1568
  /// Constructor
1594
1569
  heat_dofmap_1() : ufc::dofmap()
1595
1570
  {
1596
 
    _global_dimension = 0;
 
1571
    // Do nothing
1597
1572
  }
1598
1573
 
1599
1574
  /// Destructor
1605
1580
  /// Return a string identifying the dofmap
1606
1581
  virtual const char* signature() const
1607
1582
  {
1608
 
    return "FFC dofmap for FiniteElement('Lagrange', Cell('triangle', Space(2)), 1, None)";
 
1583
    return "FFC dofmap for FiniteElement('Lagrange', Domain(Cell('triangle', 2), 'triangle_multiverse', 2, 2), 1, None)";
1609
1584
  }
1610
1585
 
1611
1586
  /// Return true iff mesh entities of topological dimension d are needed
1612
 
  virtual bool needs_mesh_entities(unsigned int d) const
 
1587
  virtual bool needs_mesh_entities(std::size_t d) const
1613
1588
  {
1614
1589
    switch (d)
1615
1590
    {
1633
1608
    return false;
1634
1609
  }
1635
1610
 
1636
 
  /// Initialize dofmap for mesh (return true iff init_cell() is needed)
1637
 
  virtual bool init_mesh(const ufc::mesh& m)
1638
 
  {
1639
 
    _global_dimension = m.num_entities[0];
1640
 
    return false;
1641
 
  }
1642
 
 
1643
 
  /// Initialize dofmap for given cell
1644
 
  virtual void init_cell(const ufc::mesh& m,
1645
 
                         const ufc::cell& c)
1646
 
  {
1647
 
    // Do nothing
1648
 
  }
1649
 
 
1650
 
  /// Finish initialization of dofmap for cells
1651
 
  virtual void init_cell_finalize()
1652
 
  {
1653
 
    // Do nothing
1654
 
  }
1655
 
 
1656
1611
  /// Return the topological dimension of the associated cell shape
1657
 
  virtual unsigned int topological_dimension() const
 
1612
  virtual std::size_t topological_dimension() const
1658
1613
  {
1659
1614
    return 2;
1660
1615
  }
1661
1616
 
1662
1617
  /// Return the geometric dimension of the associated cell shape
1663
 
  virtual unsigned int geometric_dimension() const
 
1618
  virtual std::size_t geometric_dimension() const
1664
1619
  {
1665
1620
    return 2;
1666
1621
  }
1667
1622
 
1668
1623
  /// Return the dimension of the global finite element function space
1669
 
  virtual unsigned int global_dimension() const
 
1624
  virtual std::size_t global_dimension(const std::vector<std::size_t>&
 
1625
                                       num_global_entities) const
1670
1626
  {
1671
 
    return _global_dimension;
 
1627
    return num_global_entities[0];
1672
1628
  }
1673
1629
 
1674
1630
  /// Return the dimension of the local finite element function space for a cell
1675
 
  virtual unsigned int local_dimension(const ufc::cell& c) const
 
1631
  virtual std::size_t local_dimension(const ufc::cell& c) const
1676
1632
  {
1677
1633
    return 3;
1678
1634
  }
1679
1635
 
1680
1636
  /// Return the maximum dimension of the local finite element function space
1681
 
  virtual unsigned int max_local_dimension() const
 
1637
  virtual std::size_t max_local_dimension() const
1682
1638
  {
1683
1639
    return 3;
1684
1640
  }
1685
1641
 
1686
1642
  /// Return the number of dofs on each cell facet
1687
 
  virtual unsigned int num_facet_dofs() const
 
1643
  virtual std::size_t num_facet_dofs() const
1688
1644
  {
1689
1645
    return 2;
1690
1646
  }
1691
1647
 
1692
1648
  /// Return the number of dofs associated with each cell entity of dimension d
1693
 
  virtual unsigned int num_entity_dofs(unsigned int d) const
 
1649
  virtual std::size_t num_entity_dofs(std::size_t d) const
1694
1650
  {
1695
1651
    switch (d)
1696
1652
    {
1715
1671
  }
1716
1672
 
1717
1673
  /// Tabulate the local-to-global mapping of dofs on a cell
1718
 
  virtual void tabulate_dofs(unsigned int* dofs,
1719
 
                             const ufc::mesh& m,
 
1674
  virtual void tabulate_dofs(std::size_t* dofs,
 
1675
                             const std::vector<std::size_t>& num_global_entities,
1720
1676
                             const ufc::cell& c) const
1721
1677
  {
1722
1678
    dofs[0] = c.entity_indices[0][0];
1725
1681
  }
1726
1682
 
1727
1683
  /// Tabulate the local-to-local mapping from facet dofs to cell dofs
1728
 
  virtual void tabulate_facet_dofs(unsigned int* dofs,
1729
 
                                   unsigned int facet) const
 
1684
  virtual void tabulate_facet_dofs(std::size_t* dofs,
 
1685
                                   std::size_t facet) const
1730
1686
  {
1731
1687
    switch (facet)
1732
1688
    {
1753
1709
  }
1754
1710
 
1755
1711
  /// Tabulate the local-to-local mapping of dofs on entity (d, i)
1756
 
  virtual void tabulate_entity_dofs(unsigned int* dofs,
1757
 
                                    unsigned int d, unsigned int i) const
 
1712
  virtual void tabulate_entity_dofs(std::size_t* dofs,
 
1713
                                    std::size_t d, std::size_t i) const
1758
1714
  {
1759
1715
    if (d > 2)
1760
1716
    {
1820
1776
  }
1821
1777
 
1822
1778
  /// Return the number of sub dofmaps (for a mixed element)
1823
 
  virtual unsigned int num_sub_dofmaps() const
 
1779
  virtual std::size_t num_sub_dofmaps() const
1824
1780
  {
1825
1781
    return 0;
1826
1782
  }
1827
1783
 
1828
1784
  /// Create a new dofmap for sub dofmap i (for a mixed element)
1829
 
  virtual ufc::dofmap* create_sub_dofmap(unsigned int i) const
 
1785
  virtual ufc::dofmap* create_sub_dofmap(std::size_t i) const
1830
1786
  {
1831
1787
    return 0;
1832
1788
  }
1874
1830
    const double J_11 = x[2][1] - x[0][1];
1875
1831
    
1876
1832
    // Compute determinant of Jacobian
1877
 
    double detJ = J_00*J_11 - J_01*J_10;
 
1833
    const double detJ = J_00*J_11 - J_01*J_10;
1878
1834
    
1879
1835
    // Compute inverse of Jacobian
1880
1836
    const double K_00 =  J_11 / detJ;
1885
1841
    // Set scale factor
1886
1842
    const double det = std::abs(detJ);
1887
1843
    
1888
 
    // Cell Volume.
 
1844
    // Cell volume.
1889
1845
    
1890
 
    // Compute circumradius, assuming triangle is embedded in 2D.
 
1846
    // Compute circumradius of triangle in 2D.
1891
1847
    
1892
1848
    
1893
1849
    // Facet Area.
1952
1908
  virtual void tabulate_tensor(double* A,
1953
1909
                               const double * const * w,
1954
1910
                               const ufc::cell& c,
1955
 
                               unsigned int num_quadrature_points,
 
1911
                               std::size_t num_quadrature_points,
1956
1912
                               const double * const * quadrature_points,
1957
1913
                               const double* quadrature_weights) const
1958
1914
  {
1996
1952
    const double J_11 = x[2][1] - x[0][1];
1997
1953
    
1998
1954
    // Compute determinant of Jacobian
1999
 
    double detJ = J_00*J_11 - J_01*J_10;
 
1955
    const double detJ = J_00*J_11 - J_01*J_10;
2000
1956
    
2001
1957
    // Compute inverse of Jacobian
2002
1958
    
2003
1959
    // Set scale factor
2004
1960
    const double det = std::abs(detJ);
2005
1961
    
2006
 
    // Cell Volume.
 
1962
    // Cell volume.
2007
1963
    
2008
 
    // Compute circumradius, assuming triangle is embedded in 2D.
 
1964
    // Compute circumradius of triangle in 2D.
2009
1965
    
2010
1966
    
2011
1967
    // Facet Area.
2059
2015
  virtual void tabulate_tensor(double* A,
2060
2016
                               const double * const * w,
2061
2017
                               const ufc::cell& c,
2062
 
                               unsigned int num_quadrature_points,
 
2018
                               std::size_t num_quadrature_points,
2063
2019
                               const double * const * quadrature_points,
2064
2020
                               const double* quadrature_weights) const
2065
2021
  {
2102
2058
  /// Return a string identifying the form
2103
2059
  virtual const char* signature() const
2104
2060
  {
2105
 
    return "d7ce67578010431b29dcf0d6730b98c610d813d9f437eb34a9801aad65b212c1a6250b60b42feb23dc9bc9a5ba83e6317231688dea5e2ed094e2cf8eb1ee8fc7";
 
2061
    return "beabc8cbfdbde2305229a06a22fc65169df459942208b7edbad5638470484817dd7b24adf340e04be94824a800269900212bbcd0e8e41c86261007b33e4bb8d6";
2106
2062
  }
2107
2063
 
2108
2064
  /// Return the rank of the global tensor (r)
2109
 
  virtual unsigned int rank() const
 
2065
  virtual std::size_t rank() const
2110
2066
  {
2111
2067
    return 2;
2112
2068
  }
2113
2069
 
2114
2070
  /// Return the number of coefficients (n)
2115
 
  virtual unsigned int num_coefficients() const
 
2071
  virtual std::size_t num_coefficients() const
2116
2072
  {
2117
2073
    return 2;
2118
2074
  }
2119
2075
 
2120
2076
  /// Return the number of cell domains
2121
 
  virtual unsigned int num_cell_domains() const
 
2077
  virtual std::size_t num_cell_domains() const
2122
2078
  {
2123
2079
    return 1;
2124
2080
  }
2125
2081
 
2126
2082
  /// Return the number of exterior facet domains
2127
 
  virtual unsigned int num_exterior_facet_domains() const
 
2083
  virtual std::size_t num_exterior_facet_domains() const
2128
2084
  {
2129
2085
    return 0;
2130
2086
  }
2131
2087
 
2132
2088
  /// Return the number of interior facet domains
2133
 
  virtual unsigned int num_interior_facet_domains() const
 
2089
  virtual std::size_t num_interior_facet_domains() const
2134
2090
  {
2135
2091
    return 0;
2136
2092
  }
2137
2093
 
 
2094
  /// Return whether the form has any cell integrals
 
2095
  virtual bool has_cell_integrals() const
 
2096
  {
 
2097
    return true;
 
2098
  }
 
2099
 
 
2100
  /// Return whether the form has any exterior facet integrals
 
2101
  virtual bool has_exterior_facet_integrals() const
 
2102
  {
 
2103
    return false;
 
2104
  }
 
2105
 
 
2106
  /// Return whether the form has any interior facet integrals
 
2107
  virtual bool has_interior_facet_integrals() const
 
2108
  {
 
2109
    return false;
 
2110
  }
 
2111
 
2138
2112
  /// Create a new finite element for argument function i
2139
 
  virtual ufc::finite_element* create_finite_element(unsigned int i) const
 
2113
  virtual ufc::finite_element* create_finite_element(std::size_t i) const
2140
2114
  {
2141
2115
    switch (i)
2142
2116
    {
2166
2140
  }
2167
2141
 
2168
2142
  /// Create a new dofmap for argument function i
2169
 
  virtual ufc::dofmap* create_dofmap(unsigned int i) const
 
2143
  virtual ufc::dofmap* create_dofmap(std::size_t i) const
2170
2144
  {
2171
2145
    switch (i)
2172
2146
    {
2196
2170
  }
2197
2171
 
2198
2172
  /// Create a new cell integral on sub domain i
2199
 
  virtual ufc::cell_integral* create_cell_integral(unsigned int i) const
 
2173
  virtual ufc::cell_integral* create_cell_integral(std::size_t i) const
2200
2174
  {
2201
2175
    switch (i)
2202
2176
    {
2211
2185
  }
2212
2186
 
2213
2187
  /// Create a new exterior facet integral on sub domain i
2214
 
  virtual ufc::exterior_facet_integral* create_exterior_facet_integral(unsigned int i) const
 
2188
  virtual ufc::exterior_facet_integral* create_exterior_facet_integral(std::size_t i) const
2215
2189
  {
2216
2190
    return 0;
2217
2191
  }
2218
2192
 
2219
2193
  /// Create a new interior facet integral on sub domain i
2220
 
  virtual ufc::interior_facet_integral* create_interior_facet_integral(unsigned int i) const
 
2194
  virtual ufc::interior_facet_integral* create_interior_facet_integral(std::size_t i) const
 
2195
  {
 
2196
    return 0;
 
2197
  }
 
2198
 
 
2199
  /// Create a new cell integral on everywhere else
 
2200
  virtual ufc::cell_integral* create_default_cell_integral() const
 
2201
  {
 
2202
    return 0;
 
2203
  }
 
2204
 
 
2205
  /// Create a new exterior facet integral on everywhere else
 
2206
  virtual ufc::exterior_facet_integral* create_default_exterior_facet_integral() const
 
2207
  {
 
2208
    return 0;
 
2209
  }
 
2210
 
 
2211
  /// Create a new interior facet integral on everywhere else
 
2212
  virtual ufc::interior_facet_integral* create_default_interior_facet_integral() const
2221
2213
  {
2222
2214
    return 0;
2223
2215
  }
2258
2250
  /// Return a string identifying the form
2259
2251
  virtual const char* signature() const
2260
2252
  {
2261
 
    return "78d1a260514bb7770a5d53606c2ed59bb8d1f39ba5a49dbae5bb974f831fe896b7686c1d1c02adf1adf79c243ef7a303e7406059f122faba024d503d76b7cad1";
 
2253
    return "b90e8813365e5fa06e1e0b75dbbe1a4a7729cc03a1dfd43caa3296bc2908db84d3aac4f9e1220007e11927ad07707d2e9266c2d8d4742a78eecc84fc6831ede1";
2262
2254
  }
2263
2255
 
2264
2256
  /// Return the rank of the global tensor (r)
2265
 
  virtual unsigned int rank() const
 
2257
  virtual std::size_t rank() const
2266
2258
  {
2267
2259
    return 1;
2268
2260
  }
2269
2261
 
2270
2262
  /// Return the number of coefficients (n)
2271
 
  virtual unsigned int num_coefficients() const
 
2263
  virtual std::size_t num_coefficients() const
2272
2264
  {
2273
2265
    return 3;
2274
2266
  }
2275
2267
 
2276
2268
  /// Return the number of cell domains
2277
 
  virtual unsigned int num_cell_domains() const
 
2269
  virtual std::size_t num_cell_domains() const
2278
2270
  {
2279
2271
    return 1;
2280
2272
  }
2281
2273
 
2282
2274
  /// Return the number of exterior facet domains
2283
 
  virtual unsigned int num_exterior_facet_domains() const
 
2275
  virtual std::size_t num_exterior_facet_domains() const
2284
2276
  {
2285
2277
    return 0;
2286
2278
  }
2287
2279
 
2288
2280
  /// Return the number of interior facet domains
2289
 
  virtual unsigned int num_interior_facet_domains() const
 
2281
  virtual std::size_t num_interior_facet_domains() const
2290
2282
  {
2291
2283
    return 0;
2292
2284
  }
2293
2285
 
 
2286
  /// Return whether the form has any cell integrals
 
2287
  virtual bool has_cell_integrals() const
 
2288
  {
 
2289
    return true;
 
2290
  }
 
2291
 
 
2292
  /// Return whether the form has any exterior facet integrals
 
2293
  virtual bool has_exterior_facet_integrals() const
 
2294
  {
 
2295
    return false;
 
2296
  }
 
2297
 
 
2298
  /// Return whether the form has any interior facet integrals
 
2299
  virtual bool has_interior_facet_integrals() const
 
2300
  {
 
2301
    return false;
 
2302
  }
 
2303
 
2294
2304
  /// Create a new finite element for argument function i
2295
 
  virtual ufc::finite_element* create_finite_element(unsigned int i) const
 
2305
  virtual ufc::finite_element* create_finite_element(std::size_t i) const
2296
2306
  {
2297
2307
    switch (i)
2298
2308
    {
2322
2332
  }
2323
2333
 
2324
2334
  /// Create a new dofmap for argument function i
2325
 
  virtual ufc::dofmap* create_dofmap(unsigned int i) const
 
2335
  virtual ufc::dofmap* create_dofmap(std::size_t i) const
2326
2336
  {
2327
2337
    switch (i)
2328
2338
    {
2352
2362
  }
2353
2363
 
2354
2364
  /// Create a new cell integral on sub domain i
2355
 
  virtual ufc::cell_integral* create_cell_integral(unsigned int i) const
 
2365
  virtual ufc::cell_integral* create_cell_integral(std::size_t i) const
2356
2366
  {
2357
2367
    switch (i)
2358
2368
    {
2367
2377
  }
2368
2378
 
2369
2379
  /// Create a new exterior facet integral on sub domain i
2370
 
  virtual ufc::exterior_facet_integral* create_exterior_facet_integral(unsigned int i) const
 
2380
  virtual ufc::exterior_facet_integral* create_exterior_facet_integral(std::size_t i) const
2371
2381
  {
2372
2382
    return 0;
2373
2383
  }
2374
2384
 
2375
2385
  /// Create a new interior facet integral on sub domain i
2376
 
  virtual ufc::interior_facet_integral* create_interior_facet_integral(unsigned int i) const
 
2386
  virtual ufc::interior_facet_integral* create_interior_facet_integral(std::size_t i) const
 
2387
  {
 
2388
    return 0;
 
2389
  }
 
2390
 
 
2391
  /// Create a new cell integral on everywhere else
 
2392
  virtual ufc::cell_integral* create_default_cell_integral() const
 
2393
  {
 
2394
    return 0;
 
2395
  }
 
2396
 
 
2397
  /// Create a new exterior facet integral on everywhere else
 
2398
  virtual ufc::exterior_facet_integral* create_default_exterior_facet_integral() const
 
2399
  {
 
2400
    return 0;
 
2401
  }
 
2402
 
 
2403
  /// Create a new interior facet integral on everywhere else
 
2404
  virtual ufc::interior_facet_integral* create_default_interior_facet_integral() const
2377
2405
  {
2378
2406
    return 0;
2379
2407
  }