← Back to branch summary

~ubuntu-branches/ubuntu/saucy/deal.ii/saucy

« back to all changes in this revision

Viewing changes to deal.II/source/grid/tria_objects.all_dimensions.cc

  • Committer: Bazaar Package Importer
  • Author(s): Adam C. Powell, IV
  • Date: 2009-05-08 23:13:50 UTC
  • Revision ID: james.westby@ubuntu.com-20090508231350-rrh1ltgi0tifabwc
Tags: upstream-6.2.0
Import upstream version 6.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
deal.II/source/grid/tria_objects.all_dimensions.cc
 
1
//---------------------------------------------------------------------------
 
2
//    $Id: tria_objects.all_dimensions.cc 16430 2008-07-08 15:25:01Z hartmann $
 
3
//    Version: $Name$
 
4
//
 
5
//    Copyright (C) 2006, 2007 by the deal.II authors
 
6
//
 
7
//    This file is subject to QPL and may not be  distributed
 
8
//    without copyright and license information. Please refer
 
9
//    to the file deal.II/doc/license.html for the  text  and
 
10
//    further information on this license.
 
11
//
 
12
//---------------------------------------------------------------------------
 
13
 
 
14
 
 
15
#include <base/memory_consumption.h>
 
16
#include <grid/tria_objects.h>
 
17
#include <grid/tria.h>
 
18
#include <grid/tria_iterator.h>
 
19
#include <grid/tria_accessor.h>
 
20
 
 
21
#include <algorithm>
 
22
#include <functional>
 
23
 
 
24
    
 
25
 
 
26
DEAL_II_NAMESPACE_OPEN
 
27
 
 
28
namespace internal
 
29
{
 
30
  namespace Triangulation
 
31
  {    
 
32
    template<>
 
33
    void
 
34
    TriaObjects<TriaObject<1> >::reserve_space (const unsigned int new_lines_in_pairs,
 
35
                                      const unsigned int new_lines_single)
 
36
    {
 
37
      Assert(new_lines_in_pairs%2==0, ExcInternalError());
 
38
 
 
39
      next_free_single=0;
 
40
      next_free_pair=0;
 
41
      reverse_order_next_free_single=false;
 
42
      
 
43
                                       // count the number of lines, of
 
44
                                       // unused single lines and of
 
45
                                       // unused pairs of lines
 
46
      unsigned int n_lines=0;
 
47
      unsigned int n_unused_pairs=0;
 
48
      unsigned int n_unused_singles=0;
 
49
      for (unsigned int i=0; i<used.size(); ++i)
 
50
        {
 
51
          if (used[i])
 
52
            ++n_lines;
 
53
          else if (i+1<used.size())
 
54
            {
 
55
              if (used[i+1])
 
56
                {
 
57
                  ++n_unused_singles;
 
58
                  if (next_free_single==0)
 
59
                    next_free_single=i;
 
60
                }
 
61
              else
 
62
                {
 
63
                  ++n_unused_pairs;
 
64
                  if (next_free_pair==0)
 
65
                    next_free_pair=i;
 
66
                  ++i;
 
67
                }
 
68
            }
 
69
          else
 
70
            ++n_unused_singles;
 
71
        }
 
72
      Assert(n_lines+2*n_unused_pairs+n_unused_singles==used.size(),
 
73
             ExcInternalError());
 
74
 
 
75
                                       // how many single lines are needed in
 
76
                                       // addition to n_unused_singles?
 
77
      const int additional_single_lines=
 
78
        new_lines_single-n_unused_singles;
 
79
 
 
80
      unsigned int new_size=
 
81
        used.size() + new_lines_in_pairs - 2*n_unused_pairs;
 
82
      if (additional_single_lines>0)
 
83
        new_size+=additional_single_lines;
 
84
 
 
85
                                       // only allocate space if necessary
 
86
      if (new_size>cells.size()) 
 
87
        {
 
88
          cells.reserve (new_size);
 
89
          cells.insert (cells.end(),
 
90
                        new_size-cells.size(),
 
91
                        TriaObject<1> ());
 
92
  
 
93
          used.reserve (new_size);
 
94
          used.insert (used.end(),
 
95
                       new_size-used.size(),
 
96
                       false);
 
97
  
 
98
          user_flags.reserve (new_size);
 
99
          user_flags.insert (user_flags.end(),
 
100
                             new_size-user_flags.size(),
 
101
                             false);
 
102
      
 
103
          children.reserve (new_size);
 
104
          children.insert (children.end(),
 
105
                           new_size-children.size(),
 
106
                           -1);
 
107
 
 
108
          material_id.reserve (new_size);
 
109
          material_id.insert (material_id.end(),
 
110
                              new_size-material_id.size(),
 
111
                              255);
 
112
 
 
113
          user_data.reserve (new_size);
 
114
          user_data.insert (user_data.end(),
 
115
                            new_size-user_data.size(),
 
116
                            UserData());
 
117
        }
 
118
 
 
119
      if (n_unused_singles==0)
 
120
        {
 
121
          next_free_single=new_size-1;
 
122
          reverse_order_next_free_single=true;
 
123
        }
 
124
    }
 
125
 
 
126
 
 
127
    template<>
 
128
    void
 
129
    TriaObjects<TriaObject<2> >::reserve_space (const unsigned int new_quads_in_pairs,
 
130
                                      const unsigned int new_quads_single)
 
131
    {
 
132
      Assert(new_quads_in_pairs%2==0, ExcInternalError());
 
133
      
 
134
      next_free_single=0;
 
135
      next_free_pair=0;
 
136
      reverse_order_next_free_single=false;
 
137
 
 
138
                                       // count the number of lines, of
 
139
                                       // unused single lines and of
 
140
                                       // unused pairs of lines
 
141
      unsigned int n_quads=0;
 
142
      unsigned int n_unused_pairs=0;
 
143
      unsigned int n_unused_singles=0;
 
144
      for (unsigned int i=0; i<used.size(); ++i)
 
145
        {
 
146
          if (used[i])
 
147
            ++n_quads;
 
148
          else if (i+1<used.size())
 
149
            {
 
150
              if (used[i+1])
 
151
                {
 
152
                  ++n_unused_singles;
 
153
                  if (next_free_single==0)
 
154
                    next_free_single=i;
 
155
                }
 
156
              else
 
157
                {
 
158
                  ++n_unused_pairs;
 
159
                  if (next_free_pair==0)
 
160
                    next_free_pair=i;
 
161
                  ++i;
 
162
                }
 
163
            }
 
164
          else
 
165
            ++n_unused_singles;
 
166
        }
 
167
      Assert(n_quads+2*n_unused_pairs+n_unused_singles==used.size(),
 
168
             ExcInternalError());
 
169
 
 
170
                                       // how many single quads are needed in
 
171
                                       // addition to n_unused_quads?
 
172
      const int additional_single_quads=
 
173
        new_quads_single-n_unused_singles;
 
174
 
 
175
      unsigned int new_size=
 
176
        used.size() + new_quads_in_pairs - 2*n_unused_pairs;
 
177
      if (additional_single_quads>0)
 
178
        new_size+=additional_single_quads;
 
179
 
 
180
                                       // only allocate space if necessary
 
181
      if (new_size>cells.size())
 
182
        {
 
183
          cells.reserve (new_size);
 
184
          cells.insert (cells.end(),
 
185
                        new_size-cells.size(),
 
186
                        TriaObject<2> ());
 
187
      
 
188
          used.reserve (new_size);
 
189
          used.insert (used.end(),
 
190
                       new_size-used.size(),
 
191
                       false);
 
192
  
 
193
          user_flags.reserve (new_size);
 
194
          user_flags.insert (user_flags.end(),
 
195
                             new_size-user_flags.size(),
 
196
                             false);
 
197
  
 
198
          children.reserve (2*new_size);
 
199
          children.insert (children.end(),
 
200
                           2*new_size-children.size(),
 
201
                           -1);
 
202
 
 
203
          refinement_cases.reserve (new_size);
 
204
          refinement_cases.insert (refinement_cases.end(),
 
205
                               new_size - refinement_cases.size(),
 
206
                               RefinementCase<2>::no_refinement);
 
207
          
 
208
 
 
209
          material_id.reserve (new_size);
 
210
          material_id.insert (material_id.end(),
 
211
                              new_size-material_id.size(),
 
212
                              255);
 
213
 
 
214
          user_data.reserve (new_size);
 
215
          user_data.insert (user_data.end(),
 
216
                            new_size-user_data.size(),
 
217
                            UserData());
 
218
        }
 
219
 
 
220
      if (n_unused_singles==0)
 
221
        {
 
222
          next_free_single=new_size-1;
 
223
          reverse_order_next_free_single=true;
 
224
        }
 
225
    }
 
226
 
 
227
 
 
228
    void
 
229
    TriaObjectsHex::reserve_space (const unsigned int new_hexes)
 
230
    {
 
231
      const unsigned int new_size = new_hexes +
 
232
                                    std::count_if (used.begin(),
 
233
                                                   used.end(),
 
234
                                                   std::bind2nd (std::equal_to<bool>(), true));
 
235
 
 
236
                                       // see above...
 
237
      if (new_size>cells.size())
 
238
        {
 
239
          cells.reserve (new_size);
 
240
          cells.insert (cells.end(),
 
241
                        new_size-cells.size(),
 
242
                        TriaObject<3> ());
 
243
      
 
244
          used.reserve (new_size);
 
245
          used.insert (used.end(),
 
246
                       new_size-used.size(),
 
247
                       false);
 
248
  
 
249
          user_flags.reserve (new_size);
 
250
          user_flags.insert (user_flags.end(),
 
251
                             new_size-user_flags.size(),
 
252
                             false);
 
253
  
 
254
          children.reserve (4*new_size);
 
255
          children.insert (children.end(),
 
256
                           4*new_size-children.size(),
 
257
                           -1);
 
258
 
 
259
          material_id.reserve (new_size);
 
260
          material_id.insert (material_id.end(),
 
261
                              new_size-material_id.size(),
 
262
                              255);
 
263
 
 
264
          user_data.reserve (new_size);
 
265
          user_data.insert (user_data.end(),
 
266
                            new_size-user_data.size(),
 
267
                            UserData());
 
268
 
 
269
          face_orientations.reserve (new_size * GeometryInfo<3>::faces_per_cell);
 
270
          face_orientations.insert (face_orientations.end(),
 
271
                                    new_size * GeometryInfo<3>::faces_per_cell
 
272
                                    - face_orientations.size(),
 
273
                                    true);
 
274
 
 
275
          refinement_cases.reserve (new_size);
 
276
          refinement_cases.insert (refinement_cases.end(),
 
277
                               new_size-refinement_cases.size(),
 
278
                               RefinementCase<3>::no_refinement);
 
279
 
 
280
          face_flips.reserve (new_size * GeometryInfo<3>::faces_per_cell);
 
281
          face_flips.insert (face_flips.end(),
 
282
                                    new_size * GeometryInfo<3>::faces_per_cell
 
283
                                    - face_flips.size(),
 
284
                                    false);
 
285
          face_rotations.reserve (new_size * GeometryInfo<3>::faces_per_cell);
 
286
          face_rotations.insert (face_rotations.end(),
 
287
                                    new_size * GeometryInfo<3>::faces_per_cell
 
288
                                    - face_rotations.size(),
 
289
                                    false);
 
290
        }
 
291
      next_free_single=next_free_pair=0;
 
292
    }
 
293
 
 
294
 
 
295
    void
 
296
    TriaObjectsQuad3D::reserve_space (const unsigned int new_quads_in_pairs,
 
297
                                      const unsigned int new_quads_single)
 
298
    {
 
299
      Assert(new_quads_in_pairs%2==0, ExcInternalError());
 
300
 
 
301
      next_free_single=0;
 
302
      next_free_pair=0;
 
303
      reverse_order_next_free_single=false;
 
304
 
 
305
                                       // count the number of lines, of unused
 
306
                                       // single lines and of unused pairs of
 
307
                                       // lines
 
308
      unsigned int n_quads=0;
 
309
      unsigned int n_unused_pairs=0;
 
310
      unsigned int n_unused_singles=0;
 
311
      for (unsigned int i=0; i<used.size(); ++i)
 
312
        {
 
313
          if (used[i])
 
314
            ++n_quads;
 
315
          else if (i+1<used.size())
 
316
            {
 
317
              if (used[i+1])
 
318
                {
 
319
                  ++n_unused_singles;
 
320
                  if (next_free_single==0)
 
321
                    next_free_single=i;
 
322
                }
 
323
              else
 
324
                {
 
325
                  ++n_unused_pairs;
 
326
                  if (next_free_pair==0)
 
327
                    next_free_pair=i;
 
328
                  ++i;
 
329
                }
 
330
            }
 
331
          else
 
332
            ++n_unused_singles;
 
333
        }
 
334
      Assert(n_quads+2*n_unused_pairs+n_unused_singles==used.size(),
 
335
             ExcInternalError());
 
336
 
 
337
                                       // how many single quads are needed in
 
338
                                       // addition to n_unused_quads?
 
339
      const int additional_single_quads=
 
340
        new_quads_single-n_unused_singles;
 
341
 
 
342
      unsigned int new_size=
 
343
        used.size() + new_quads_in_pairs - 2*n_unused_pairs;
 
344
      if (additional_single_quads>0)
 
345
        new_size+=additional_single_quads;
 
346
      
 
347
                                       // see above...
 
348
      if (new_size>cells.size())
 
349
        {
 
350
                                           // reseve space for the base class
 
351
          TriaObjects<TriaObject<2> >::reserve_space(new_quads_in_pairs,new_quads_single);
 
352
                                           // reserve the field of the derived
 
353
                                           // class
 
354
          line_orientations.reserve (new_size * GeometryInfo<2>::lines_per_cell);
 
355
          line_orientations.insert (line_orientations.end(),
 
356
                                    new_size * GeometryInfo<2>::lines_per_cell
 
357
                                    - line_orientations.size(),
 
358
                                    true);
 
359
        }
 
360
 
 
361
      if (n_unused_singles==0)
 
362
        {
 
363
          next_free_single=new_size-1;
 
364
          reverse_order_next_free_single=true;
 
365
        }
 
366
    }
 
367
    
 
368
 
 
369
    template<>
 
370
    void
 
371
    TriaObjects<TriaObject<1> >::monitor_memory (const unsigned int) const
 
372
    {
 
373
                                       // check that we have not allocated
 
374
                                       // too much memory. note that bool
 
375
                                       // vectors allocate their memory in
 
376
                                       // chunks of whole integers, so
 
377
                                       // they may over-allocate by up to
 
378
                                       // as many elements as an integer
 
379
                                       // has bits
 
380
      Assert (cells.size() <=
 
381
              cells.capacity() + DEAL_II_MIN_VECTOR_CAPACITY,
 
382
              ExcMemoryWasted ("lines",
 
383
                               cells.size(), cells.capacity()));
 
384
      Assert (children.size() <=
 
385
              children.capacity() + DEAL_II_MIN_VECTOR_CAPACITY,
 
386
              ExcMemoryWasted ("children",
 
387
                               children.size(), children.capacity()));
 
388
      Assert (used.size() <= used.capacity() + sizeof(int)*8 ||
 
389
              used.size()<DEAL_II_MIN_BOOL_VECTOR_CAPACITY,
 
390
              ExcMemoryWasted ("used",
 
391
                               used.size(), used.capacity()));
 
392
      Assert (user_flags.size() <= user_flags.capacity() + sizeof(int)*8 ||
 
393
              user_flags.size()<DEAL_II_MIN_BOOL_VECTOR_CAPACITY,
 
394
              ExcMemoryWasted ("user_flags",
 
395
                               user_flags.size(), user_flags.capacity()));
 
396
      Assert (cells.size() == used.size(),
 
397
              ExcMemoryInexact (cells.size(), used.size()));
 
398
      Assert (cells.size() == user_flags.size(),
 
399
              ExcMemoryInexact (cells.size(), user_flags.size()));
 
400
      Assert (cells.size() == children.size(),
 
401
              ExcMemoryInexact (cells.size(), children.size()));
 
402
      Assert (cells.size() == material_id.size(),
 
403
              ExcMemoryInexact (cells.size(), material_id.size()));
 
404
      Assert (cells.size() == user_data.size(),
 
405
              ExcMemoryInexact (cells.size(), user_data.size()));
 
406
    }
 
407
 
 
408
 
 
409
    template<>
 
410
    void
 
411
    TriaObjects<TriaObject<2> >::monitor_memory (const unsigned int) const
 
412
    {
 
413
                                       // check that we have not allocated
 
414
                                       // too much memory. note that bool
 
415
                                       // vectors allocate their memory in
 
416
                                       // chunks of whole integers, so
 
417
                                       // they may over-allocate by up to
 
418
                                       // as many elements as an integer
 
419
                                       // has bits
 
420
      Assert (cells.size() <=
 
421
              cells.capacity() + DEAL_II_MIN_VECTOR_CAPACITY,
 
422
              ExcMemoryWasted ("quads",
 
423
                               cells.size(), cells.capacity()));
 
424
      Assert (children.size() <=
 
425
              children.capacity() + DEAL_II_MIN_VECTOR_CAPACITY,
 
426
              ExcMemoryWasted ("children",
 
427
                               children.size(), children.capacity()));
 
428
      Assert (used.size() <= used.capacity() + sizeof(int)*8 ||
 
429
              used.size()<DEAL_II_MIN_BOOL_VECTOR_CAPACITY,
 
430
              ExcMemoryWasted ("used",
 
431
                               used.size(), used.capacity()));
 
432
      Assert (user_flags.size() <= user_flags.capacity() + sizeof(int)*8 ||
 
433
              user_flags.size()<DEAL_II_MIN_BOOL_VECTOR_CAPACITY,
 
434
              ExcMemoryWasted ("user_flags",
 
435
                               user_flags.size(), user_flags.capacity()));
 
436
      Assert (cells.size() == used.size(),
 
437
              ExcMemoryInexact (cells.size(), used.size()));
 
438
      Assert (cells.size() == user_flags.size(),
 
439
              ExcMemoryInexact (cells.size(), user_flags.size()));
 
440
      Assert (2*cells.size() == children.size(),
 
441
              ExcMemoryInexact (cells.size(), children.size()));
 
442
      Assert (cells.size() == refinement_cases.size(),
 
443
              ExcMemoryInexact (cells.size(), refinement_cases.size()));
 
444
      Assert (cells.size() == material_id.size(),
 
445
              ExcMemoryInexact (cells.size(), material_id.size()));
 
446
      Assert (cells.size() == user_data.size(),
 
447
              ExcMemoryInexact (cells.size(), user_data.size()));
 
448
    }
 
449
 
 
450
 
 
451
    void
 
452
    TriaObjectsHex::monitor_memory (const unsigned int) const
 
453
    {
 
454
                                       // check that we have not allocated
 
455
                                       // too much memory. note that bool
 
456
                                       // vectors allocate their memory in
 
457
                                       // chunks of whole integers, so
 
458
                                       // they may over-allocate by up to
 
459
                                       // as many elements as an integer
 
460
                                       // has bits
 
461
      Assert (cells.size() <=
 
462
              cells.capacity() + DEAL_II_MIN_VECTOR_CAPACITY,
 
463
              ExcMemoryWasted ("hexes",
 
464
                               cells.size(), cells.capacity()));
 
465
      Assert (children.size() <=
 
466
              children.capacity() + DEAL_II_MIN_VECTOR_CAPACITY,
 
467
              ExcMemoryWasted ("children",
 
468
                               children.size(), children.capacity()));
 
469
      Assert (used.size() <= used.capacity() + sizeof(int)*8 ||
 
470
              used.size()<DEAL_II_MIN_BOOL_VECTOR_CAPACITY,
 
471
              ExcMemoryWasted ("used",
 
472
                               used.size(), used.capacity()));
 
473
      Assert (user_flags.size() <= user_flags.capacity() + sizeof(int)*8 ||
 
474
              user_flags.size()<DEAL_II_MIN_BOOL_VECTOR_CAPACITY,
 
475
              ExcMemoryWasted ("user_flags",
 
476
                               user_flags.size(), user_flags.capacity()));
 
477
      Assert (cells.size() == used.size(),
 
478
              ExcMemoryInexact (cells.size(), used.size()));
 
479
      Assert (cells.size() == user_flags.size(),
 
480
              ExcMemoryInexact (cells.size(), user_flags.size()));
 
481
      Assert (4*cells.size() == children.size(),
 
482
              ExcMemoryInexact (cells.size(), children.size()));
 
483
      Assert (cells.size() == material_id.size(),
 
484
              ExcMemoryInexact (cells.size(), material_id.size()));
 
485
      Assert (cells.size() == user_data.size(),
 
486
              ExcMemoryInexact (cells.size(), user_data.size()));
 
487
      Assert (cells.size() * GeometryInfo<3>::faces_per_cell
 
488
              == face_orientations.size(),
 
489
              ExcMemoryInexact (cells.size() * GeometryInfo<3>::faces_per_cell,
 
490
                                face_orientations.size()));
 
491
      Assert (cells.size() * GeometryInfo<3>::faces_per_cell
 
492
              == face_flips.size(),
 
493
              ExcMemoryInexact (cells.size() * GeometryInfo<3>::faces_per_cell,
 
494
                                face_flips.size()));
 
495
      Assert (cells.size() * GeometryInfo<3>::faces_per_cell
 
496
              == face_rotations.size(),
 
497
              ExcMemoryInexact (cells.size() * GeometryInfo<3>::faces_per_cell,
 
498
                                face_rotations.size()));
 
499
    }
 
500
 
 
501
 
 
502
    void
 
503
    TriaObjectsQuad3D::monitor_memory (const unsigned int) const
 
504
    {
 
505
                                       // check that we have not allocated
 
506
                                       // too much memory. note that bool
 
507
                                       // vectors allocate their memory in
 
508
                                       // chunks of whole integers, so
 
509
                                       // they may over-allocate by up to
 
510
                                       // as many elements as an integer
 
511
                                       // has bits
 
512
      Assert (cells.size() * GeometryInfo<2>::lines_per_cell
 
513
              == line_orientations.size(),
 
514
              ExcMemoryInexact (cells.size() * GeometryInfo<2>::lines_per_cell,
 
515
                                line_orientations.size()));
 
516
      TriaObjects<TriaObject<2> >::monitor_memory (3);
 
517
      
 
518
    }
 
519
 
 
520
 
 
521
    template <typename G>
 
522
    void
 
523
    TriaObjects<G>::clear()
 
524
    {
 
525
      cells.clear();
 
526
      children.clear();
 
527
      refinement_cases.clear();
 
528
      used.clear();
 
529
      user_flags.clear();
 
530
      material_id.clear();
 
531
      user_data.clear();
 
532
      user_data_type = data_unknown;
 
533
    }
 
534
    
 
535
 
 
536
    void
 
537
    TriaObjectsHex::clear()
 
538
    {
 
539
      TriaObjects<TriaObject<3> >::clear();
 
540
      face_orientations.clear();
 
541
      face_flips.clear();
 
542
      face_rotations.clear();
 
543
    }
 
544
 
 
545
 
 
546
    void
 
547
    TriaObjectsQuad3D::clear()
 
548
    {
 
549
      TriaObjects<TriaObject<2> >::clear();
 
550
      line_orientations.clear();
 
551
    }
 
552
    
 
553
    
 
554
    template<typename G>
 
555
    unsigned int
 
556
    TriaObjects<G>::memory_consumption () const
 
557
    {
 
558
      return (MemoryConsumption::memory_consumption (cells) +
 
559
              MemoryConsumption::memory_consumption (children) +
 
560
              MemoryConsumption::memory_consumption (used) +
 
561
              MemoryConsumption::memory_consumption (user_flags) +
 
562
              MemoryConsumption::memory_consumption (material_id) +
 
563
              MemoryConsumption::memory_consumption (refinement_cases) +
 
564
              user_data.capacity() * sizeof(UserData) + sizeof(user_data));
 
565
    }
 
566
  
 
567
 
 
568
    unsigned int
 
569
    TriaObjectsHex::memory_consumption () const
 
570
    {
 
571
      return (MemoryConsumption::memory_consumption (face_orientations) +
 
572
              MemoryConsumption::memory_consumption (face_flips) +
 
573
              MemoryConsumption::memory_consumption (face_rotations) +
 
574
              TriaObjects<TriaObject<3> >::memory_consumption() );
 
575
    }
 
576
 
 
577
 
 
578
    unsigned int
 
579
    TriaObjectsQuad3D::memory_consumption () const
 
580
    {
 
581
      return (MemoryConsumption::memory_consumption (line_orientations) +
 
582
              this->TriaObjects<TriaObject<2> >::memory_consumption() );
 
583
    }
 
584
 
 
585
    
 
586
 
 
587
                                     // explicit instantiations
 
588
 
 
589
    template class TriaObjects<TriaObject<1> >;
 
590
    template class TriaObjects<TriaObject<2> >;
 
591
  }
 
592
}
 
593
 
 
594
DEAL_II_NAMESPACE_CLOSE
 
595