← Back to branch summary

~ubuntu-branches/ubuntu/natty/dolfin/natty

« back to all changes in this revision

Viewing changes to demo/undocumented/reaction-diffusion/cpp/ReactionDiffusion.h

  • Committer: Bazaar Package Importer
  • Author(s): Johannes Ring
  • Date: 2011-02-24 10:34:44 UTC
  • mfrom: (1.1.7 upstream) (14.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20110224103444-n3fwnmh32lfoske0
Tags: 0.9.10-1
http://bugs.debian.org/612602
* New upstream release. This release fixes bug "FTBFS: error:
  'SCOTCH_Dgraph' was not declared in this scope" (closes: #612602).
* debian/control:
  - Add libslepc3.1-dev and libboost-thread-dev to Build-Depends and
    Depends field in binary package libdolfin0-dev.
  - Bump build dependency on python-ufc to >= 2.0.0.
  - Remove Build-Depends-Indep field as upstream no longer ships the
    user manual.
  - Remove old fields Conflicts, Provides, and Replaces from
    libdolfin0-dev, libdolfin0, libdolfin0-dbg, and python-dolfin.
* Remove all patches as they are now incorporated upstream.
* Add dolfin-plot and dolfin-version to debian/dolfin-bin.install.
* Remove .doc-base file since the user manual is removed by upstream.
* Remove targets clean and install/dolfin-doc from debian/rules since
  they are no longer needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
demo/undocumented/reaction-diffusion/cpp/ReactionDiffusion.h
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.2
 
2
// and was automatically generated by FFC version 0.9.4+.
3
3
//
4
4
// This code was generated with the option '-l dolfin' and
5
5
// contains DOLFIN-specific wrappers that depend on DOLFIN.
9
9
//   cache_dir:                      ''
10
10
//   convert_exceptions_to_warnings: False
11
11
//   cpp_optimize:                   False
 
12
//   cpp_optimize_flags:             '-O2'
12
13
//   epsilon:                        1e-14
 
14
//   error_control:                  False
13
15
//   form_postfix:                   True
14
16
//   format:                         'dolfin'
15
17
//   log_level:                      10
16
18
//   log_prefix:                     ''
 
19
//   no_ferari:                      True
17
20
//   optimize:                       True
18
21
//   output_dir:                     '.'
19
22
//   precision:                      15
60
63
    return ufc::triangle;
61
64
  }
62
65
 
 
66
  /// Return the topological dimension of the cell shape
 
67
  virtual unsigned int topological_dimension() const
 
68
  {
 
69
    return 2;
 
70
  }
 
71
 
 
72
  /// Return the geometric dimension of the cell shape
 
73
  virtual unsigned int geometric_dimension() const
 
74
  {
 
75
    return 2;
 
76
  }
 
77
 
63
78
  /// Return the dimension of the finite element function space
64
79
  virtual unsigned int space_dimension() const
65
80
  {
939
954
    vertex_values[2] = dof_values[2];
940
955
  }
941
956
 
 
957
  /// Map coordinate xhat from reference cell to coordinate x in cell
 
958
  virtual void map_from_reference_cell(double* x,
 
959
                                       const double* xhat,
 
960
                                       const ufc::cell& c)
 
961
  {
 
962
    throw std::runtime_error("map_from_reference_cell not yet implemented (introduced in UFC 2.0).");
 
963
  }
 
964
 
 
965
  /// Map from coordinate x in cell to coordinate xhat in reference cell
 
966
  virtual void map_to_reference_cell(double* xhat,
 
967
                                     const double* x,
 
968
                                     const ufc::cell& c)
 
969
  {
 
970
    throw std::runtime_error("map_to_reference_cell not yet implemented (introduced in UFC 2.0).");
 
971
  }
 
972
 
942
973
  /// Return the number of sub elements (for a mixed element)
943
974
  virtual unsigned int num_sub_elements() const
944
975
  {
951
982
    return 0;
952
983
  }
953
984
 
 
985
  /// Create a new class instance
 
986
  virtual ufc::finite_element* create() const
 
987
  {
 
988
    return new reactiondiffusion_finite_element_0();
 
989
  }
 
990
 
954
991
};
955
992
 
956
993
/// This class defines the interface for a local-to-global mapping of
957
994
/// degrees of freedom (dofs).
958
995
 
959
 
class reactiondiffusion_dof_map_0: public ufc::dof_map
 
996
class reactiondiffusion_dofmap_0: public ufc::dofmap
960
997
{
961
998
private:
962
999
 
964
1001
public:
965
1002
 
966
1003
  /// Constructor
967
 
  reactiondiffusion_dof_map_0() : ufc::dof_map()
 
1004
  reactiondiffusion_dofmap_0() : ufc::dofmap()
968
1005
  {
969
1006
    _global_dimension = 0;
970
1007
  }
971
1008
 
972
1009
  /// Destructor
973
 
  virtual ~reactiondiffusion_dof_map_0()
 
1010
  virtual ~reactiondiffusion_dofmap_0()
974
1011
  {
975
1012
    // Do nothing
976
1013
  }
977
1014
 
978
 
  /// Return a string identifying the dof map
 
1015
  /// Return a string identifying the dofmap
979
1016
  virtual const char* signature() const
980
1017
  {
981
1018
    return "FFC dofmap for FiniteElement('Lagrange', Cell('triangle', 1, Space(2)), 1)";
1006
1043
    return false;
1007
1044
  }
1008
1045
 
1009
 
  /// Initialize dof map for mesh (return true iff init_cell() is needed)
 
1046
  /// Initialize dofmap for mesh (return true iff init_cell() is needed)
1010
1047
  virtual bool init_mesh(const ufc::mesh& m)
1011
1048
  {
1012
1049
    _global_dimension = m.num_entities[0];
1013
1050
    return false;
1014
1051
  }
1015
1052
 
1016
 
  /// Initialize dof map for given cell
 
1053
  /// Initialize dofmap for given cell
1017
1054
  virtual void init_cell(const ufc::mesh& m,
1018
1055
                         const ufc::cell& c)
1019
1056
  {
1020
1057
    // Do nothing
1021
1058
  }
1022
1059
 
1023
 
  /// Finish initialization of dof map for cells
 
1060
  /// Finish initialization of dofmap for cells
1024
1061
  virtual void init_cell_finalize()
1025
1062
  {
1026
1063
    // Do nothing
1027
1064
  }
1028
1065
 
 
1066
  /// Return the topological dimension of the associated cell shape
 
1067
  virtual unsigned int topological_dimension() const
 
1068
  {
 
1069
    return 2;
 
1070
  }
 
1071
 
 
1072
  /// Return the geometric dimension of the associated cell shape
 
1073
  virtual unsigned int geometric_dimension() const
 
1074
  {
 
1075
    return 2;
 
1076
  }
 
1077
 
1029
1078
  /// Return the dimension of the global finite element function space
1030
1079
  virtual unsigned int global_dimension() const
1031
1080
  {
1044
1093
    return 3;
1045
1094
  }
1046
1095
 
1047
 
  // Return the geometric dimension of the coordinates this dof map provides
1048
 
  virtual unsigned int geometric_dimension() const
1049
 
  {
1050
 
    return 2;
1051
 
  }
1052
 
 
1053
1096
  /// Return the number of dofs on each cell facet
1054
1097
  virtual unsigned int num_facet_dofs() const
1055
1098
  {
1186
1229
    coordinates[2][1] = x[2][1];
1187
1230
  }
1188
1231
 
1189
 
  /// Return the number of sub dof maps (for a mixed element)
1190
 
  virtual unsigned int num_sub_dof_maps() const
1191
 
  {
1192
 
    return 0;
1193
 
  }
1194
 
 
1195
 
  /// Create a new dof_map for sub dof map i (for a mixed element)
1196
 
  virtual ufc::dof_map* create_sub_dof_map(unsigned int i) const
1197
 
  {
1198
 
    return 0;
 
1232
  /// Return the number of sub dofmaps (for a mixed element)
 
1233
  virtual unsigned int num_sub_dofmaps() const
 
1234
  {
 
1235
    return 0;
 
1236
  }
 
1237
 
 
1238
  /// Create a new dofmap for sub dofmap i (for a mixed element)
 
1239
  virtual ufc::dofmap* create_sub_dofmap(unsigned int i) const
 
1240
  {
 
1241
    return 0;
 
1242
  }
 
1243
 
 
1244
  /// Create a new class instance
 
1245
  virtual ufc::dofmap* create() const
 
1246
  {
 
1247
    return new reactiondiffusion_dofmap_0();
1199
1248
  }
1200
1249
 
1201
1250
};
1270
1319
    A[8] = 0.499999999999999*G0_1_1 + 0.083333333333333*G1_;
1271
1320
  }
1272
1321
 
 
1322
  /// Tabulate the tensor for the contribution from a local cell
 
1323
  /// using the specified reference cell quadrature points/weights
 
1324
  virtual void tabulate_tensor(double* A,
 
1325
                               const double * const * w,
 
1326
                               const ufc::cell& c,
 
1327
                               unsigned int num_quadrature_points,
 
1328
                               const double * const * quadrature_points,
 
1329
                               const double* quadrature_weights) const
 
1330
  {
 
1331
    throw std::runtime_error("Quadrature version of tabulate_tensor not available when using the FFC tensor representation.");
 
1332
  }
 
1333
 
1273
1334
};
1274
1335
 
1275
1336
/// This class defines the interface for the tabulation of the cell
1330
1391
    A[2] = 0.041666666666667*G0_0 + 0.041666666666667*G0_1 + 0.083333333333333*G0_2;
1331
1392
  }
1332
1393
 
 
1394
  /// Tabulate the tensor for the contribution from a local cell
 
1395
  /// using the specified reference cell quadrature points/weights
 
1396
  virtual void tabulate_tensor(double* A,
 
1397
                               const double * const * w,
 
1398
                               const ufc::cell& c,
 
1399
                               unsigned int num_quadrature_points,
 
1400
                               const double * const * quadrature_points,
 
1401
                               const double* quadrature_weights) const
 
1402
  {
 
1403
    throw std::runtime_error("Quadrature version of tabulate_tensor not available when using the FFC tensor representation.");
 
1404
  }
 
1405
 
1333
1406
};
1334
1407
 
1335
1408
/// This class defines the interface for the assembly of the global
1381
1454
    return 0;
1382
1455
  }
1383
1456
 
1384
 
  /// Return the number of cell integrals
1385
 
  virtual unsigned int num_cell_integrals() const
 
1457
  /// Return the number of cell domains
 
1458
  virtual unsigned int num_cell_domains() const
1386
1459
  {
1387
1460
    return 1;
1388
1461
  }
1389
1462
 
1390
 
  /// Return the number of exterior facet integrals
1391
 
  virtual unsigned int num_exterior_facet_integrals() const
 
1463
  /// Return the number of exterior facet domains
 
1464
  virtual unsigned int num_exterior_facet_domains() const
1392
1465
  {
1393
1466
    return 0;
1394
1467
  }
1395
1468
 
1396
 
  /// Return the number of interior facet integrals
1397
 
  virtual unsigned int num_interior_facet_integrals() const
 
1469
  /// Return the number of interior facet domains
 
1470
  virtual unsigned int num_interior_facet_domains() const
1398
1471
  {
1399
1472
    return 0;
1400
1473
  }
1419
1492
    return 0;
1420
1493
  }
1421
1494
 
1422
 
  /// Create a new dof map for argument function i
1423
 
  virtual ufc::dof_map* create_dof_map(unsigned int i) const
 
1495
  /// Create a new dofmap for argument function i
 
1496
  virtual ufc::dofmap* create_dofmap(unsigned int i) const
1424
1497
  {
1425
1498
    switch (i)
1426
1499
    {
1427
1500
    case 0:
1428
1501
      {
1429
 
        return new reactiondiffusion_dof_map_0();
 
1502
        return new reactiondiffusion_dofmap_0();
1430
1503
        break;
1431
1504
      }
1432
1505
    case 1:
1433
1506
      {
1434
 
        return new reactiondiffusion_dof_map_0();
 
1507
        return new reactiondiffusion_dofmap_0();
1435
1508
        break;
1436
1509
      }
1437
1510
    }
1517
1590
    return 1;
1518
1591
  }
1519
1592
 
1520
 
  /// Return the number of cell integrals
1521
 
  virtual unsigned int num_cell_integrals() const
 
1593
  /// Return the number of cell domains
 
1594
  virtual unsigned int num_cell_domains() const
1522
1595
  {
1523
1596
    return 1;
1524
1597
  }
1525
1598
 
1526
 
  /// Return the number of exterior facet integrals
1527
 
  virtual unsigned int num_exterior_facet_integrals() const
 
1599
  /// Return the number of exterior facet domains
 
1600
  virtual unsigned int num_exterior_facet_domains() const
1528
1601
  {
1529
1602
    return 0;
1530
1603
  }
1531
1604
 
1532
 
  /// Return the number of interior facet integrals
1533
 
  virtual unsigned int num_interior_facet_integrals() const
 
1605
  /// Return the number of interior facet domains
 
1606
  virtual unsigned int num_interior_facet_domains() const
1534
1607
  {
1535
1608
    return 0;
1536
1609
  }
1555
1628
    return 0;
1556
1629
  }
1557
1630
 
1558
 
  /// Create a new dof map for argument function i
1559
 
  virtual ufc::dof_map* create_dof_map(unsigned int i) const
 
1631
  /// Create a new dofmap for argument function i
 
1632
  virtual ufc::dofmap* create_dofmap(unsigned int i) const
1560
1633
  {
1561
1634
    switch (i)
1562
1635
    {
1563
1636
    case 0:
1564
1637
      {
1565
 
        return new reactiondiffusion_dof_map_0();
 
1638
        return new reactiondiffusion_dofmap_0();
1566
1639
        break;
1567
1640
      }
1568
1641
    case 1:
1569
1642
      {
1570
 
        return new reactiondiffusion_dof_map_0();
 
1643
        return new reactiondiffusion_dofmap_0();
1571
1644
        break;
1572
1645
      }
1573
1646
    }
1617
1690
#include <dolfin/function/FunctionSpace.h>
1618
1691
#include <dolfin/function/GenericFunction.h>
1619
1692
#include <dolfin/function/CoefficientAssigner.h>
 
1693
#include <dolfin/adaptivity/ErrorControl.h>
 
1694
#include <dolfin/adaptivity/GoalFunctional.h>
1620
1695
 
1621
1696
namespace ReactionDiffusion
1622
1697
{
1628
1703
  CoefficientSpace_f(const dolfin::Mesh& mesh):
1629
1704
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
1630
1705
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1631
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), mesh)))
 
1706
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), mesh)))
1632
1707
  {
1633
1708
    // Do nothing
1634
1709
  }
1636
1711
  CoefficientSpace_f(dolfin::Mesh& mesh):
1637
1712
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
1638
1713
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1639
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), mesh)))
 
1714
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), mesh)))
1640
1715
  {
1641
1716
    // Do nothing
1642
1717
  }
1644
1719
  CoefficientSpace_f(boost::shared_ptr<dolfin::Mesh> mesh):
1645
1720
    dolfin::FunctionSpace(mesh,
1646
1721
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1647
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), *mesh)))
 
1722
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), *mesh)))
1648
1723
  {
1649
1724
      // Do nothing
1650
1725
  }
1652
1727
  CoefficientSpace_f(boost::shared_ptr<const dolfin::Mesh> mesh):
1653
1728
    dolfin::FunctionSpace(mesh,
1654
1729
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1655
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), *mesh)))
 
1730
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), *mesh)))
1656
1731
  {
1657
1732
      // Do nothing
1658
1733
  }
1670
1745
  Form_0_FunctionSpace_0(const dolfin::Mesh& mesh):
1671
1746
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
1672
1747
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1673
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), mesh)))
 
1748
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), mesh)))
1674
1749
  {
1675
1750
    // Do nothing
1676
1751
  }
1678
1753
  Form_0_FunctionSpace_0(dolfin::Mesh& mesh):
1679
1754
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
1680
1755
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1681
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), mesh)))
 
1756
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), mesh)))
1682
1757
  {
1683
1758
    // Do nothing
1684
1759
  }
1686
1761
  Form_0_FunctionSpace_0(boost::shared_ptr<dolfin::Mesh> mesh):
1687
1762
    dolfin::FunctionSpace(mesh,
1688
1763
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1689
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), *mesh)))
 
1764
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), *mesh)))
1690
1765
  {
1691
1766
      // Do nothing
1692
1767
  }
1694
1769
  Form_0_FunctionSpace_0(boost::shared_ptr<const dolfin::Mesh> mesh):
1695
1770
    dolfin::FunctionSpace(mesh,
1696
1771
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1697
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), *mesh)))
 
1772
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), *mesh)))
1698
1773
  {
1699
1774
      // Do nothing
1700
1775
  }
1712
1787
  Form_0_FunctionSpace_1(const dolfin::Mesh& mesh):
1713
1788
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
1714
1789
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1715
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), mesh)))
 
1790
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), mesh)))
1716
1791
  {
1717
1792
    // Do nothing
1718
1793
  }
1720
1795
  Form_0_FunctionSpace_1(dolfin::Mesh& mesh):
1721
1796
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
1722
1797
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1723
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), mesh)))
 
1798
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), mesh)))
1724
1799
  {
1725
1800
    // Do nothing
1726
1801
  }
1728
1803
  Form_0_FunctionSpace_1(boost::shared_ptr<dolfin::Mesh> mesh):
1729
1804
    dolfin::FunctionSpace(mesh,
1730
1805
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1731
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), *mesh)))
 
1806
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), *mesh)))
1732
1807
  {
1733
1808
      // Do nothing
1734
1809
  }
1736
1811
  Form_0_FunctionSpace_1(boost::shared_ptr<const dolfin::Mesh> mesh):
1737
1812
    dolfin::FunctionSpace(mesh,
1738
1813
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1739
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), *mesh)))
 
1814
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), *mesh)))
1740
1815
  {
1741
1816
      // Do nothing
1742
1817
  }
1805
1880
  Form_1_FunctionSpace_0(const dolfin::Mesh& mesh):
1806
1881
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
1807
1882
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1808
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), mesh)))
 
1883
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), mesh)))
1809
1884
  {
1810
1885
    // Do nothing
1811
1886
  }
1813
1888
  Form_1_FunctionSpace_0(dolfin::Mesh& mesh):
1814
1889
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
1815
1890
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1816
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), mesh)))
 
1891
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), mesh)))
1817
1892
  {
1818
1893
    // Do nothing
1819
1894
  }
1821
1896
  Form_1_FunctionSpace_0(boost::shared_ptr<dolfin::Mesh> mesh):
1822
1897
    dolfin::FunctionSpace(mesh,
1823
1898
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1824
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), *mesh)))
 
1899
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), *mesh)))
1825
1900
  {
1826
1901
      // Do nothing
1827
1902
  }
1829
1904
  Form_1_FunctionSpace_0(boost::shared_ptr<const dolfin::Mesh> mesh):
1830
1905
    dolfin::FunctionSpace(mesh,
1831
1906
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new reactiondiffusion_finite_element_0()))),
1832
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new reactiondiffusion_dof_map_0()), *mesh)))
 
1907
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new reactiondiffusion_dofmap_0()), *mesh)))
1833
1908
  {
1834
1909
      // Do nothing
1835
1910
  }