← Back to branch summary

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

« back to all changes in this revision

Viewing changes to bench/fem/speedup/cpp/Poisson.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:
bench/fem/speedup/cpp/Poisson.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::tetrahedron;
61
64
  }
62
65
 
 
66
  /// Return the topological dimension of the cell shape
 
67
  virtual unsigned int topological_dimension() const
 
68
  {
 
69
    return 3;
 
70
  }
 
71
 
 
72
  /// Return the geometric dimension of the cell shape
 
73
  virtual unsigned int geometric_dimension() const
 
74
  {
 
75
    return 3;
 
76
  }
 
77
 
63
78
  /// Return the dimension of the finite element function space
64
79
  virtual unsigned int space_dimension() const
65
80
  {
1393
1408
    vertex_values[3] = dof_values[3];
1394
1409
  }
1395
1410
 
 
1411
  /// Map coordinate xhat from reference cell to coordinate x in cell
 
1412
  virtual void map_from_reference_cell(double* x,
 
1413
                                       const double* xhat,
 
1414
                                       const ufc::cell& c)
 
1415
  {
 
1416
    throw std::runtime_error("map_from_reference_cell not yet implemented (introduced in UFC 2.0).");
 
1417
  }
 
1418
 
 
1419
  /// Map from coordinate x in cell to coordinate xhat in reference cell
 
1420
  virtual void map_to_reference_cell(double* xhat,
 
1421
                                     const double* x,
 
1422
                                     const ufc::cell& c)
 
1423
  {
 
1424
    throw std::runtime_error("map_to_reference_cell not yet implemented (introduced in UFC 2.0).");
 
1425
  }
 
1426
 
1396
1427
  /// Return the number of sub elements (for a mixed element)
1397
1428
  virtual unsigned int num_sub_elements() const
1398
1429
  {
1405
1436
    return 0;
1406
1437
  }
1407
1438
 
 
1439
  /// Create a new class instance
 
1440
  virtual ufc::finite_element* create() const
 
1441
  {
 
1442
    return new poisson_finite_element_0();
 
1443
  }
 
1444
 
1408
1445
};
1409
1446
 
1410
1447
/// This class defines the interface for a local-to-global mapping of
1411
1448
/// degrees of freedom (dofs).
1412
1449
 
1413
 
class poisson_dof_map_0: public ufc::dof_map
 
1450
class poisson_dofmap_0: public ufc::dofmap
1414
1451
{
1415
1452
private:
1416
1453
 
1418
1455
public:
1419
1456
 
1420
1457
  /// Constructor
1421
 
  poisson_dof_map_0() : ufc::dof_map()
 
1458
  poisson_dofmap_0() : ufc::dofmap()
1422
1459
  {
1423
1460
    _global_dimension = 0;
1424
1461
  }
1425
1462
 
1426
1463
  /// Destructor
1427
 
  virtual ~poisson_dof_map_0()
 
1464
  virtual ~poisson_dofmap_0()
1428
1465
  {
1429
1466
    // Do nothing
1430
1467
  }
1431
1468
 
1432
 
  /// Return a string identifying the dof map
 
1469
  /// Return a string identifying the dofmap
1433
1470
  virtual const char* signature() const
1434
1471
  {
1435
1472
    return "FFC dofmap for FiniteElement('Lagrange', Cell('tetrahedron', 1, Space(3)), 1)";
1465
1502
    return false;
1466
1503
  }
1467
1504
 
1468
 
  /// Initialize dof map for mesh (return true iff init_cell() is needed)
 
1505
  /// Initialize dofmap for mesh (return true iff init_cell() is needed)
1469
1506
  virtual bool init_mesh(const ufc::mesh& m)
1470
1507
  {
1471
1508
    _global_dimension = m.num_entities[0];
1472
1509
    return false;
1473
1510
  }
1474
1511
 
1475
 
  /// Initialize dof map for given cell
 
1512
  /// Initialize dofmap for given cell
1476
1513
  virtual void init_cell(const ufc::mesh& m,
1477
1514
                         const ufc::cell& c)
1478
1515
  {
1479
1516
    // Do nothing
1480
1517
  }
1481
1518
 
1482
 
  /// Finish initialization of dof map for cells
 
1519
  /// Finish initialization of dofmap for cells
1483
1520
  virtual void init_cell_finalize()
1484
1521
  {
1485
1522
    // Do nothing
1486
1523
  }
1487
1524
 
 
1525
  /// Return the topological dimension of the associated cell shape
 
1526
  virtual unsigned int topological_dimension() const
 
1527
  {
 
1528
    return 3;
 
1529
  }
 
1530
 
 
1531
  /// Return the geometric dimension of the associated cell shape
 
1532
  virtual unsigned int geometric_dimension() const
 
1533
  {
 
1534
    return 3;
 
1535
  }
 
1536
 
1488
1537
  /// Return the dimension of the global finite element function space
1489
1538
  virtual unsigned int global_dimension() const
1490
1539
  {
1503
1552
    return 4;
1504
1553
  }
1505
1554
 
1506
 
  // Return the geometric dimension of the coordinates this dof map provides
1507
 
  virtual unsigned int geometric_dimension() const
1508
 
  {
1509
 
    return 3;
1510
 
  }
1511
 
 
1512
1555
  /// Return the number of dofs on each cell facet
1513
1556
  virtual unsigned int num_facet_dofs() const
1514
1557
  {
1677
1720
    coordinates[3][2] = x[3][2];
1678
1721
  }
1679
1722
 
1680
 
  /// Return the number of sub dof maps (for a mixed element)
1681
 
  virtual unsigned int num_sub_dof_maps() const
1682
 
  {
1683
 
    return 0;
1684
 
  }
1685
 
 
1686
 
  /// Create a new dof_map for sub dof map i (for a mixed element)
1687
 
  virtual ufc::dof_map* create_sub_dof_map(unsigned int i) const
1688
 
  {
1689
 
    return 0;
 
1723
  /// Return the number of sub dofmaps (for a mixed element)
 
1724
  virtual unsigned int num_sub_dofmaps() const
 
1725
  {
 
1726
    return 0;
 
1727
  }
 
1728
 
 
1729
  /// Create a new dofmap for sub dofmap i (for a mixed element)
 
1730
  virtual ufc::dofmap* create_sub_dofmap(unsigned int i) const
 
1731
  {
 
1732
    return 0;
 
1733
  }
 
1734
 
 
1735
  /// Create a new class instance
 
1736
  virtual ufc::dofmap* create() const
 
1737
  {
 
1738
    return new poisson_dofmap_0();
1690
1739
  }
1691
1740
 
1692
1741
};
1793
1842
    A[15] = 0.166666666666666*G0_2_2;
1794
1843
  }
1795
1844
 
 
1845
  /// Tabulate the tensor for the contribution from a local cell
 
1846
  /// using the specified reference cell quadrature points/weights
 
1847
  virtual void tabulate_tensor(double* A,
 
1848
                               const double * const * w,
 
1849
                               const ufc::cell& c,
 
1850
                               unsigned int num_quadrature_points,
 
1851
                               const double * const * quadrature_points,
 
1852
                               const double* quadrature_weights) const
 
1853
  {
 
1854
    throw std::runtime_error("Quadrature version of tabulate_tensor not available when using the FFC tensor representation.");
 
1855
  }
 
1856
 
1796
1857
};
1797
1858
 
1798
1859
/// This class defines the interface for the tabulation of the cell
1865
1926
    A[3] = 0.008333333333333*G0_0 + 0.008333333333333*G0_1 + 0.008333333333333*G0_2 + 0.016666666666667*G0_3;
1866
1927
  }
1867
1928
 
 
1929
  /// Tabulate the tensor for the contribution from a local cell
 
1930
  /// using the specified reference cell quadrature points/weights
 
1931
  virtual void tabulate_tensor(double* A,
 
1932
                               const double * const * w,
 
1933
                               const ufc::cell& c,
 
1934
                               unsigned int num_quadrature_points,
 
1935
                               const double * const * quadrature_points,
 
1936
                               const double* quadrature_weights) const
 
1937
  {
 
1938
    throw std::runtime_error("Quadrature version of tabulate_tensor not available when using the FFC tensor representation.");
 
1939
  }
 
1940
 
1868
1941
};
1869
1942
 
1870
1943
/// This class defines the interface for the assembly of the global
1916
1989
    return 0;
1917
1990
  }
1918
1991
 
1919
 
  /// Return the number of cell integrals
1920
 
  virtual unsigned int num_cell_integrals() const
 
1992
  /// Return the number of cell domains
 
1993
  virtual unsigned int num_cell_domains() const
1921
1994
  {
1922
1995
    return 1;
1923
1996
  }
1924
1997
 
1925
 
  /// Return the number of exterior facet integrals
1926
 
  virtual unsigned int num_exterior_facet_integrals() const
 
1998
  /// Return the number of exterior facet domains
 
1999
  virtual unsigned int num_exterior_facet_domains() const
1927
2000
  {
1928
2001
    return 0;
1929
2002
  }
1930
2003
 
1931
 
  /// Return the number of interior facet integrals
1932
 
  virtual unsigned int num_interior_facet_integrals() const
 
2004
  /// Return the number of interior facet domains
 
2005
  virtual unsigned int num_interior_facet_domains() const
1933
2006
  {
1934
2007
    return 0;
1935
2008
  }
1954
2027
    return 0;
1955
2028
  }
1956
2029
 
1957
 
  /// Create a new dof map for argument function i
1958
 
  virtual ufc::dof_map* create_dof_map(unsigned int i) const
 
2030
  /// Create a new dofmap for argument function i
 
2031
  virtual ufc::dofmap* create_dofmap(unsigned int i) const
1959
2032
  {
1960
2033
    switch (i)
1961
2034
    {
1962
2035
    case 0:
1963
2036
      {
1964
 
        return new poisson_dof_map_0();
 
2037
        return new poisson_dofmap_0();
1965
2038
        break;
1966
2039
      }
1967
2040
    case 1:
1968
2041
      {
1969
 
        return new poisson_dof_map_0();
 
2042
        return new poisson_dofmap_0();
1970
2043
        break;
1971
2044
      }
1972
2045
    }
2052
2125
    return 1;
2053
2126
  }
2054
2127
 
2055
 
  /// Return the number of cell integrals
2056
 
  virtual unsigned int num_cell_integrals() const
 
2128
  /// Return the number of cell domains
 
2129
  virtual unsigned int num_cell_domains() const
2057
2130
  {
2058
2131
    return 1;
2059
2132
  }
2060
2133
 
2061
 
  /// Return the number of exterior facet integrals
2062
 
  virtual unsigned int num_exterior_facet_integrals() const
 
2134
  /// Return the number of exterior facet domains
 
2135
  virtual unsigned int num_exterior_facet_domains() const
2063
2136
  {
2064
2137
    return 0;
2065
2138
  }
2066
2139
 
2067
 
  /// Return the number of interior facet integrals
2068
 
  virtual unsigned int num_interior_facet_integrals() const
 
2140
  /// Return the number of interior facet domains
 
2141
  virtual unsigned int num_interior_facet_domains() const
2069
2142
  {
2070
2143
    return 0;
2071
2144
  }
2090
2163
    return 0;
2091
2164
  }
2092
2165
 
2093
 
  /// Create a new dof map for argument function i
2094
 
  virtual ufc::dof_map* create_dof_map(unsigned int i) const
 
2166
  /// Create a new dofmap for argument function i
 
2167
  virtual ufc::dofmap* create_dofmap(unsigned int i) const
2095
2168
  {
2096
2169
    switch (i)
2097
2170
    {
2098
2171
    case 0:
2099
2172
      {
2100
 
        return new poisson_dof_map_0();
 
2173
        return new poisson_dofmap_0();
2101
2174
        break;
2102
2175
      }
2103
2176
    case 1:
2104
2177
      {
2105
 
        return new poisson_dof_map_0();
 
2178
        return new poisson_dofmap_0();
2106
2179
        break;
2107
2180
      }
2108
2181
    }
2152
2225
#include <dolfin/function/FunctionSpace.h>
2153
2226
#include <dolfin/function/GenericFunction.h>
2154
2227
#include <dolfin/function/CoefficientAssigner.h>
 
2228
#include <dolfin/adaptivity/ErrorControl.h>
 
2229
#include <dolfin/adaptivity/GoalFunctional.h>
2155
2230
 
2156
2231
namespace Poisson
2157
2232
{
2163
2238
  CoefficientSpace_f(const dolfin::Mesh& mesh):
2164
2239
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
2165
2240
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2166
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), mesh)))
 
2241
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), mesh)))
2167
2242
  {
2168
2243
    // Do nothing
2169
2244
  }
2171
2246
  CoefficientSpace_f(dolfin::Mesh& mesh):
2172
2247
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
2173
2248
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2174
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), mesh)))
 
2249
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), mesh)))
2175
2250
  {
2176
2251
    // Do nothing
2177
2252
  }
2179
2254
  CoefficientSpace_f(boost::shared_ptr<dolfin::Mesh> mesh):
2180
2255
    dolfin::FunctionSpace(mesh,
2181
2256
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2182
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), *mesh)))
 
2257
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), *mesh)))
2183
2258
  {
2184
2259
      // Do nothing
2185
2260
  }
2187
2262
  CoefficientSpace_f(boost::shared_ptr<const dolfin::Mesh> mesh):
2188
2263
    dolfin::FunctionSpace(mesh,
2189
2264
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2190
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), *mesh)))
 
2265
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), *mesh)))
2191
2266
  {
2192
2267
      // Do nothing
2193
2268
  }
2205
2280
  Form_0_FunctionSpace_0(const dolfin::Mesh& mesh):
2206
2281
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
2207
2282
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2208
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), mesh)))
 
2283
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), mesh)))
2209
2284
  {
2210
2285
    // Do nothing
2211
2286
  }
2213
2288
  Form_0_FunctionSpace_0(dolfin::Mesh& mesh):
2214
2289
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
2215
2290
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2216
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), mesh)))
 
2291
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), mesh)))
2217
2292
  {
2218
2293
    // Do nothing
2219
2294
  }
2221
2296
  Form_0_FunctionSpace_0(boost::shared_ptr<dolfin::Mesh> mesh):
2222
2297
    dolfin::FunctionSpace(mesh,
2223
2298
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2224
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), *mesh)))
 
2299
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), *mesh)))
2225
2300
  {
2226
2301
      // Do nothing
2227
2302
  }
2229
2304
  Form_0_FunctionSpace_0(boost::shared_ptr<const dolfin::Mesh> mesh):
2230
2305
    dolfin::FunctionSpace(mesh,
2231
2306
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2232
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), *mesh)))
 
2307
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), *mesh)))
2233
2308
  {
2234
2309
      // Do nothing
2235
2310
  }
2247
2322
  Form_0_FunctionSpace_1(const dolfin::Mesh& mesh):
2248
2323
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
2249
2324
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2250
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), mesh)))
 
2325
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), mesh)))
2251
2326
  {
2252
2327
    // Do nothing
2253
2328
  }
2255
2330
  Form_0_FunctionSpace_1(dolfin::Mesh& mesh):
2256
2331
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
2257
2332
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2258
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), mesh)))
 
2333
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), mesh)))
2259
2334
  {
2260
2335
    // Do nothing
2261
2336
  }
2263
2338
  Form_0_FunctionSpace_1(boost::shared_ptr<dolfin::Mesh> mesh):
2264
2339
    dolfin::FunctionSpace(mesh,
2265
2340
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2266
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), *mesh)))
 
2341
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), *mesh)))
2267
2342
  {
2268
2343
      // Do nothing
2269
2344
  }
2271
2346
  Form_0_FunctionSpace_1(boost::shared_ptr<const dolfin::Mesh> mesh):
2272
2347
    dolfin::FunctionSpace(mesh,
2273
2348
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2274
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), *mesh)))
 
2349
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), *mesh)))
2275
2350
  {
2276
2351
      // Do nothing
2277
2352
  }
2340
2415
  Form_1_FunctionSpace_0(const dolfin::Mesh& mesh):
2341
2416
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
2342
2417
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2343
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), mesh)))
 
2418
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), mesh)))
2344
2419
  {
2345
2420
    // Do nothing
2346
2421
  }
2348
2423
  Form_1_FunctionSpace_0(dolfin::Mesh& mesh):
2349
2424
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
2350
2425
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2351
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), mesh)))
 
2426
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), mesh)))
2352
2427
  {
2353
2428
    // Do nothing
2354
2429
  }
2356
2431
  Form_1_FunctionSpace_0(boost::shared_ptr<dolfin::Mesh> mesh):
2357
2432
    dolfin::FunctionSpace(mesh,
2358
2433
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2359
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), *mesh)))
 
2434
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), *mesh)))
2360
2435
  {
2361
2436
      // Do nothing
2362
2437
  }
2364
2439
  Form_1_FunctionSpace_0(boost::shared_ptr<const dolfin::Mesh> mesh):
2365
2440
    dolfin::FunctionSpace(mesh,
2366
2441
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new poisson_finite_element_0()))),
2367
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new poisson_dof_map_0()), *mesh)))
 
2442
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new poisson_dofmap_0()), *mesh)))
2368
2443
  {
2369
2444
      // Do nothing
2370
2445
  }