← Back to branch summary

~corrado-maurini/dolfin/tao

« back to all changes in this revision

Viewing changes to dolfin/mesh/PointCell.cpp

  • Committer: corrado maurini
  • Date: 2012-12-18 12:16:08 UTC
  • mfrom: (6685.78.207 trunk)
  • Revision ID: corrado.maurini@upmc.fr-20121218121608-nk82ly9jgsld9u84
updating with trunk, fix uint in TAO solver and hacking the check for tao FindTAO.cmake

Show diffs side-by-side

added added

removed removed

Lines of Context:
dolfin/mesh/PointCell.cpp
32
32
using namespace dolfin;
33
33
 
34
34
//-----------------------------------------------------------------------------
35
 
dolfin::uint PointCell::dim() const
 
35
std::size_t PointCell::dim() const
36
36
{
37
37
  return 0;
38
38
}
39
39
//-----------------------------------------------------------------------------
40
 
dolfin::uint PointCell::num_entities(uint dim) const
 
40
std::size_t PointCell::num_entities(std::size_t dim) const
41
41
{
42
42
  switch (dim)
43
43
  {
52
52
  return 0;
53
53
}
54
54
//-----------------------------------------------------------------------------
55
 
dolfin::uint PointCell::num_vertices(uint dim) const
 
55
std::size_t PointCell::num_vertices(std::size_t dim) const
56
56
{
57
57
  switch (dim)
58
58
  {
67
67
  return 0;
68
68
}
69
69
//-----------------------------------------------------------------------------
70
 
dolfin::uint PointCell::orientation(const Cell& cell) const
 
70
std::size_t PointCell::orientation(const Cell& cell) const
71
71
{
72
72
  dolfin_error("PointCell.cpp",
73
73
               "find orientation",
75
75
  return 0;
76
76
}
77
77
//-----------------------------------------------------------------------------
78
 
void PointCell::create_entities(std::vector<std::vector<uint> >& e, uint dim,
79
 
                                const uint* v) const
 
78
void PointCell::create_entities(std::vector<std::vector<std::size_t> >& e,
 
79
                                std::size_t dim,
 
80
                                const std::size_t* v) const
80
81
{
81
82
  dolfin_error("PointCell.cpp",
82
83
               "create entities",
84
85
}
85
86
//-----------------------------------------------------------------------------
86
87
void PointCell::refine_cell(Cell& cell, MeshEditor& editor,
87
 
                          uint& current_cell) const
 
88
                          std::size_t& current_cell) const
88
89
{
89
90
  dolfin_error("PointCell.cpp",
90
91
               "refine cell",
107
108
  return 0.0;
108
109
}
109
110
//-----------------------------------------------------------------------------
110
 
double PointCell::normal(const Cell& cell, uint facet, uint i) const
 
111
double PointCell::normal(const Cell& cell, std::size_t facet, std::size_t i) const
111
112
{
112
113
  dolfin_error("PointCell.cpp",
113
114
               "find component of normal vector of cell",
115
116
  return 0.0;
116
117
}
117
118
//-----------------------------------------------------------------------------
118
 
Point PointCell::normal(const Cell& cell, uint facet) const
 
119
Point PointCell::normal(const Cell& cell, std::size_t facet) const
119
120
{
120
121
  dolfin_error("PointCell.cpp",
121
122
               "find normal vector of cell",
124
125
  return p;
125
126
}
126
127
//-----------------------------------------------------------------------------
127
 
double PointCell::facet_area(const Cell& cell, uint facet) const
 
128
double PointCell::facet_area(const Cell& cell, std::size_t facet) const
128
129
{
129
130
  dolfin_error("PointCell.cpp",
130
131
               "find facet area of cell",
133
134
}
134
135
//-----------------------------------------------------------------------------
135
136
void PointCell::order(Cell& cell,
136
 
                 const std::vector<uint>& local_to_global_vertex_indices) const
 
137
                 const std::vector<std::size_t>& local_to_global_vertex_indices) const
137
138
{
138
139
  dolfin_error("PointCell.cpp",
139
140
               "order cell",
147
148
  return "points";
148
149
}
149
150
//-----------------------------------------------------------------------------
150
 
dolfin::uint PointCell::find_edge(uint i, const Cell& cell) const
 
151
std::size_t PointCell::find_edge(std::size_t i, const Cell& cell) const
151
152
{
152
153
  dolfin_error("PointCell.cpp",
153
154
               "find edge",