← Back to branch summary

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

« back to all changes in this revision

Viewing changes to bench/fem/assembly/cpp/forms/Elasticity3D.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/assembly/cpp/forms/Elasticity3D.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 elasticity3d_finite_element_0();
 
1443
  }
 
1444
 
1408
1445
};
1409
1446
 
1410
1447
/// This class defines the interface for a finite element.
1437
1474
    return ufc::tetrahedron;
1438
1475
  }
1439
1476
 
 
1477
  /// Return the topological dimension of the cell shape
 
1478
  virtual unsigned int topological_dimension() const
 
1479
  {
 
1480
    return 3;
 
1481
  }
 
1482
 
 
1483
  /// Return the geometric dimension of the cell shape
 
1484
  virtual unsigned int geometric_dimension() const
 
1485
  {
 
1486
    return 3;
 
1487
  }
 
1488
 
1440
1489
  /// Return the dimension of the finite element function space
1441
1490
  virtual unsigned int space_dimension() const
1442
1491
  {
4874
4923
    vertex_values[11] = dof_values[11];
4875
4924
  }
4876
4925
 
 
4926
  /// Map coordinate xhat from reference cell to coordinate x in cell
 
4927
  virtual void map_from_reference_cell(double* x,
 
4928
                                       const double* xhat,
 
4929
                                       const ufc::cell& c)
 
4930
  {
 
4931
    throw std::runtime_error("map_from_reference_cell not yet implemented (introduced in UFC 2.0).");
 
4932
  }
 
4933
 
 
4934
  /// Map from coordinate x in cell to coordinate xhat in reference cell
 
4935
  virtual void map_to_reference_cell(double* xhat,
 
4936
                                     const double* x,
 
4937
                                     const ufc::cell& c)
 
4938
  {
 
4939
    throw std::runtime_error("map_to_reference_cell not yet implemented (introduced in UFC 2.0).");
 
4940
  }
 
4941
 
4877
4942
  /// Return the number of sub elements (for a mixed element)
4878
4943
  virtual unsigned int num_sub_elements() const
4879
4944
  {
4905
4970
    return 0;
4906
4971
  }
4907
4972
 
 
4973
  /// Create a new class instance
 
4974
  virtual ufc::finite_element* create() const
 
4975
  {
 
4976
    return new elasticity3d_finite_element_1();
 
4977
  }
 
4978
 
4908
4979
};
4909
4980
 
4910
4981
/// This class defines the interface for a local-to-global mapping of
4911
4982
/// degrees of freedom (dofs).
4912
4983
 
4913
 
class elasticity3d_dof_map_0: public ufc::dof_map
 
4984
class elasticity3d_dofmap_0: public ufc::dofmap
4914
4985
{
4915
4986
private:
4916
4987
 
4918
4989
public:
4919
4990
 
4920
4991
  /// Constructor
4921
 
  elasticity3d_dof_map_0() : ufc::dof_map()
 
4992
  elasticity3d_dofmap_0() : ufc::dofmap()
4922
4993
  {
4923
4994
    _global_dimension = 0;
4924
4995
  }
4925
4996
 
4926
4997
  /// Destructor
4927
 
  virtual ~elasticity3d_dof_map_0()
 
4998
  virtual ~elasticity3d_dofmap_0()
4928
4999
  {
4929
5000
    // Do nothing
4930
5001
  }
4931
5002
 
4932
 
  /// Return a string identifying the dof map
 
5003
  /// Return a string identifying the dofmap
4933
5004
  virtual const char* signature() const
4934
5005
  {
4935
5006
    return "FFC dofmap for FiniteElement('Lagrange', Cell('tetrahedron', 1, Space(3)), 1)";
4965
5036
    return false;
4966
5037
  }
4967
5038
 
4968
 
  /// Initialize dof map for mesh (return true iff init_cell() is needed)
 
5039
  /// Initialize dofmap for mesh (return true iff init_cell() is needed)
4969
5040
  virtual bool init_mesh(const ufc::mesh& m)
4970
5041
  {
4971
5042
    _global_dimension = m.num_entities[0];
4972
5043
    return false;
4973
5044
  }
4974
5045
 
4975
 
  /// Initialize dof map for given cell
 
5046
  /// Initialize dofmap for given cell
4976
5047
  virtual void init_cell(const ufc::mesh& m,
4977
5048
                         const ufc::cell& c)
4978
5049
  {
4979
5050
    // Do nothing
4980
5051
  }
4981
5052
 
4982
 
  /// Finish initialization of dof map for cells
 
5053
  /// Finish initialization of dofmap for cells
4983
5054
  virtual void init_cell_finalize()
4984
5055
  {
4985
5056
    // Do nothing
4986
5057
  }
4987
5058
 
 
5059
  /// Return the topological dimension of the associated cell shape
 
5060
  virtual unsigned int topological_dimension() const
 
5061
  {
 
5062
    return 3;
 
5063
  }
 
5064
 
 
5065
  /// Return the geometric dimension of the associated cell shape
 
5066
  virtual unsigned int geometric_dimension() const
 
5067
  {
 
5068
    return 3;
 
5069
  }
 
5070
 
4988
5071
  /// Return the dimension of the global finite element function space
4989
5072
  virtual unsigned int global_dimension() const
4990
5073
  {
5003
5086
    return 4;
5004
5087
  }
5005
5088
 
5006
 
  // Return the geometric dimension of the coordinates this dof map provides
5007
 
  virtual unsigned int geometric_dimension() const
5008
 
  {
5009
 
    return 3;
5010
 
  }
5011
 
 
5012
5089
  /// Return the number of dofs on each cell facet
5013
5090
  virtual unsigned int num_facet_dofs() const
5014
5091
  {
5177
5254
    coordinates[3][2] = x[3][2];
5178
5255
  }
5179
5256
 
5180
 
  /// Return the number of sub dof maps (for a mixed element)
5181
 
  virtual unsigned int num_sub_dof_maps() const
5182
 
  {
5183
 
    return 0;
5184
 
  }
5185
 
 
5186
 
  /// Create a new dof_map for sub dof map i (for a mixed element)
5187
 
  virtual ufc::dof_map* create_sub_dof_map(unsigned int i) const
5188
 
  {
5189
 
    return 0;
 
5257
  /// Return the number of sub dofmaps (for a mixed element)
 
5258
  virtual unsigned int num_sub_dofmaps() const
 
5259
  {
 
5260
    return 0;
 
5261
  }
 
5262
 
 
5263
  /// Create a new dofmap for sub dofmap i (for a mixed element)
 
5264
  virtual ufc::dofmap* create_sub_dofmap(unsigned int i) const
 
5265
  {
 
5266
    return 0;
 
5267
  }
 
5268
 
 
5269
  /// Create a new class instance
 
5270
  virtual ufc::dofmap* create() const
 
5271
  {
 
5272
    return new elasticity3d_dofmap_0();
5190
5273
  }
5191
5274
 
5192
5275
};
5194
5277
/// This class defines the interface for a local-to-global mapping of
5195
5278
/// degrees of freedom (dofs).
5196
5279
 
5197
 
class elasticity3d_dof_map_1: public ufc::dof_map
 
5280
class elasticity3d_dofmap_1: public ufc::dofmap
5198
5281
{
5199
5282
private:
5200
5283
 
5202
5285
public:
5203
5286
 
5204
5287
  /// Constructor
5205
 
  elasticity3d_dof_map_1() : ufc::dof_map()
 
5288
  elasticity3d_dofmap_1() : ufc::dofmap()
5206
5289
  {
5207
5290
    _global_dimension = 0;
5208
5291
  }
5209
5292
 
5210
5293
  /// Destructor
5211
 
  virtual ~elasticity3d_dof_map_1()
 
5294
  virtual ~elasticity3d_dofmap_1()
5212
5295
  {
5213
5296
    // Do nothing
5214
5297
  }
5215
5298
 
5216
 
  /// Return a string identifying the dof map
 
5299
  /// Return a string identifying the dofmap
5217
5300
  virtual const char* signature() const
5218
5301
  {
5219
5302
    return "FFC dofmap for VectorElement('Lagrange', Cell('tetrahedron', 1, Space(3)), 1, 3)";
5249
5332
    return false;
5250
5333
  }
5251
5334
 
5252
 
  /// Initialize dof map for mesh (return true iff init_cell() is needed)
 
5335
  /// Initialize dofmap for mesh (return true iff init_cell() is needed)
5253
5336
  virtual bool init_mesh(const ufc::mesh& m)
5254
5337
  {
5255
5338
    _global_dimension = 3.000000000000000*m.num_entities[0];
5256
5339
    return false;
5257
5340
  }
5258
5341
 
5259
 
  /// Initialize dof map for given cell
 
5342
  /// Initialize dofmap for given cell
5260
5343
  virtual void init_cell(const ufc::mesh& m,
5261
5344
                         const ufc::cell& c)
5262
5345
  {
5263
5346
    // Do nothing
5264
5347
  }
5265
5348
 
5266
 
  /// Finish initialization of dof map for cells
 
5349
  /// Finish initialization of dofmap for cells
5267
5350
  virtual void init_cell_finalize()
5268
5351
  {
5269
5352
    // Do nothing
5270
5353
  }
5271
5354
 
 
5355
  /// Return the topological dimension of the associated cell shape
 
5356
  virtual unsigned int topological_dimension() const
 
5357
  {
 
5358
    return 3;
 
5359
  }
 
5360
 
 
5361
  /// Return the geometric dimension of the associated cell shape
 
5362
  virtual unsigned int geometric_dimension() const
 
5363
  {
 
5364
    return 3;
 
5365
  }
 
5366
 
5272
5367
  /// Return the dimension of the global finite element function space
5273
5368
  virtual unsigned int global_dimension() const
5274
5369
  {
5287
5382
    return 12;
5288
5383
  }
5289
5384
 
5290
 
  // Return the geometric dimension of the coordinates this dof map provides
5291
 
  virtual unsigned int geometric_dimension() const
5292
 
  {
5293
 
    return 3;
5294
 
  }
5295
 
 
5296
5385
  /// Return the number of dofs on each cell facet
5297
5386
  virtual unsigned int num_facet_dofs() const
5298
5387
  {
5529
5618
    coordinates[11][2] = x[3][2];
5530
5619
  }
5531
5620
 
5532
 
  /// Return the number of sub dof maps (for a mixed element)
5533
 
  virtual unsigned int num_sub_dof_maps() const
 
5621
  /// Return the number of sub dofmaps (for a mixed element)
 
5622
  virtual unsigned int num_sub_dofmaps() const
5534
5623
  {
5535
5624
    return 3;
5536
5625
  }
5537
5626
 
5538
 
  /// Create a new dof_map for sub dof map i (for a mixed element)
5539
 
  virtual ufc::dof_map* create_sub_dof_map(unsigned int i) const
 
5627
  /// Create a new dofmap for sub dofmap i (for a mixed element)
 
5628
  virtual ufc::dofmap* create_sub_dofmap(unsigned int i) const
5540
5629
  {
5541
5630
    switch (i)
5542
5631
    {
5543
5632
    case 0:
5544
5633
      {
5545
 
        return new elasticity3d_dof_map_0();
 
5634
        return new elasticity3d_dofmap_0();
5546
5635
        break;
5547
5636
      }
5548
5637
    case 1:
5549
5638
      {
5550
 
        return new elasticity3d_dof_map_0();
 
5639
        return new elasticity3d_dofmap_0();
5551
5640
        break;
5552
5641
      }
5553
5642
    case 2:
5554
5643
      {
5555
 
        return new elasticity3d_dof_map_0();
 
5644
        return new elasticity3d_dofmap_0();
5556
5645
        break;
5557
5646
      }
5558
5647
    }
5560
5649
    return 0;
5561
5650
  }
5562
5651
 
 
5652
  /// Create a new class instance
 
5653
  virtual ufc::dofmap* create() const
 
5654
  {
 
5655
    return new elasticity3d_dofmap_1();
 
5656
  }
 
5657
 
5563
5658
};
5564
5659
 
5565
5660
/// This class defines the interface for the tabulation of the cell
5629
5724
    // Set scale factor
5630
5725
    const double det = std::abs(detJ);
5631
5726
    
 
5727
    // Cell Volume.
 
5728
    
 
5729
    // Compute circumradius.
 
5730
    
 
5731
    
5632
5732
    // Array of quadrature weights.
5633
5733
    static const double W1 = 0.166666666666666;
5634
5734
    // Quadrature points on the UFC reference element: (0.250000000000000, 0.250000000000000, 0.250000000000000)
5895
5995
    }// end loop over 'j'
5896
5996
  }
5897
5997
 
 
5998
  /// Tabulate the tensor for the contribution from a local cell
 
5999
  /// using the specified reference cell quadrature points/weights
 
6000
  virtual void tabulate_tensor(double* A,
 
6001
                               const double * const * w,
 
6002
                               const ufc::cell& c,
 
6003
                               unsigned int num_quadrature_points,
 
6004
                               const double * const * quadrature_points,
 
6005
                               const double* quadrature_weights) const
 
6006
  {
 
6007
    throw std::runtime_error("Quadrature version of tabulate_tensor not yet implemented (introduced in UFC 2.0).");
 
6008
  }
 
6009
 
5898
6010
};
5899
6011
 
5900
6012
/// This class defines the interface for the assembly of the global
5946
6058
    return 0;
5947
6059
  }
5948
6060
 
5949
 
  /// Return the number of cell integrals
5950
 
  virtual unsigned int num_cell_integrals() const
 
6061
  /// Return the number of cell domains
 
6062
  virtual unsigned int num_cell_domains() const
5951
6063
  {
5952
6064
    return 1;
5953
6065
  }
5954
6066
 
5955
 
  /// Return the number of exterior facet integrals
5956
 
  virtual unsigned int num_exterior_facet_integrals() const
 
6067
  /// Return the number of exterior facet domains
 
6068
  virtual unsigned int num_exterior_facet_domains() const
5957
6069
  {
5958
6070
    return 0;
5959
6071
  }
5960
6072
 
5961
 
  /// Return the number of interior facet integrals
5962
 
  virtual unsigned int num_interior_facet_integrals() const
 
6073
  /// Return the number of interior facet domains
 
6074
  virtual unsigned int num_interior_facet_domains() const
5963
6075
  {
5964
6076
    return 0;
5965
6077
  }
5984
6096
    return 0;
5985
6097
  }
5986
6098
 
5987
 
  /// Create a new dof map for argument function i
5988
 
  virtual ufc::dof_map* create_dof_map(unsigned int i) const
 
6099
  /// Create a new dofmap for argument function i
 
6100
  virtual ufc::dofmap* create_dofmap(unsigned int i) const
5989
6101
  {
5990
6102
    switch (i)
5991
6103
    {
5992
6104
    case 0:
5993
6105
      {
5994
 
        return new elasticity3d_dof_map_1();
 
6106
        return new elasticity3d_dofmap_1();
5995
6107
        break;
5996
6108
      }
5997
6109
    case 1:
5998
6110
      {
5999
 
        return new elasticity3d_dof_map_1();
 
6111
        return new elasticity3d_dofmap_1();
6000
6112
        break;
6001
6113
      }
6002
6114
    }
6046
6158
#include <dolfin/function/FunctionSpace.h>
6047
6159
#include <dolfin/function/GenericFunction.h>
6048
6160
#include <dolfin/function/CoefficientAssigner.h>
 
6161
#include <dolfin/adaptivity/ErrorControl.h>
 
6162
#include <dolfin/adaptivity/GoalFunctional.h>
6049
6163
 
6050
6164
namespace Elasticity3D
6051
6165
{
6057
6171
  Form_0_FunctionSpace_0(const dolfin::Mesh& mesh):
6058
6172
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
6059
6173
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new elasticity3d_finite_element_1()))),
6060
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new elasticity3d_dof_map_1()), mesh)))
 
6174
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new elasticity3d_dofmap_1()), mesh)))
6061
6175
  {
6062
6176
    // Do nothing
6063
6177
  }
6065
6179
  Form_0_FunctionSpace_0(dolfin::Mesh& mesh):
6066
6180
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
6067
6181
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new elasticity3d_finite_element_1()))),
6068
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new elasticity3d_dof_map_1()), mesh)))
 
6182
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new elasticity3d_dofmap_1()), mesh)))
6069
6183
  {
6070
6184
    // Do nothing
6071
6185
  }
6073
6187
  Form_0_FunctionSpace_0(boost::shared_ptr<dolfin::Mesh> mesh):
6074
6188
    dolfin::FunctionSpace(mesh,
6075
6189
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new elasticity3d_finite_element_1()))),
6076
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new elasticity3d_dof_map_1()), *mesh)))
 
6190
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new elasticity3d_dofmap_1()), *mesh)))
6077
6191
  {
6078
6192
      // Do nothing
6079
6193
  }
6081
6195
  Form_0_FunctionSpace_0(boost::shared_ptr<const dolfin::Mesh> mesh):
6082
6196
    dolfin::FunctionSpace(mesh,
6083
6197
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new elasticity3d_finite_element_1()))),
6084
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new elasticity3d_dof_map_1()), *mesh)))
 
6198
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new elasticity3d_dofmap_1()), *mesh)))
6085
6199
  {
6086
6200
      // Do nothing
6087
6201
  }
6099
6213
  Form_0_FunctionSpace_1(const dolfin::Mesh& mesh):
6100
6214
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
6101
6215
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new elasticity3d_finite_element_1()))),
6102
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new elasticity3d_dof_map_1()), mesh)))
 
6216
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new elasticity3d_dofmap_1()), mesh)))
6103
6217
  {
6104
6218
    // Do nothing
6105
6219
  }
6107
6221
  Form_0_FunctionSpace_1(dolfin::Mesh& mesh):
6108
6222
    dolfin::FunctionSpace(dolfin::reference_to_no_delete_pointer(mesh),
6109
6223
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new elasticity3d_finite_element_1()))),
6110
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new elasticity3d_dof_map_1()), mesh)))
 
6224
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new elasticity3d_dofmap_1()), mesh)))
6111
6225
  {
6112
6226
    // Do nothing
6113
6227
  }
6115
6229
  Form_0_FunctionSpace_1(boost::shared_ptr<dolfin::Mesh> mesh):
6116
6230
    dolfin::FunctionSpace(mesh,
6117
6231
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new elasticity3d_finite_element_1()))),
6118
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new elasticity3d_dof_map_1()), *mesh)))
 
6232
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new elasticity3d_dofmap_1()), *mesh)))
6119
6233
  {
6120
6234
      // Do nothing
6121
6235
  }
6123
6237
  Form_0_FunctionSpace_1(boost::shared_ptr<const dolfin::Mesh> mesh):
6124
6238
    dolfin::FunctionSpace(mesh,
6125
6239
                          boost::shared_ptr<const dolfin::FiniteElement>(new dolfin::FiniteElement(boost::shared_ptr<ufc::finite_element>(new elasticity3d_finite_element_1()))),
6126
 
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dof_map>(new elasticity3d_dof_map_1()), *mesh)))
 
6240
                          boost::shared_ptr<const dolfin::DofMap>(new dolfin::DofMap(boost::shared_ptr<ufc::dofmap>(new elasticity3d_dofmap_1()), *mesh)))
6127
6241
  {
6128
6242
      // Do nothing
6129
6243
  }