← Back to branch summary

~corrado-maurini/dolfin/tao

« back to all changes in this revision

Viewing changes to dolfin/io/BinaryFile.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/io/BinaryFile.cpp
52
52
{
53
53
  open_read();
54
54
 
55
 
  const uint n = read_uint();
 
55
  const std::size_t n = read_uint();
56
56
  values.resize(n);
57
57
  read_array(n, &values[0]);
58
58
 
63
63
{
64
64
  open_read();
65
65
 
66
 
  const uint n = read_uint();
 
66
  const std::size_t n = read_uint();
67
67
  std::vector<double> values(n);
68
68
  read_array(n, values.data());
69
69
 
83
83
 
84
84
  // Read mesh topology
85
85
  MeshTopology& t = mesh._topology;
86
 
  uint D = read_uint();
 
86
  std::size_t D = read_uint();
87
87
  t.num_entities.resize(D + 1);
88
88
  read_array(D + 1, t.num_entities.data());
89
89
  t.connectivity.resize(D + 1);
90
 
  for (uint i = 0; i <= D; i++)
 
90
  for (std::size_t i = 0; i <= D; i++)
91
91
  {
92
 
    for (uint j = 0; j <= D; j++)
 
92
    for (std::size_t j = 0; j <= D; j++)
93
93
    {
94
94
      t.connectivity[i].push_back(MeshConnectivity(i, j));
95
95
      MeshConnectivity& c = t.connectivity[i][j];
96
 
      const uint size = read_uint();
 
96
      const std::size_t size = read_uint();
97
97
      if (size > 0)
98
98
      {
99
 
        const uint num_entities = read_uint();
100
 
        c.connections = std::vector<uint>(size);
 
99
        const std::size_t num_entities = read_uint();
 
100
        c.connections = std::vector<std::size_t>(size);
101
101
        read_array(size, &(c.connections)[0]);
102
102
        c.index_to_position.resize(num_entities + 1);
103
103
        read_array(c.index_to_position.size(), &(c.index_to_position[0]));
108
108
  // Read mesh geometry (ignoring higher order stuff)
109
109
  MeshGeometry& g = mesh._geometry;
110
110
  g._dim = read_uint();
111
 
  const uint size = read_uint();
 
111
  const std::size_t size = read_uint();
112
112
  g.coordinates.resize(g._dim*size);
113
113
  read_array(g._dim*size, g.coordinates.data());
114
114
 
142
142
{
143
143
  open_write();
144
144
 
145
 
  const uint n = vector.size();
 
145
  const std::size_t n = vector.size();
146
146
  std::vector<double> values(n);
147
147
  vector.get_local(values);
148
148
  write_uint(n);
158
158
 
159
159
  // Write mesh topology
160
160
  const MeshTopology& t = mesh._topology;
161
 
  const uint D = t.dim();
 
161
  const std::size_t D = t.dim();
162
162
  write_uint(D);
163
163
  if (_store_connectivity)
164
164
    write_array(D + 1, t.num_entities.data());
165
165
  else
166
166
  {
167
 
    for (uint i = 0; i <= D; i++)
 
167
    for (std::size_t i = 0; i <= D; i++)
168
168
    {
169
169
      if (i==0 || i == D)
170
170
        write_uint(t.size(i));
172
172
        write_uint(0);
173
173
    }
174
174
  }
175
 
  for (uint i = 0; i <= D; i++)
 
175
  for (std::size_t i = 0; i <= D; i++)
176
176
  {
177
 
    for (uint j = 0; j <= D; j++)
 
177
    for (std::size_t j = 0; j <= D; j++)
178
178
    {
179
179
      const MeshConnectivity& c = t.connectivity[i][j];
180
180
 
201
201
  write_array(g._dim*g.size(), g.coordinates.data());
202
202
 
203
203
  // Write cell type
204
 
  write_uint(static_cast<uint>(mesh._cell_type->cell_type()));
 
204
  write_uint(static_cast<std::size_t>(mesh._cell_type->cell_type()));
205
205
 
206
206
  // Write mesh data
207
207
  // FIXME: Not implemented
269
269
  ofilter.reset();
270
270
}
271
271
//-----------------------------------------------------------------------------
272
 
dolfin::uint BinaryFile::read_uint()
 
272
std::size_t BinaryFile::read_uint()
273
273
{
274
 
  uint value = 0;
275
 
  boost::iostreams::read(ifilter, (char*) &value, (std::streamsize) sizeof(uint));
 
274
  std::size_t value = 0;
 
275
  boost::iostreams::read(ifilter, (char*) &value, (std::streamsize) sizeof(std::size_t));
276
276
  return value;
277
277
}
278
278
//-----------------------------------------------------------------------------
279
 
void BinaryFile::read_array(uint n, uint* values)
 
279
void BinaryFile::read_array(std::size_t n, std::size_t* values)
280
280
{
281
 
  for (uint i = 0; i < n; ++i)
282
 
    boost::iostreams::read(ifilter, (char*) (values + i), (std::streamsize) sizeof(uint));
 
281
  for (std::size_t i = 0; i < n; ++i)
 
282
    boost::iostreams::read(ifilter, (char*) (values + i), (std::streamsize) sizeof(std::size_t));
283
283
}
284
284
//-----------------------------------------------------------------------------
285
 
void BinaryFile::read_array(uint n, double* values)
 
285
void BinaryFile::read_array(std::size_t n, double* values)
286
286
{
287
 
  for (uint i = 0; i < n; ++i)
 
287
  for (std::size_t i = 0; i < n; ++i)
288
288
    boost::iostreams::read(ifilter, (char*) (values + i), (std::streamsize) sizeof(double));
289
289
}
290
290
//-----------------------------------------------------------------------------
291
 
void BinaryFile::write_uint(uint value)
292
 
{
293
 
  boost::iostreams::write(ofilter, (char*) &value, (std::streamsize) sizeof(uint));
294
 
}
295
 
//-----------------------------------------------------------------------------
296
 
void BinaryFile::write_array(uint n, const uint* values)
297
 
{
298
 
  for (uint i = 0; i < n; ++i)
299
 
    boost::iostreams::write(ofilter, (char*) &values[i], (std::streamsize) sizeof(uint));
300
 
}
301
 
//-----------------------------------------------------------------------------
302
 
void BinaryFile::write_array(uint n, const double* values)
303
 
{
304
 
  for (uint i = 0; i < n; ++i)
 
291
void BinaryFile::write_uint(std::size_t value)
 
292
{
 
293
  boost::iostreams::write(ofilter, (char*) &value, (std::streamsize) sizeof(std::size_t));
 
294
}
 
295
//-----------------------------------------------------------------------------
 
296
void BinaryFile::write_array(std::size_t n, const std::size_t* values)
 
297
{
 
298
  for (std::size_t i = 0; i < n; ++i)
 
299
    boost::iostreams::write(ofilter, (char*) &values[i], (std::streamsize) sizeof(std::size_t));
 
300
}
 
301
//-----------------------------------------------------------------------------
 
302
void BinaryFile::write_array(std::size_t n, const double* values)
 
303
{
 
304
  for (std::size_t i = 0; i < n; ++i)
305
305
    boost::iostreams::write(ofilter, (char*) &values[i], (std::streamsize) sizeof(double));
306
306
}
307
307
//-----------------------------------------------------------------------------